Change initrd 'executable' bool to type enum.

Not actually integrating with the kernel yet.

.git-commit-template

@@ -1,11 +0,0 @@
-[section] Imperative-voiced title in less than 50
-
-# Body describes what was done, and why. New obviously-needed features
-# don't necessarily require a why.
-
-# Links to relevant bugs or web pages
-See: Github bug #242
-See: [frobozz blog post](https://jsix.dev/posts/frobozz/)
-
-# Tags and keywords useful for searching
-Tags:

assets/debugging/jsix.elf-gdb.py

@@ -24,5 +24,8 @@ class PrintStackCommand(gdb.Command):
 
 PrintStackCommand()
 
+import time
+time.sleep(3.5)
 gdb.execute("target remote :1234")
+gdb.execute("set waiting = false")
 gdb.execute("display/i $rip")

assets/initrd.toml

@@ -8,6 +8,11 @@
 #                               # initial application for the kernel to execute
 #                               # on startup
 
+[[files]]
+dest = "vdso.so"
+source = "host/libvdso.so"
+type = "vdso"
+
 [[files]]
 dest = "screenfont.psf"
 source = "../assets/fonts/tamsyn8x16r.psf"
@@ -15,9 +20,9 @@ source = "../assets/fonts/tamsyn8x16r.psf"
 [[files]]
 dest = "nulldrv1"
 source = "user/nulldrv"
-executable = true
+type = "executable"
 
 [[files]]
 dest = "nulldrv2"
 source = "user/nulldrv"
-executable = true
+type = "executable"

external/uefi/boot_services.h

@@ -1,101 +0,0 @@
-#pragma once
-#ifndef _uefi_boot_services_h_
-#define _uefi_boot_services_h_
-
-// This Source Code Form is part of the j6-uefi-headers project and is subject
-// to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was
-// not distributed with this file, You can obtain one at
-// http://mozilla.org/MPL/2.0/.
-
-#include <stdint.h>
-#include <uefi/tables.h>
-#include <uefi/types.h>
-
-namespace uefi {
-namespace bs_impl {
-	using allocate_pages = status (*)(allocate_type, memory_type, size_t, void**);
-	using get_memory_map = status (*)(size_t*, memory_descriptor*, size_t*, size_t*, uint32_t*);
-	using allocate_pool = status (*)(memory_type, uint64_t, void**);
-	using handle_protocol = status (*)(handle, const guid*, void**);
-	using create_event = status (*)(evt, tpl, event_notify, void*, event*);
-	using exit_boot_services = status (*)(handle, size_t);
-	using locate_protocol = status (*)(const guid*, void*, void**);
-	using copy_mem = void (*)(void*, void*, size_t);
-	using set_mem = void (*)(void*, uint64_t, uint8_t);
-}
-
-struct boot_services {
-	static constexpr uint64_t signature = 0x56524553544f4f42ull;
-
-	table_header header;
-
-	// Task Priority Level management
-	void *raise_tpl;
-	void *restore_tpl;
-
-	// Memory Services
-	bs_impl::allocate_pages allocate_pages;
-	void *free_pages;
-	bs_impl::get_memory_map get_memory_map;
-	bs_impl::allocate_pool allocate_pool;
-	void *free_pool;
-
-	// Event & Timer Services
-	bs_impl::create_event create_event;
-	void *set_timer;
-	void *wait_for_event;
-	void *signal_event;
-	void *close_event;
-	void *check_event;
-
-	// Protocol Handler Services
-	void *install_protocol_interface;
-	void *reinstall_protocol_interface;
-	void *uninstall_protocol_interface;
-	bs_impl::handle_protocol handle_protocol;
-	void *_reserved;
-	void *register_protocol_notify;
-	void *locate_handle;
-	void *locate_device_path;
-	void *install_configuration_table;
-
-	// Image Services
-	void *load_image;
-	void *start_image;
-	void *exit;
-	void *unload_image;
-	bs_impl::exit_boot_services exit_boot_services;
-
-	// Miscellaneous Services
-	void *get_next_monotonic_count;
-	void *stall;
-	void *set_watchdog_timer;
-
-	// DriverSupport Services
-	void *connect_controller;
-	void *disconnect_controller;
-
-	// Open and Close Protocol Services
-	void *open_protocol;
-	void *close_protocol;
-	void *open_protocol_information;
-
-	// Library Services
-	void *protocols_per_handle;
-	void *locate_handle_buffer;
-	bs_impl::locate_protocol locate_protocol;
-	void *install_multiple_protocol_interfaces;
-	void *uninstall_multiple_protocol_interfaces;
-
-	// 32-bit CRC Services
-	void *calculate_crc32;
-
-	// Miscellaneous Services
-	bs_impl::copy_mem copy_mem;
-	bs_impl::set_mem set_mem;
-	void *create_event_ex;
-};
-
-} // namespace uefi
-
-#endif

external/uefi/errors.inc

@@ -1,39 +0,0 @@
-STATUS_WARNING( warn_unknown_glyph,   1)
-STATUS_WARNING( warn_delete_failure,  2)
-STATUS_WARNING( warn_write_failure,   3)
-STATUS_WARNING( warn_buffer_too_small,4)
-STATUS_WARNING( warn_stale_data,      5)
-STATUS_WARNING( warn_file_system,     6)
-
-STATUS_ERROR( load_error,             1)
-STATUS_ERROR( invalid_parameter,      2)
-STATUS_ERROR( unsupported,            3)
-STATUS_ERROR( bad_buffer_size,        4)
-STATUS_ERROR( buffer_too_small,       5)
-STATUS_ERROR( not_ready,              6)
-STATUS_ERROR( device_error,           7)
-STATUS_ERROR( write_protected,        8)
-STATUS_ERROR( out_of_resources,       9)
-STATUS_ERROR( volume_corrupted,       10)
-STATUS_ERROR( volume_full,            11)
-STATUS_ERROR( no_media,               12)
-STATUS_ERROR( media_changed,          13)
-STATUS_ERROR( not_found,              14)
-STATUS_ERROR( access_denied,          15)
-STATUS_ERROR( no_response,            16)
-STATUS_ERROR( no_mapping,             17)
-STATUS_ERROR( timeout,                18)
-STATUS_ERROR( not_started,            19)
-STATUS_ERROR( already_started,        20)
-STATUS_ERROR( aborted,                21)
-STATUS_ERROR( icmp_error,             22)
-STATUS_ERROR( tftp_error,             23)
-STATUS_ERROR( protocol_error,         24)
-STATUS_ERROR( incompatible_version,   25)
-STATUS_ERROR( security_violation,     26)
-STATUS_ERROR( crc_error,              27)
-STATUS_ERROR( end_of_media,           28)
-STATUS_ERROR( end_of_file,            31)
-STATUS_ERROR( invalid_language,       32)
-STATUS_ERROR( compromised_data,       33)
-STATUS_ERROR( http_error,             35)

external/uefi/graphics.h

@@ -1,92 +0,0 @@
-#pragma once
-#ifndef _uefi_graphics_h_
-#define _uefi_graphics_h_
-
-// This Source Code Form is part of the j6-uefi-headers project and is subject
-// to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was
-// not distributed with this file, You can obtain one at
-// http://mozilla.org/MPL/2.0/.
-
-#include <stdint.h>
-#include <uefi/types.h>
-
-namespace uefi {
-
-struct text_output_mode
-{
-	int32_t max_mode;
-	int32_t mode;
-	int32_t attribute;
-	int32_t cursor_column;
-	int32_t cursor_row;
-	bool cursor_visible;
-};
-
-struct pixel_bitmask
-{
-	uint32_t red_mask;
-	uint32_t green_mask;
-	uint32_t blue_mask;
-	uint32_t reserved_mask;
-};
-
-enum class pixel_format
-{
-	rgb8,
-	bgr8,
-	bitmask,
-	blt_only
-};
-
-struct graphics_output_mode_info
-{
-	uint32_t version;
-	uint32_t horizontal_resolution;
-	uint32_t vertical_resolution;
-	pixel_format pixel_format;
-	pixel_bitmask pixel_information;
-	uint32_t pixels_per_scanline;
-};
-
-struct graphics_output_mode
-{
-	uint32_t max_mode;
-	uint32_t mode;
-	graphics_output_mode_info *info;
-	uint64_t size_of_info;
-	uintptr_t frame_buffer_base;
-	uint64_t frame_buffer_size;
-};
-
-enum class attribute : uint64_t
-{
-	black,
-	blue,
-	green,
-	cyan,
-	red,
-	magenta,
-	brown,
-	light_gray,
-	dark_gray,
-	light_blue,
-	light_green,
-	light_cyan,
-	light_red,
-	light_magenta,
-	yellow,
-	white,
-
-	background_black      = 0x00,
-	background_blue       = 0x10,
-	background_green      = 0x20,
-	background_cyan       = 0x30,
-	background_red        = 0x40,
-	background_magenta    = 0x50,
-	background_brown      = 0x60,
-	background_light_gray = 0x70,
-};
-
-} // namespace uefi
-
-#endif

external/uefi/guid.h

@@ -1,29 +0,0 @@
-#pragma once
-#ifndef _uefi_guid_h_
-#define _uefi_guid_h_
-
-// This Source Code Form is part of the j6-uefi-headers project and is subject
-// to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was
-// not distributed with this file, You can obtain one at
-// http://mozilla.org/MPL/2.0/.
-
-#include <stdint.h>
-
-namespace uefi {
-
-struct guid
-{
-	uint32_t data1;
-	uint16_t data2;
-	uint16_t data3;
-	uint8_t data4[8];
-
-	inline bool operator==(const guid &other) const {
-		return reinterpret_cast<const uint64_t*>(this)[0] == reinterpret_cast<const uint64_t*>(&other)[0]
-			&& reinterpret_cast<const uint64_t*>(this)[1] == reinterpret_cast<const uint64_t*>(&other)[1];
-	}
-};
-
-} // namespace uefi
-
-#endif

external/uefi/protos/device_path.h

@@ -1,30 +0,0 @@
-#pragma once
-#ifndef _uefi_protos_device_path_h_
-#define _uefi_protos_device_path_h_
-
-// This file was auto generated by the j6-uefi-headers project. Please see
-// https://github.com/justinian/j6-uefi-headers for more information.
-
-#include <uefi/guid.h>
-#include <uefi/types.h>
-
-namespace uefi {
-namespace protos {
-struct device_path;
-
-struct device_path
-{
-    static constexpr uefi::guid guid{ 0x09576e91,0x6d3f,0x11d2,{0x8e,0x39,0x00,0xa0,0xc9,0x69,0x72,0x3b} };
-
-    uint8_t type;
-    uint8_t sub_type;
-    uint16_t length;
-
-protected:
-public:
-};
-
-} // namespace protos
-} // namespace uefi
-
-#endif // _uefi_protos_device_path_h_

external/uefi/protos/file.h

@@ -1,126 +0,0 @@
-#pragma once
-#ifndef _uefi_protos_file_h_
-#define _uefi_protos_file_h_
-
-// This file was auto generated by the j6-uefi-headers project. Please see
-// https://github.com/justinian/j6-uefi-headers for more information.
-
-#include <uefi/guid.h>
-#include <uefi/types.h>
-
-namespace uefi {
-namespace protos {
-struct file;
-
-struct file
-{
-    
-
-    inline uefi::status open(file ** new_handle, const wchar_t * file_name, file_mode open_mode, file_attr attributes) {
-        return _open(this, new_handle, file_name, open_mode, attributes);
-    }
-
-    inline uefi::status close() {
-        return _close(this);
-    }
-
-    inline uefi::status delete_file() {
-        return _delete_file(this);
-    }
-
-    inline uefi::status read(uint64_t * buffer_size, void * buffer) {
-        return _read(this, buffer_size, buffer);
-    }
-
-    inline uefi::status write(uint64_t * buffer_size, void * buffer) {
-        return _write(this, buffer_size, buffer);
-    }
-
-    inline uefi::status get_position(uint64_t * position) {
-        return _get_position(this, position);
-    }
-
-    inline uefi::status set_position(uint64_t position) {
-        return _set_position(this, position);
-    }
-
-    inline uefi::status get_info(const guid * info_type, uint64_t * buffer_size, void * buffer) {
-        return _get_info(this, info_type, buffer_size, buffer);
-    }
-
-    inline uefi::status set_info(const guid * info_type, uint64_t buffer_size, void * buffer) {
-        return _set_info(this, info_type, buffer_size, buffer);
-    }
-
-    inline uefi::status flush() {
-        return _flush(this);
-    }
-
-    inline uefi::status open_ex(file ** new_handle, const wchar_t * file_name, uint64_t open_mode, uint64_t attributes, file_io_token * token) {
-        return _open_ex(this, new_handle, file_name, open_mode, attributes, token);
-    }
-
-    inline uefi::status read_ex(file_io_token * token) {
-        return _read_ex(this, token);
-    }
-
-    inline uefi::status write_ex(file_io_token * token) {
-        return _write_ex(this, token);
-    }
-
-    inline uefi::status flush_ex(file_io_token * token) {
-        return _flush_ex(this, token);
-    }
-
-    uint64_t revision;
-
-protected:
-    using _open_def = uefi::status (*)(uefi::protos::file *, file **, const wchar_t *, file_mode, file_attr);
-    _open_def _open;
-
-    using _close_def = uefi::status (*)(uefi::protos::file *);
-    _close_def _close;
-
-    using _delete_file_def = uefi::status (*)(uefi::protos::file *);
-    _delete_file_def _delete_file;
-
-    using _read_def = uefi::status (*)(uefi::protos::file *, uint64_t *, void *);
-    _read_def _read;
-
-    using _write_def = uefi::status (*)(uefi::protos::file *, uint64_t *, void *);
-    _write_def _write;
-
-    using _get_position_def = uefi::status (*)(uefi::protos::file *, uint64_t *);
-    _get_position_def _get_position;
-
-    using _set_position_def = uefi::status (*)(uefi::protos::file *, uint64_t);
-    _set_position_def _set_position;
-
-    using _get_info_def = uefi::status (*)(uefi::protos::file *, const guid *, uint64_t *, void *);
-    _get_info_def _get_info;
-
-    using _set_info_def = uefi::status (*)(uefi::protos::file *, const guid *, uint64_t, void *);
-    _set_info_def _set_info;
-
-    using _flush_def = uefi::status (*)(uefi::protos::file *);
-    _flush_def _flush;
-
-    using _open_ex_def = uefi::status (*)(uefi::protos::file *, file **, const wchar_t *, uint64_t, uint64_t, file_io_token *);
-    _open_ex_def _open_ex;
-
-    using _read_ex_def = uefi::status (*)(uefi::protos::file *, file_io_token *);
-    _read_ex_def _read_ex;
-
-    using _write_ex_def = uefi::status (*)(uefi::protos::file *, file_io_token *);
-    _write_ex_def _write_ex;
-
-    using _flush_ex_def = uefi::status (*)(uefi::protos::file *, file_io_token *);
-    _flush_ex_def _flush_ex;
-
-public:
-};
-
-} // namespace protos
-} // namespace uefi
-
-#endif // _uefi_protos_file_h_

external/uefi/protos/file_info.h

@@ -1,35 +0,0 @@
-#pragma once
-#ifndef _uefi_protos_file_info_h_
-#define _uefi_protos_file_info_h_
-
-// This file was auto generated by the j6-uefi-headers project. Please see
-// https://github.com/justinian/j6-uefi-headers for more information.
-
-#include <uefi/guid.h>
-#include <uefi/types.h>
-
-namespace uefi {
-namespace protos {
-struct file_info;
-
-struct file_info
-{
-    static constexpr uefi::guid guid{ 0x09576e92,0x6d3f,0x11d2,{0x8e,0x39,0x00,0xa0,0xc9,0x69,0x72,0x3b} };
-
-    uint64_t size;
-    uint64_t file_size;
-    uint64_t physical_size;
-    time create_time;
-    time last_access_time;
-    time modification_time;
-    uint64_t attribute;
-    wchar_t file_name[];
-
-protected:
-public:
-};
-
-} // namespace protos
-} // namespace uefi
-
-#endif // _uefi_protos_file_info_h_

external/uefi/protos/graphics_output.h

@@ -1,50 +0,0 @@
-#pragma once
-#ifndef _uefi_protos_graphics_output_h_
-#define _uefi_protos_graphics_output_h_
-
-// This file was auto generated by the j6-uefi-headers project. Please see
-// https://github.com/justinian/j6-uefi-headers for more information.
-
-#include <uefi/guid.h>
-#include <uefi/types.h>
-#include <uefi/graphics.h>
-
-namespace uefi {
-namespace protos {
-struct graphics_output;
-
-struct graphics_output
-{
-    static constexpr uefi::guid guid{ 0x9042a9de,0x23dc,0x4a38,{0x96,0xfb,0x7a,0xde,0xd0,0x80,0x51,0x6a} };
-
-    inline uefi::status query_mode(uint32_t mode_number, uint64_t * size_of_info, uefi::graphics_output_mode_info ** info) {
-        return _query_mode(this, mode_number, size_of_info, info);
-    }
-
-    inline uefi::status set_mode(uint32_t mode_number) {
-        return _set_mode(this, mode_number);
-    }
-
-    inline uefi::status blt() {
-        return _blt(this);
-    }
-
-
-protected:
-    using _query_mode_def = uefi::status (*)(uefi::protos::graphics_output *, uint32_t, uint64_t *, uefi::graphics_output_mode_info **);
-    _query_mode_def _query_mode;
-
-    using _set_mode_def = uefi::status (*)(uefi::protos::graphics_output *, uint32_t);
-    _set_mode_def _set_mode;
-
-    using _blt_def = uefi::status (*)(uefi::protos::graphics_output *);
-    _blt_def _blt;
-
-public:
-    uefi::graphics_output_mode * mode;
-};
-
-} // namespace protos
-} // namespace uefi
-
-#endif // _uefi_protos_graphics_output_h_

external/uefi/protos/loaded_image.h

@@ -1,48 +0,0 @@
-#pragma once
-#ifndef _uefi_protos_loaded_image_h_
-#define _uefi_protos_loaded_image_h_
-
-// This file was auto generated by the j6-uefi-headers project. Please see
-// https://github.com/justinian/j6-uefi-headers for more information.
-
-#include <uefi/guid.h>
-#include <uefi/types.h>
-#include <uefi/tables.h>
-#include <uefi/protos/device_path.h>
-
-namespace uefi {
-namespace protos {
-struct loaded_image;
-
-struct loaded_image
-{
-    static constexpr uefi::guid guid{ 0x5b1b31a1,0x9562,0x11d2,{0x8e,0x3f,0x00,0xa0,0xc9,0x69,0x72,0x3b} };
-
-    inline uefi::status unload(uefi::handle image_handle) {
-        return _unload(image_handle);
-    }
-
-    uint32_t revision;
-    uefi::handle parent_handle;
-    uefi::system_table * system_table;
-    uefi::handle device_handle;
-    uefi::protos::device_path * file_path;
-    void * reserved;
-    uint32_t load_options_size;
-    void * load_options;
-    void * image_base;
-    uint64_t image_size;
-    uefi::memory_type image_code_type;
-    uefi::memory_type image_data_type;
-
-protected:
-    using _unload_def = uefi::status (*)(uefi::handle);
-    _unload_def _unload;
-
-public:
-};
-
-} // namespace protos
-} // namespace uefi
-
-#endif // _uefi_protos_loaded_image_h_

external/uefi/protos/simple_file_system.h

@@ -1,36 +0,0 @@
-#pragma once
-#ifndef _uefi_protos_simple_file_system_h_
-#define _uefi_protos_simple_file_system_h_
-
-// This file was auto generated by the j6-uefi-headers project. Please see
-// https://github.com/justinian/j6-uefi-headers for more information.
-
-#include <uefi/guid.h>
-#include <uefi/types.h>
-#include <uefi/protos/file.h>
-
-namespace uefi {
-namespace protos {
-struct simple_file_system;
-
-struct simple_file_system
-{
-    static constexpr uefi::guid guid{ 0x0964e5b22,0x6459,0x11d2,{0x8e,0x39,0x00,0xa0,0xc9,0x69,0x72,0x3b} };
-
-    inline uefi::status open_volume(uefi::protos::file ** root) {
-        return _open_volume(this, root);
-    }
-
-    uint64_t revision;
-
-protected:
-    using _open_volume_def = uefi::status (*)(uefi::protos::simple_file_system *, uefi::protos::file **);
-    _open_volume_def _open_volume;
-
-public:
-};
-
-} // namespace protos
-} // namespace uefi
-
-#endif // _uefi_protos_simple_file_system_h_

external/uefi/protos/simple_text_output.h

@@ -1,92 +0,0 @@
-#pragma once
-#ifndef _uefi_protos_simple_text_output_h_
-#define _uefi_protos_simple_text_output_h_
-
-// This file was auto generated by the j6-uefi-headers project. Please see
-// https://github.com/justinian/j6-uefi-headers for more information.
-
-#include <uefi/guid.h>
-#include <uefi/types.h>
-#include <uefi/graphics.h>
-
-namespace uefi {
-namespace protos {
-struct simple_text_output;
-
-struct simple_text_output
-{
-    static constexpr uefi::guid guid{ 0x387477c2,0x69c7,0x11d2,{0x8e,0x39,0x00,0xa0,0xc9,0x69,0x72,0x3b} };
-
-    inline uefi::status reset(bool extended_verification) {
-        return _reset(this, extended_verification);
-    }
-
-    inline uefi::status output_string(const wchar_t * string) {
-        return _output_string(this, string);
-    }
-
-    inline uefi::status test_string(const wchar_t * string) {
-        return _test_string(this, string);
-    }
-
-    inline uefi::status query_mode(uint64_t mode_number, uint64_t * columns, uint64_t * rows) {
-        return _query_mode(this, mode_number, columns, rows);
-    }
-
-    inline uefi::status set_mode(uint64_t mode_number) {
-        return _set_mode(this, mode_number);
-    }
-
-    inline uefi::status set_attribute(uefi::attribute attribute) {
-        return _set_attribute(this, attribute);
-    }
-
-    inline uefi::status clear_screen() {
-        return _clear_screen(this);
-    }
-
-    inline uefi::status set_cursor_position(uint64_t column, uint64_t row) {
-        return _set_cursor_position(this, column, row);
-    }
-
-    inline uefi::status enable_cursor(bool visible) {
-        return _enable_cursor(this, visible);
-    }
-
-
-protected:
-    using _reset_def = uefi::status (*)(uefi::protos::simple_text_output *, bool);
-    _reset_def _reset;
-
-    using _output_string_def = uefi::status (*)(uefi::protos::simple_text_output *, const wchar_t *);
-    _output_string_def _output_string;
-
-    using _test_string_def = uefi::status (*)(uefi::protos::simple_text_output *, const wchar_t *);
-    _test_string_def _test_string;
-
-    using _query_mode_def = uefi::status (*)(uefi::protos::simple_text_output *, uint64_t, uint64_t *, uint64_t *);
-    _query_mode_def _query_mode;
-
-    using _set_mode_def = uefi::status (*)(uefi::protos::simple_text_output *, uint64_t);
-    _set_mode_def _set_mode;
-
-    using _set_attribute_def = uefi::status (*)(uefi::protos::simple_text_output *, uefi::attribute);
-    _set_attribute_def _set_attribute;
-
-    using _clear_screen_def = uefi::status (*)(uefi::protos::simple_text_output *);
-    _clear_screen_def _clear_screen;
-
-    using _set_cursor_position_def = uefi::status (*)(uefi::protos::simple_text_output *, uint64_t, uint64_t);
-    _set_cursor_position_def _set_cursor_position;
-
-    using _enable_cursor_def = uefi::status (*)(uefi::protos::simple_text_output *, bool);
-    _enable_cursor_def _enable_cursor;
-
-public:
-    uefi::text_output_mode * mode;
-};
-
-} // namespace protos
-} // namespace uefi
-
-#endif // _uefi_protos_simple_text_output_h_

external/uefi/runtime_services.h

@@ -1,52 +0,0 @@
-#pragma once
-#ifndef _uefi_runtime_services_h_
-#define _uefi_runtime_services_h_
-
-// This Source Code Form is part of the j6-uefi-headers project and is subject
-// to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was
-// not distributed with this file, You can obtain one at
-// http://mozilla.org/MPL/2.0/.
-
-#include <stdint.h>
-#include <uefi/tables.h>
-
-namespace uefi {
-namespace rs_impl {
-	using convert_pointer = uefi::status (*)(uint64_t, void **);
-	using set_virtual_address_map = uefi::status (*)(size_t, size_t, uint32_t, memory_descriptor *);
-}
-
-struct runtime_services {
-	static constexpr uint64_t signature = 0x56524553544e5552ull;
-
-	table_header header;
-
-	// Time Services
-	void *get_time;
-	void *set_time;
-	void *get_wakeup_time;
-	void *set_wakeup_time;
-
-	// Virtual Memory Services
-	rs_impl::set_virtual_address_map set_virtual_address_map;
-	rs_impl::convert_pointer convert_pointer;
-
-	// Variable Services
-	void *get_variable;
-	void *get_next_variable_name;
-	void *set_variable;
-
-	// Miscellaneous Services
-	void *get_next_high_monotonic_count;
-	void *reset_system;
-
-	// UEFI 2.0 Capsule Services
-	void *update_capsule;
-	void *query_capsule_capabilities;
-
-	// Miscellaneous UEFI 2.0 Service
-	void *query_variable_info;
-};
-
-} // namespace uefi
-#endif

external/uefi/tables.h

@@ -1,73 +0,0 @@
-#pragma once
-#ifndef _uefi_tables_h_
-#define _uefi_tables_h_
-
-// This Source Code Form is part of the j6-uefi-headers project and is subject
-// to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was
-// not distributed with this file, You can obtain one at
-// http://mozilla.org/MPL/2.0/.
-
-#include <stdint.h>
-#include <uefi/guid.h>
-#include <uefi/types.h>
-
-namespace uefi {
-
-struct runtime_services;
-struct boot_services;
-namespace protos {
-	struct simple_text_input;
-	struct simple_text_output;
-}
-
-struct table_header
-{
-	uint64_t signature;
-	uint32_t revision;
-	uint32_t header_size;
-	uint32_t crc32;
-	uint32_t reserved;
-};
-
-struct configuration_table
-{
-	guid vendor_guid;
-	void *vendor_table;
-};
-
-struct system_table
-{
-	table_header header;
-
-	char16_t *firmware_vendor;
-	uint32_t firmware_revision;
-
-	handle console_in_handle;
-	protos::simple_text_input *con_in;
-	handle console_out_handle;
-	protos::simple_text_output *con_out;
-	handle standard_error_handle;
-	protos::simple_text_output *std_err;
-
-	runtime_services *runtime_services;
-	boot_services *boot_services;
-
-	unsigned int number_of_table_entries;
-	configuration_table *configuration_table;
-};
-
-constexpr uint32_t make_system_table_revision(int major, int minor) {
-	return (major << 16) | minor;
-}
-
-constexpr uint64_t system_table_signature = 0x5453595320494249ull;
-constexpr uint32_t system_table_revision = make_system_table_revision(2, 70);
-constexpr uint32_t specification_revision = system_table_revision;
-
-namespace vendor_guids {
-	constexpr guid acpi1{ 0xeb9d2d30,0x2d88,0x11d3,{0x9a,0x16,0x00,0x90,0x27,0x3f,0xc1,0x4d} };
-	constexpr guid acpi2{ 0x8868e871,0xe4f1,0x11d3,{0xbc,0x22,0x00,0x80,0xc7,0x3c,0x88,0x81} };
-} // namespace vendor_guids
-} // namespace uefi
-
-#endif

external/uefi/types.h

@@ -1,157 +0,0 @@
-#pragma once
-#ifndef _uefi_types_h_
-#define _uefi_types_h_
-
-// This Source Code Form is part of the j6-uefi-headers project and is subject
-// to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was
-// not distributed with this file, You can obtain one at
-// http://mozilla.org/MPL/2.0/.
-
-#include <stdint.h>
-
-namespace uefi {
-
-using handle = void *;
-
-
-//
-// Error and status code definitions
-//
-constexpr uint64_t error_bit = 0x8000000000000000ull; 
-constexpr uint64_t make_error(uint64_t e) { return e|error_bit; }
-
-enum class status : uint64_t
-{
-	success = 0,
-
-#define STATUS_WARNING(name, num) name = num,
-#define STATUS_ERROR(name, num) name = make_error(num),
-#include "uefi/errors.inc"
-#undef STATUS_WARNING
-#undef STATUS_ERROR
-};
-
-inline bool is_error(status s) { return static_cast<uint64_t>(s) & error_bit; }
-inline bool is_warning(status s) { return !is_error(s) && s != status::success; }
-
-
-//
-// Time defitions
-//
-struct time
-{
-	uint16_t year;
-	uint8_t month;
-	uint8_t day;
-	uint8_t hour;
-	uint8_t minute;
-	uint8_t second;
-	uint8_t _pad0;
-	uint32_t nanosecond;
-	int16_t time_zone;
-	uint8_t daylight;
-	uint8_t _pad1;
-};
-
-
-//
-// Memory and allocation defitions
-//
-enum class memory_type : uint32_t
-{
-	reserved,
-	loader_code,
-	loader_data,
-	boot_services_code,
-	boot_services_data,
-	runtime_services_code,
-	runtime_services_data,
-	conventional_memory,
-	unusable_memory,
-	acpi_reclaim_memory,
-	acpi_memory_nvs,
-	memory_mapped_io,
-	memory_mapped_io_port_space,
-	pal_code,
-	persistent_memory,
-	max_memory_type
-};
-
-enum class allocate_type : uint32_t
-{
-	any_pages,
-	max_address,
-	address
-};
-
-struct memory_descriptor
-{
-	memory_type type;
-	uintptr_t physical_start;
-	uintptr_t virtual_start;
-	uint64_t number_of_pages;
-	uint64_t attribute;
-};
-
-
-//
-// Event handling defitions
-//
-using event = void *;
-
-enum class evt : uint32_t
-{
-	notify_wait                   = 0x00000100,
-	notify_signal                 = 0x00000200,
-
-	signal_exit_boot_services     = 0x00000201,
-	signal_virtual_address_change = 0x60000202,
-
-	runtime                       = 0x40000000,
-	timer                         = 0x80000000
-};
-
-enum class tpl : uint64_t
-{
-	application = 4,
-	callback    = 8,
-	notify      = 16,
-	high_level  = 31
-};
-
-using event_notify = void (*)(event, void*);
-
-
-//
-// File IO defitions
-//
-struct file_io_token
-{
-	event event;
-	status status;
-	uint64_t buffer_size;
-	void *buffer;
-};
-
-enum class file_mode : uint64_t
-{
-	read   = 0x0000000000000001ull,
-	write  = 0x0000000000000002ull,
-
-	create = 0x8000000000000000ull
-};
-
-enum class file_attr : uint64_t
-{
-	none      = 0,
-	read_only = 0x0000000000000001ull,
-	hidden    = 0x0000000000000002ull,
-	system    = 0x0000000000000004ull,
-	reserved  = 0x0000000000000008ull,
-	directory = 0x0000000000000010ull,
-	archive   = 0x0000000000000020ull
-};
-
-} // namespace uefi
-
-#endif

modules.yaml

@@ -9,6 +9,7 @@ modules:
             - elf
             - initrd
             - kutil
+            - vdso
         includes:
             - src/kernel
         source:
@@ -53,17 +54,26 @@ modules:
     boot:
         kind: exe
         target: boot
-        output: boot.efi
+        output: boot.elf
         source:
-            - src/boot/main.cpp
+            - src/boot/crt0.s
             - src/boot/console.cpp
-            - src/boot/error.cpp
-            - src/boot/fs.cpp
-            - src/boot/hardware.cpp
+            - src/boot/guids.cpp
             - src/boot/loader.cpp
+            - src/boot/main.cpp
             - src/boot/memory.cpp
-            - src/boot/paging.cpp
-            - src/boot/support.cpp
+            - src/boot/reloc.cpp
+            - src/boot/utility.cpp
+
+    vdso:
+        kind: exe
+        target: host
+        output: libvdso.so
+        extra:
+            - src/arch/x86_64/vdso.ld
+        source:
+            - src/vdso/syscalls.cpp
+            - src/vdso/overrides.cpp
 
     nulldrv:
         kind: exe

other_software.md

@@ -87,3 +87,46 @@ which is also released under the terms of the MIT license:
 > LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 > SOFTWARE.
+
+## GNU-EFI
+
+jsix's UEFI bootloader initially used [GNU-EFI][], and still uses one file (the
+linker script for the bootloader) from that project. GNU-EFI claims to be
+released under the BSD license. Again, I could not find its specific license
+file, so I am reproducing a generic 3-clause BSD license (the most restrictive,
+so as not to assume any extra rights that may not actually be granted) for it
+here:
+
+[GNU-EFI]: https://gnu-efi.sourceforge.net
+
+> Copyright (c) Nigel Croxon
+> 
+> Redistribution and use in source and binary forms, with or without
+> modification, are permitted provided that the following conditions are met:
+> 
+> 1. Redistributions of source code must retain the above copyright notice, this
+>    list of conditions and the following disclaimer.
+> 
+> 2. Redistributions in binary form must reproduce the above copyright notice,
+>    this list of conditions and the following disclaimer in the documentation
+>    and/or other materials provided with the distribution.
+> 
+> 3. Neither the name of the copyright holder nor the names of its contributors
+>    may be used to endorse or promote products derived from this software
+>    without specific prior written permission.
+> 
+> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+> ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+> WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+> DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+> FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+> DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+> SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+> OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+> OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+## Intel EFI Application Toolkit
+
+jsix's UEFI loader uses code from Intel's EFI Application toolkit. Relevant
+code includes license statements at the top of each file.

qemu.sh

@@ -3,7 +3,6 @@
 build="$(dirname $0)/build"
 assets="$(dirname $0)/assets"
 debug=""
-debugtarget="${build}/jsix.elf"
 flash_name="ovmf_vars"
 gfx="-nographic"
 kvm=""
@@ -11,13 +10,8 @@ cpu="Broadwell,+pdpe1gb"
 
 for arg in $@; do
 	case "${arg}" in
-		--debugboot)
-			debug="-s -S"
-			debugtarget="${build}/boot/boot.efi"
-			flash_name="ovmf_vars_d"
-			;;
 		--debug)
-			debug="-s -S"
+			debug="-s"
 			flash_name="ovmf_vars_d"
 			;;
 		--gfx)
@@ -43,7 +37,7 @@ fi
 
 if [[ -n $TMUX ]]; then
 	if [[ -n $debug ]]; then
-		tmux split-window -h "gdb ${debugtarget}" &
+		tmux split-window "gdb ${build}/jsix.elf" &
 	else
 		tmux split-window -l 10 "sleep 1; telnet localhost 45454" &
 	fi

scripts/templates/build.ninja.j2

@@ -28,7 +28,6 @@ warnflags = $
     -Wno-unused-result $
     -Wno-deprecated-declarations $
     -Wno-unused-function $
-    -Wno-address-of-packed-member $
     -Werror
 
 ccflags = $
@@ -44,6 +43,7 @@ ccflags = $
     $warnflags
 
 asflags = $
+    -I${srcroot}/src/include $
     -DVERSION_MAJOR={{ version_major }} $
     -DVERSION_MINOR={{ version_minor }} $
     -DVERSION_PATCH={{ version_patch }} $
@@ -187,6 +187,7 @@ build $builddir/fatroot/efi/boot/bootx64.efi : cp $builddir/boot/boot.efi
     name = bootloader to FAT image
 
 build $builddir/fatroot/initrd.img : makerd ${srcroot}/assets/initrd.toml | $
+    ${builddir}/host/libvdso.so $
     ${builddir}/native/makerd $
     ${builddir}/user/nulldrv
 

scripts/templates/exe.boot.j2

@@ -3,10 +3,23 @@
 {{ super() }}
 
 ccflags = $ccflags $
-    -g3 $
     -DKERNEL_FILENAME=L\"jsix.elf\" $
-    -I${srcroot}/external/include $
-    -I${srcroot}/external/include/X64
+    -DGNU_EFI_USE_MS_ABI $
+    -DHAVE_USE_MS_ABI $
+    -DEFI_DEBUG=0 $
+    -DEFI_DEBUG_CLEAR_MEMORY=0 $
+    -DBOOTLOADER_DEBUG
+
+ldflags = $ldflags $
+    -T ${srcroot}/src/arch/x86_64/boot.ld $
+    -shared
+
+{% endblock %}
+
+{% block extra %}
+
+build $builddir/boot.efi : makeefi ${builddir}/{{ module.output }}
+    name = boot.efi
 
 {% endblock %}
 

scripts/templates/exe.vdso.j2

@@ -0,0 +1,9 @@
+{% extends "exe.default.j2" %}
+{% block variables %}
+{{ super() }}
+ccflags = $ccflags -fPIC -mcmodel=large
+ldflags = $ldflags -shared -znotext -T ${srcroot}/src/arch/x86_64/vdso.ld
+{% endblock %}
+
+# vim: ft=ninja et ts=4 sts=4 sw=4
+

scripts/templates/target.boot.j2

@@ -3,7 +3,7 @@
 {% block binaries %}
 cc = clang
 cxx = clang++
-ld = clang++
+ld = ld
 ar = ar
 nasm = nasm
 objcopy = objcopy
@@ -12,25 +12,27 @@ objcopy = objcopy
 {% block variables %}
 
 ccflags = $ccflags $
-    -I $srcroot/external $
-    --target=x86_64-unknown-windows $
+	-ggdb $
+	-nostdlib $
 	-ffreestanding $
+	-nodefaultlibs $
+	-fno-builtin $
+	-mno-sse $
+	-fno-omit-frame-pointer $
 	-mno-red-zone $
 	-fshort-wchar $
-	-fno-omit-frame-pointer $
-	-ggdb
+	-D__ELF__ $
+	-fPIC
 
 cxxflags = $cxxflags $
-    -fno-rtti $
-    -fno-exceptions
+	-fno-exceptions $
+	-fno-rtti $
 
 ldflags = $ldflags $
-    --target=x86_64-unknown-windows $
+	-g $
 	-nostdlib $
-    -Wl,-entry:efi_main $
-    -Wl,-subsystem:efi_application $
-    -fuse-ld=lld-link $
-	-g
+	-Bsymbolic $
+	-nostartfiles
 
 {% endblock %}
 

src/arch/x86_64/boot.ld

@@ -0,0 +1,79 @@
+/* Linker script originally from GNU-EFI project
+ * https://sourceforge.net/p/gnu-efi/
+ */
+
+OUTPUT_FORMAT("elf64-x86-64", "elf64-x86-64", "elf64-x86-64")
+OUTPUT_ARCH(i386:x86-64)
+ENTRY(_start)
+SECTIONS
+{
+  . = 0;
+  ImageBase = .;
+  /* .hash and/or .gnu.hash MUST come first! */
+  .hash : { *(.hash) }
+  .gnu.hash : { *(.gnu.hash) }
+  . = ALIGN(4096);
+  .eh_frame : 
+  { 
+    *(.eh_frame)
+  }
+  . = ALIGN(4096);
+  .text :
+  {
+   _text = .;
+   *(.text)
+   *(.text.*)
+   *(.gnu.linkonce.t.*)
+   . = ALIGN(16);
+  }
+  _etext = .;
+  _text_size = . - _text;
+  . = ALIGN(4096);
+  .reloc :
+  {
+   *(.reloc)
+  }
+  . = ALIGN(4096);
+  .data :
+  {
+   _data = .;
+   *(.rodata*)
+   *(.got.plt)
+   *(.got)
+   *(.data*)
+   *(.sdata)
+   /* the EFI loader doesn't seem to like a .bss section, so we stick
+      it all into .data: */
+   *(.sbss)
+   *(.scommon)
+   *(.dynbss)
+   *(.bss)
+   *(COMMON)
+   *(.rel.local)
+  }
+  .note.gnu.build-id : { *(.note.gnu.build-id) }
+
+  _edata = .;
+  _data_size = . - _etext;
+  . = ALIGN(4096);
+  .dynamic  : { *(.dynamic) }
+  . = ALIGN(4096);
+  .rela :
+  {
+    *(.rela.data*)
+    *(.rela.got)
+    *(.rela.stab)
+  }
+  . = ALIGN(4096);
+  .dynsym   : { *(.dynsym) }
+  . = ALIGN(4096);
+  .dynstr   : { *(.dynstr) }
+  . = ALIGN(4096);
+  .ignored.reloc :
+  {
+    *(.rela.reloc)
+    *(.eh_frame)
+    *(.note.GNU-stack)
+  }
+  .comment 0 : { *(.comment) }
+}

src/arch/x86_64/kernel.ld

@@ -1,7 +1,7 @@
 ENTRY(_start)
 SECTIONS
 {
-	OFFSET = 0xFFFF800000000000;
+	OFFSET = 0xFFFFFF0000000000;
 	. = OFFSET + 0x100000;
 
 	.header : {

src/arch/x86_64/vdso.ld

@@ -0,0 +1,73 @@
+PHDRS {
+	headers PT_PHDR FLAGS(4) FILEHDR PHDRS ;
+	rodata PT_LOAD FLAGS(4) ;
+	text PT_LOAD FLAGS(5) ;
+	dynamic PT_DYNAMIC FLAGS(4) ;
+	note PT_NOTE ;
+	eh_frame PT_GNU_EH_FRAME ;
+}
+
+SECTIONS {
+	. = SIZEOF_HEADERS;
+
+	/DISCARD/ : {
+		*(.got*)
+		*(.plt*)
+		*(.note.*)
+		*(.hash*)
+		*(.debug*)
+	}
+
+	.illegal.relocations : {
+		*(.rel*)
+	}
+
+	.illegal.writeable : {
+		*(.data*)
+		*(.bss*)
+	}
+
+	.rodata : {
+		*(.rodata*)
+	} :rodata
+
+	.dynamic : {
+		*(.dynamic)
+	} :dynamic
+
+	.dynsym : {
+		*(.dynsym*)
+	} :rodata :dynamic
+
+	.dynstr : {
+		*(.dynstr*)
+	} :rodata :dynamic
+
+	.gnu.hash : {
+		*(.gnu.hash*)
+	} :rodata
+
+	.eh_frame_hdr : {
+		__eh_frame_start = .;
+		KEEP(*(.eh_frame))
+		__eh_frame_end = .;
+
+		KEEP(*(.eh_frame_hdr))
+	} :eh_frame
+
+	.shstrtab : {
+		*(.shstrtab)
+	}
+
+	.text ALIGN(0x1000) : {
+		*(.text*)
+		*(.init*)
+		*(.fini*)
+		. = ALIGN(0x1000);
+	} :text
+
+	ASSERT(SIZEOF(.illegal.relocations) == 0,
+			"Code has introduced relocations into the VDSO")
+	ASSERT(SIZEOF(.illegal.writeable) == 0,
+			"Code has introduced writeable data into the VDSO")
+}

src/boot/console.cpp

@@ -1,113 +1,84 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <uefi/types.h>
-#include <uefi/graphics.h>
-#include <uefi/protos/graphics_output.h>
-
 #include "console.h"
-#include "error.h"
-
-#ifndef GIT_VERSION_WIDE
-#define GIT_VERSION_WIDE L"no version"
-#endif
-
-namespace boot {
+#include "guids.h"
+#include "utility.h"
 
 size_t ROWS = 0;
 size_t COLS = 0;
 
-static constexpr int level_ok = 0;
-static constexpr int level_warn = 1;
-static constexpr int level_fail = 2;
-
-static const wchar_t *level_tags[] = {
-	L"  ok  ",
-	L" warn ",
-	L"failed"
-};
-static const uefi::attribute level_colors[] = {
-	uefi::attribute::green,
-	uefi::attribute::brown,
-	uefi::attribute::light_red
-};
-
-console *console::s_console = nullptr;
-status_line *status_line::s_current = nullptr;
+static EFI_SIMPLE_TEXT_OUT_PROTOCOL *m_out = 0;
 
 static const wchar_t digits[] = {u'0', u'1', u'2', u'3', u'4', u'5',
 	u'6', u'7', u'8', u'9', u'a', u'b', u'c', u'd', u'e', u'f'};
 
-
-static size_t
-wstrlen(const wchar_t *s)
-{
-	size_t count = 0;
-	while (s && *s++) count++;
-	return count;
-}
-
-
-console::console(uefi::boot_services *bs, uefi::protos::simple_text_output *out) :
+console::console(EFI_SYSTEM_TABLE *system_table) :
 	m_rows(0),
 	m_cols(0),
-	m_out(out)
+	m_out(nullptr)
 {
-	pick_mode(bs);
-
-	try_or_raise(
-		m_out->query_mode(m_out->mode->mode, &m_cols, &m_rows),
-		L"Failed to get text output mode.");
-
-	try_or_raise(
-		m_out->clear_screen(),
-		L"Failed to clear screen");
-
-	m_out->set_attribute(uefi::attribute::light_cyan);
-	m_out->output_string(L"jsix loader ");
-
-	m_out->set_attribute(uefi::attribute::light_magenta);
-	m_out->output_string(GIT_VERSION_WIDE);
-
-	m_out->set_attribute(uefi::attribute::light_gray);
-	m_out->output_string(L" booting...\r\n\n");
-
 	s_console = this;
+	m_boot = system_table->BootServices;
+	m_out = system_table->ConOut;
 }
 
-void
-console::pick_mode(uefi::boot_services *bs)
+EFI_STATUS
+console::initialize(const wchar_t *version)
 {
-	uefi::status status;
-	uefi::protos::graphics_output *gfx_out_proto;
-	uefi::guid guid = uefi::protos::graphics_output::guid;
+	EFI_STATUS status;
 
-	try_or_raise(
-		bs->locate_protocol(&guid, nullptr, (void **)&gfx_out_proto),
-		L"Failed to find a Graphics Output Protocol handle");
+	// Might not find a video device at all, so ignore not found errors
+	status = pick_mode();
+	if (status != EFI_NOT_FOUND)
+		CHECK_EFI_STATUS_OR_FAIL(status);
 
-	const uint32_t modes = gfx_out_proto->mode->max_mode;
-	uint32_t best = gfx_out_proto->mode->mode;
+	status = m_out->QueryMode(m_out, m_out->Mode->Mode, &m_cols, &m_rows);
+	CHECK_EFI_STATUS_OR_RETURN(status, "QueryMode");
 
-	uefi::graphics_output_mode_info *info =
-		(uefi::graphics_output_mode_info *)gfx_out_proto->mode;
+	status = m_out->ClearScreen(m_out);
+	CHECK_EFI_STATUS_OR_RETURN(status, "ClearScreen");
 
-	uint32_t res = info->horizontal_resolution * info->vertical_resolution;
-	int is_fb = info->pixel_format != uefi::pixel_format::blt_only;
+	m_out->SetAttribute(m_out, EFI_LIGHTCYAN);
+	m_out->OutputString(m_out, (wchar_t *)L"jsix loader ");
+
+	m_out->SetAttribute(m_out, EFI_LIGHTMAGENTA);
+	m_out->OutputString(m_out, (wchar_t *)version);
+
+	m_out->SetAttribute(m_out, EFI_LIGHTGRAY);
+	m_out->OutputString(m_out, (wchar_t *)L" booting...\r\n\n");
+
+	return status;
+}
+
+EFI_STATUS
+console::pick_mode()
+{
+	EFI_STATUS status;
+	EFI_GRAPHICS_OUTPUT_PROTOCOL *gfx_out_proto;
+	status = m_boot->LocateProtocol(&guid_gfx_out, NULL, (void **)&gfx_out_proto);
+	CHECK_EFI_STATUS_OR_RETURN(status, "LocateProtocol gfx");
+
+	const uint32_t modes = gfx_out_proto->Mode->MaxMode;
+	uint32_t best = gfx_out_proto->Mode->Mode;
+
+	EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *info =
+		(EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *)gfx_out_proto->Mode;
+
+	uint32_t res = info->HorizontalResolution * info->VerticalResolution;
+	int is_fb = info->PixelFormat != PixelBltOnly;
 
 	for (uint32_t i = 0; i < modes; ++i) {
 		size_t size = 0;
-
-		try_or_raise(
-			gfx_out_proto->query_mode(i, &size, &info),
-			L"Failed to find a graphics mode the driver claimed to support");
+		status = gfx_out_proto->QueryMode(gfx_out_proto, i, &size, &info);
+		CHECK_EFI_STATUS_OR_RETURN(status, "QueryMode");
 
 #ifdef MAX_HRES
-		if (info->horizontal_resolution > MAX_HRES) continue;
+		if (info->HorizontalResolution > MAX_HRES) continue;
 #endif
 
-		const uint32_t new_res = info->horizontal_resolution * info->vertical_resolution;
-		const int new_is_fb = info->pixel_format != uefi::pixel_format::blt_only;
+		const uint32_t new_res = info->HorizontalResolution * info->VerticalResolution;
+		const int new_is_fb = info->PixelFormat == PixelBltOnly;
 
 		if (new_is_fb > is_fb && new_res >= res) {
 			best = i;
@@ -115,9 +86,9 @@ console::pick_mode(uefi::boot_services *bs)
 		}
 	}
 
-	try_or_raise(
-		gfx_out_proto->set_mode(best),
-		L"Failed to set graphics mode");
+	status = gfx_out_proto->SetMode(gfx_out_proto, best);
+	CHECK_EFI_STATUS_OR_RETURN(status, "SetMode %d/%d", best, modes);
+	return EFI_SUCCESS;
 }
 
 size_t
@@ -126,11 +97,11 @@ console::print_hex(uint32_t n) const
 	wchar_t buffer[9];
 	wchar_t *p = buffer;
 	for (int i = 7; i >= 0; --i) {
-		uint8_t nibble = (n >> (i*4)) & 0xf;
+		uint8_t nibble = (n & (0xf << (i*4))) >> (i*4);
 		*p++ = digits[nibble];
 	}
 	*p = 0;
-	m_out->output_string(buffer);
+	m_out->OutputString(m_out, buffer);
 	return 8;
 }
 
@@ -140,11 +111,11 @@ console::print_long_hex(uint64_t n) const
 	wchar_t buffer[17];
 	wchar_t *p = buffer;
 	for (int i = 15; i >= 0; --i) {
-		uint8_t nibble = (n >> (i*4)) & 0xf;
+		uint8_t nibble = (n & (0xf << (i*4))) >> (i*4);
 		*p++ = digits[nibble];
 	}
 	*p = 0;
-	m_out->output_string(buffer);
+	m_out->OutputString(m_out, buffer);
 	return 16;
 }
 
@@ -159,7 +130,7 @@ console::print_dec(uint32_t n) const
 		n /= 10;
 	} while (n != 0);
 
-	m_out->output_string(++p);
+	m_out->OutputString(m_out, ++p);
 	return 10 - (p - buffer);
 }
 
@@ -174,7 +145,7 @@ console::print_long_dec(uint64_t n) const
 		n /= 10;
 	} while (n != 0);
 
-	m_out->output_string(++p);
+	m_out->OutputString(m_out, ++p);
 	return 20 - (p - buffer);
 }
 
@@ -194,14 +165,14 @@ console::vprintf(const wchar_t *fmt, va_list args) const
 		}
 
 		*w = 0;
-		m_out->output_string(buffer);
+		m_out->OutputString(m_out, buffer);
 		w = buffer;
 
 		r++; // chomp the %
 
 		switch (*r++) {
 			case L'%':
-				m_out->output_string(const_cast<wchar_t*>(L"%"));
+				m_out->OutputString(m_out, const_cast<wchar_t*>(L"%"));
 				count++;
 				break;
 
@@ -218,7 +189,7 @@ console::vprintf(const wchar_t *fmt, va_list args) const
 				{
 					wchar_t *s = va_arg(args, wchar_t*);
 					count += wstrlen(s);
-					m_out->output_string(s);
+					m_out->OutputString(m_out, s);
 				}
 				break;
 
@@ -244,7 +215,7 @@ console::vprintf(const wchar_t *fmt, va_list args) const
 	}
 
 	*w = 0;
-	m_out->output_string(buffer);
+	m_out->OutputString(m_out, buffer);
 	return count;
 }
 
@@ -272,123 +243,41 @@ console::print(const wchar_t *fmt, ...)
 	return result;
 }
 
-status_line::status_line(const wchar_t *message, const wchar_t *context) :
-	m_level(level_ok)
+void
+console::status_begin(const wchar_t *message) const
 {
-	auto out = console::get().m_out;
-	m_line = out->mode->cursor_row;
-	m_depth = (s_current ? 1 + s_current->m_depth : 0);
-
-	int indent = 2 * m_depth;
-	out->set_cursor_position(indent, m_line);
-	out->set_attribute(uefi::attribute::light_gray);
-	out->output_string(message);
-
-	if (context) {
-		out->output_string(L": ");
-		out->output_string(context);
-	}
-
-	out->output_string(L"\r\n");
-
-	m_next = s_current;
-	s_current = this;
-}
-
-status_line::~status_line()
-{
-	if (s_current != this)
-		error::raise(uefi::status::unsupported, L"Destroying non-current status_line");
-
-	finish();
-	if (m_next && m_level > m_next->m_level) {
-		m_next->m_level = m_level;
-		m_next->print_status_tag();
-	}
-	s_current = m_next;
+	m_out->SetAttribute(m_out, EFI_LIGHTGRAY);
+	m_out->OutputString(m_out, (wchar_t *)message);
 }
 
 void
-status_line::print_status_tag()
+console::status_ok() const
 {
-	auto out = console::get().m_out;
-	int row = out->mode->cursor_row;
-	int col = out->mode->cursor_column;
-
-	uefi::attribute color = level_colors[m_level];
-	const wchar_t *tag = level_tags[m_level];
-
-	out->set_cursor_position(50, m_line);
-
-	out->set_attribute(uefi::attribute::light_gray);
-	out->output_string(L"[");
-	out->set_attribute(color);
-	out->output_string(tag);
-	out->set_attribute(uefi::attribute::light_gray);
-	out->output_string(L"]\r\n");
-
-	out->set_cursor_position(col, row);
+	m_out->SetAttribute(m_out, EFI_LIGHTGRAY);
+	m_out->OutputString(m_out, (wchar_t *)L"[");
+	m_out->SetAttribute(m_out, EFI_GREEN);
+	m_out->OutputString(m_out, (wchar_t *)L"  ok  ");
+	m_out->SetAttribute(m_out, EFI_LIGHTGRAY);
+	m_out->OutputString(m_out, (wchar_t *)L"]\r\n");
 }
 
 void
-status_line::do_warn(const wchar_t *message, const wchar_t *error)
+console::status_fail(const wchar_t *error) const
 {
-	auto out = console::get().m_out;
-	int row = out->mode->cursor_row;
+	m_out->SetAttribute(m_out, EFI_LIGHTGRAY);
+	m_out->OutputString(m_out, (wchar_t *)L"[");
+	m_out->SetAttribute(m_out, EFI_LIGHTRED);
+	m_out->OutputString(m_out, (wchar_t *)L"failed");
+	m_out->SetAttribute(m_out, EFI_LIGHTGRAY);
+	m_out->OutputString(m_out, (wchar_t *)L"]\r\n");
 
-	if (m_level < level_warn) {
-		m_level = level_warn;
-		print_status_tag();
-	}
-
-	int indent = 2 + 2 * m_depth;
-	out->set_cursor_position(indent, row);
-	out->set_attribute(uefi::attribute::yellow);
-	out->output_string(message);
-
-	if (error) {
-		out->output_string(L": ");
-		out->output_string(error);
-	}
-
-	out->set_attribute(uefi::attribute::light_gray);
-	out->output_string(L"\r\n");
+	m_out->SetAttribute(m_out, EFI_RED);
+	m_out->OutputString(m_out, (wchar_t *)error);
+	m_out->SetAttribute(m_out, EFI_LIGHTGRAY);
+	m_out->OutputString(m_out, (wchar_t *)L"\r\n");
 }
 
-void
-status_line::do_fail(const wchar_t *message, const wchar_t *error)
-{
-	auto out = console::get().m_out;
-	int row = out->mode->cursor_row;
-
-	if (s_current->m_level < level_fail) {
-		m_level = level_fail;
-		print_status_tag();
-	}
-
-	int indent = 2 + 2 * m_depth;
-	out->set_cursor_position(indent, row);
-	out->set_attribute(uefi::attribute::red);
-	out->output_string(message);
-
-	if (error) {
-		out->output_string(L": ");
-		out->output_string(error);
-	}
-
-	out->set_attribute(uefi::attribute::light_gray);
-	out->output_string(L"\r\n");
-}
-
-void
-status_line::finish()
-{
-	if (m_level <= level_ok)
-		print_status_tag();
-}
-
-/*
-uefi::status
+EFI_STATUS
 con_get_framebuffer(
 	EFI_BOOT_SERVICES *bootsvc,
 	void **buffer,
@@ -399,17 +288,17 @@ con_get_framebuffer(
 	uint32_t *gmask,
 	uint32_t *bmask)
 {
-	uefi::status status;
+	EFI_STATUS status;
 
-	uefi::protos::graphics_output *gop;
+	EFI_GRAPHICS_OUTPUT_PROTOCOL *gop;
 	status = bootsvc->LocateProtocol(&guid_gfx_out, NULL, (void **)&gop);
 	if (status != EFI_NOT_FOUND) {
 		CHECK_EFI_STATUS_OR_RETURN(status, "LocateProtocol gfx");
 
 		*buffer = (void *)gop->Mode->FrameBufferBase;
 		*buffer_size = gop->Mode->FrameBufferSize;
-		*hres = gop->Mode->Info->horizontal_resolution;
-		*vres = gop->Mode->Info->vertical_resolution;
+		*hres = gop->Mode->Info->HorizontalResolution;
+		*vres = gop->Mode->Info->VerticalResolution;
 
 		switch (gop->Mode->Info->PixelFormat) {
 			case PixelRedGreenBlueReserved8BitPerColor:
@@ -442,6 +331,3 @@ con_get_framebuffer(
 	*rmask = *gmask = *bmask = 0;
 	return EFI_SUCCESS;
 }
-*/
-
-} // namespace boot

src/boot/console.h

@@ -1,18 +1,18 @@
-/// \file console.h
-/// Text output and status message handling
 #pragma once
 #include <stdarg.h>
 #include <stddef.h>
-#include <uefi/boot_services.h>
-#include <uefi/protos/simple_text_output.h>
+#include <efi/efi.h>
 
-namespace boot {
-
-/// Object providing basic output functionality to the UEFI console
 class console
 {
 public:
-	console(uefi::boot_services *bs, uefi::protos::simple_text_output *out);
+	console(EFI_SYSTEM_TABLE *system_table);
+
+	EFI_STATUS initialize(const wchar_t *version);
+
+	void status_begin(const wchar_t *message) const;
+	void status_fail(const wchar_t *error) const;
+	void status_ok() const;
 
 	size_t print_hex(uint32_t n) const;
 	size_t print_dec(uint32_t n) const;
@@ -20,61 +20,27 @@ public:
 	size_t print_long_dec(uint64_t n) const;
 	size_t printf(const wchar_t *fmt, ...) const;
 
-	static console & get() { return *s_console; }
+	static const console & get() { return *s_console; }
 	static size_t print(const wchar_t *fmt, ...);
 
 private:
-	friend class status_line;
-
-	void pick_mode(uefi::boot_services *bs);
+	EFI_STATUS pick_mode();
 	size_t vprintf(const wchar_t *fmt, va_list args) const;
 
 	size_t m_rows, m_cols;
-	uefi::protos::simple_text_output *m_out;
+	EFI_BOOT_SERVICES *m_boot;
+	EFI_SIMPLE_TEXT_OUT_PROTOCOL *m_out;
 
 	static console *s_console;
 };
 
-/// Scoped status line reporter. Prints a message and an "OK" if no errors
-/// or warnings were reported before destruction, otherwise reports the
-/// error or warning.
-class status_line
-{
-public:
-	/// Constructor.
-	/// \arg message  Description of the operation in progress
-	/// \arg context  If non-null, printed after `message` and a colon
-	status_line(const wchar_t *message, const wchar_t *context = nullptr);
-	~status_line();
-
-	/// Set the state to warning, and print a message. If the state is already at
-	/// warning or error, the state is unchanged but the message is still printed.
-	/// \arg message  The warning message to print
-	/// \arg error    If non-null, printed after `message`
-	inline static void warn(const wchar_t *message, const wchar_t *error = nullptr) {
-		if (s_current) s_current->do_warn(message, error);
-	}
-
-	/// Set the state to error, and print a message. If the state is already at
-	/// error, the state is unchanged but the message is still printed.
-	/// \arg message  The error message to print
-	/// \arg error    If non-null, printed after `message`
-	inline static void fail(const wchar_t *message, const wchar_t *error = nullptr) {
-		if (s_current) s_current->do_fail(message, error);
-	}
-
-private:
-	void print_status_tag();
-	void do_warn(const wchar_t *message, const wchar_t *error);
-	void do_fail(const wchar_t *message, const wchar_t *error);
-	void finish();
-
-	size_t m_line;
-	int m_level;
-	int m_depth;
-
-	status_line *m_next;
-	static status_line *s_current;
-};
-
-} // namespace boot
+EFI_STATUS
+con_get_framebuffer(
+	EFI_BOOT_SERVICES *bootsvc,
+	void **buffer,
+	size_t *buffer_size,
+	uint32_t *hres,
+	uint32_t *vres,
+	uint32_t *rmask,
+	uint32_t *gmask,
+	uint32_t *bmask);

src/boot/crt0.s

@@ -0,0 +1,85 @@
+;   crt0-efi-x86_64.S - x86_64 EFI startup code.
+;   Copyright (C) 1999 Hewlett-Packard Co.
+;	Contributed by David Mosberger <davidm@hpl.hp.com>.
+;   Copyright (C) 2005 Intel Co.
+;	Contributed by Fenghua Yu <fenghua.yu@intel.com>.
+;
+;    All rights reserved.
+;
+;    Redistribution and use in source and binary forms, with or without
+;    modification, are permitted provided that the following conditions
+;    are met:
+;
+;    * Redistributions of source code must retain the above copyright
+;      notice, this list of conditions and the following disclaimer.
+;    * Redistributions in binary form must reproduce the above
+;      copyright notice, this list of conditions and the following
+;      disclaimer in the documentation and/or other materials
+;      provided with the distribution.
+;    * Neither the name of Hewlett-Packard Co. nor the names of its
+;      contributors may be used to endorse or promote products derived
+;      from this software without specific prior written permission.
+;
+;    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+;    CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+;    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+;    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+;    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+;    BE LIABLE FOR ANYDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+;    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+;    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+;    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+;    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+;    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+;    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+;    SUCH DAMAGE.
+;
+;	2018-05-05 Converted to NASM syntax by Justin C. Miller
+
+extern ImageBase
+extern _DYNAMIC
+extern _relocate
+extern efi_main
+
+section .text
+align 4
+
+global _start
+_start:
+	sub rsp, 8
+	push rcx
+	push rdx
+
+	; These are already in RDI/RSI from EFI calling us, right? -justin
+	;lea rdi, [ImageBase]
+	;lea rsi, [_DYNAMIC]
+
+	pop rcx
+	pop rdx
+	push rcx
+	push rdx
+	call _relocate
+
+	pop rdi
+	pop rsi
+
+	call efi_main
+	add rsp, 8
+
+.exit:	
+  	ret
+
+; hand-craft a dummy .reloc section so EFI knows it's a relocatable executable:
+section .data
+dummy:
+	dd 0
+
+
+%define IMAGE_REL_ABSOLUTE	0
+
+section .reloc
+label1:
+	dd 0							; Page RVA
+ 	dd 10							; Block Size (2*4+2)
+	dw (IMAGE_REL_ABSOLUTE<<12) + 0	; reloc for dummy
+

src/boot/elf.h

@@ -1,32 +1,46 @@
-/// \file elf.h
-/// Definitions and related constants for ELF64 structures
 #pragma once
 #include <stdint.h>
 
-namespace boot {
-namespace elf {
+#ifndef ELF_VERSION
+#define ELF_VERSION 1
+#endif
 
-constexpr uint8_t version = 1;
-constexpr uint8_t word_size = 2;
-constexpr uint8_t endianness = 1;
-constexpr uint8_t os_abi = 0;
-constexpr uint16_t machine = 0x3e;
+#ifndef ELF_WORDSIZE
+#define ELF_WORDSIZE 2
+#endif
 
-const unsigned PT_LOAD = 1;
-const unsigned ST_PROGBITS = 1;
-const unsigned ST_NOBITS = 8;
-const unsigned long SHF_ALLOC = 0x2;
+#ifndef ELF_ENDIAN
+#define ELF_ENDIAN 1
+#endif
 
-struct header
+#ifndef ELF_OSABI
+#define ELF_OSABI 0
+#endif
+
+#ifndef ELF_MACHINE
+#define ELF_MACHINE 0x3e
+#endif
+
+const unsigned ELF_PT_LOAD = 1;
+const unsigned ELF_ST_PROGBITS = 1;
+const unsigned ELF_ST_NOBITS = 8;
+const unsigned long ELF_SHF_ALLOC = 0x2;
+
+struct elf_ident
 {
 	char magic[4];
 
 	uint8_t word_size;
 	uint8_t endianness;
-	uint8_t header_version;
+	uint8_t version;
 	uint8_t os_abi;
 
 	uint64_t reserved;
+} __attribute__ ((packed));
+
+struct elf_header
+{
+	struct elf_ident ident;
 
 	uint16_t type;
 	uint16_t machine;
@@ -50,7 +64,7 @@ struct header
 	uint16_t sh_str_idx;
 } __attribute__ ((packed));
 
-struct program_header
+struct elf_program_header
 {
 	uint32_t type;
 	uint32_t flags;
@@ -65,7 +79,7 @@ struct program_header
 	uint64_t align;
 } __attribute__ ((packed));
 
-struct section_header
+struct elf_section_header
 {
 	uint32_t name;
 	uint32_t type;
@@ -78,6 +92,3 @@ struct section_header
 	uint64_t align;
 	uint64_t entry_size;
 } __attribute__ ((packed));
-
-} // namespace elf
-} // namespace boot

src/boot/error.cpp

@@ -1,94 +0,0 @@
-#include "error.h"
-#include "console.h"
-
-namespace boot {
-namespace error {
-
-handler *handler::s_current = nullptr;
-
-struct error_code_desc {
-	uefi::status code;
-	const wchar_t *name;
-};
-
-struct error_code_desc error_table[] = {
-#define STATUS_ERROR(name, num) { uefi::status::name, L#name },
-#define STATUS_WARNING(name, num) { uefi::status::name, L#name },
-#include "uefi/errors.inc"
-#undef STATUS_ERROR
-#undef STATUS_WARNING
-	{ uefi::status::success, nullptr }
-};
-
-static const wchar_t *
-error_message(uefi::status status)
-{
-	int32_t i = -1;
-	while (error_table[++i].name != nullptr) {
-		if (error_table[i].code == status) return error_table[i].name;
-	}
-
-	if (uefi::is_error(status))
-		return L"Unknown Error";
-	else
-		return L"Unknown Warning";
-}
-
-[[ noreturn ]] void
-raise(uefi::status status, const wchar_t *message)
-{
-	if (handler::s_current) {
-		handler::s_current->handle(status, message);
-	}
-	while (1) asm("hlt");
-}
-
-handler::handler() :
-	m_next(s_current)
-{
-	s_current = this;
-}
-
-handler::~handler()
-{
-	if (s_current != this)
-		raise(uefi::status::warn_stale_data,
-				L"Non-current error handler destructing");
-	s_current = m_next;
-}
-
-uefi_handler::uefi_handler(console &con) :
-	handler(),
-	m_con(con)
-{
-}
-
-void
-uefi_handler::handle(uefi::status s, const wchar_t *message)
-{
-	status_line::fail(message, error_message(s));
-}
-
-cpu_assert_handler::cpu_assert_handler() : handler() {}
-
-void
-cpu_assert_handler::handle(uefi::status s, const wchar_t *message)
-{
-	asm volatile (
-		"movq $0xeeeeeeebadbadbad, %%r8;"
-		"movq %0, %%r9;"
-		"movq $0, %%rdx;"
-		"divq %%rdx;"
-		:
-		: "r"((uint64_t)s)
-		: "rax", "rdx", "r8", "r9");
-}
-
-} // namespace error
-} // namespace boot
-
-void debug_break()
-{
-	volatile int go = 0;
-	while (!go);
-}

src/boot/error.h

@@ -1,74 +0,0 @@
-/// \file error.h
-/// Error handling definitions
-#pragma once
-
-#include <stddef.h>
-#include <uefi/types.h>
-
-namespace boot {
-
-class console;
-
-namespace error {
-
-/// Halt or exit the program with the given error status/message
-[[ noreturn ]] void raise(uefi::status status, const wchar_t *message);
-
-/// Interface for error-handling functors
-class handler
-{
-public:
-	/// Constructor must be called by implementing classes.
-	handler();
-	virtual ~handler();
-
-	/// Interface for implementations of error handling.
-	virtual void handle(uefi::status, const wchar_t*) = 0;
-
-private:
-	friend void raise(uefi::status, const wchar_t *);
-
-	handler *m_next;
-	static handler *s_current;
-};
-
-/// Error handler using UEFI boot services. Integrates with `status_line`
-/// to print formatted error messages to the screen.
-class uefi_handler :
-	public handler
-{
-public:
-	uefi_handler(console &con);
-	virtual ~uefi_handler() {}
-	void handle(uefi::status, const wchar_t*) override;
-
-private:
-	console &m_con;
-};
-
-/// Error handler that doesn't rely on UEFI. Sets status into CPU
-/// registers and then causes a CPU #DE exception.
-class cpu_assert_handler :
-	public handler
-{
-public:
-	cpu_assert_handler();
-	virtual ~cpu_assert_handler() {}
-	void handle(uefi::status, const wchar_t*) override;
-};
-
-} // namespace error
-} // namespace boot
-
-/// Debugging psuedo-breakpoint.
-void debug_break();
-
-/// Helper macro to raise an error if an operation fails.
-/// \arg s  An expression evaluating to a UEFI status
-/// \arg m  The error message to use on failure
-#define try_or_raise(s, m) \
-	do { \
-		uefi::status _s = (s); \
-		if (uefi::is_error(_s)) ::boot::error::raise(_s, (m)); \
-	} while(0)
-

src/boot/fs.cpp

@@ -1,114 +0,0 @@
-#include <uefi/types.h>
-#include <uefi/protos/file.h>
-#include <uefi/protos/file_info.h>
-#include <uefi/protos/loaded_image.h>
-#include <uefi/protos/simple_file_system.h>
-
-#include "fs.h"
-#include "console.h"
-#include "error.h"
-#include "memory.h"
-
-namespace boot {
-namespace fs {
-
-file::file(uefi::protos::file *f, uefi::boot_services *bs) :
-	m_file(f),
-	m_bs(bs)
-{
-}
-
-file::file(file &o) :
-	m_file(o.m_file),
-	m_bs(o.m_bs)
-{
-	o.m_file = nullptr;
-}
-
-file::file(file &&o) :
-	m_file(o.m_file),
-	m_bs(o.m_bs)
-{
-	o.m_file = nullptr;
-}
-
-file::~file()
-{
-	if (m_file)
-		m_file->close();
-}
-
-file
-file::open(const wchar_t *path)
-{
-	uefi::protos::file *fh = nullptr;
-
-	try_or_raise(
-		m_file->open(&fh, path, uefi::file_mode::read, uefi::file_attr::none),
-		L"Could not open relative path to file");
-
-	return file(fh, m_bs);
-}
-
-void *
-file::load(size_t *out_size, uefi::memory_type mem_type)
-{
-	uint8_t buffer[sizeof(uefi::protos::file_info) + 100];
-	size_t size = sizeof(buffer);
-	uefi::guid info_guid = uefi::protos::file_info::guid;
-
-	try_or_raise(
-		m_file->get_info(&info_guid, &size, &buffer),
-		L"Could not get file info");
-
-	uefi::protos::file_info *info =
-		reinterpret_cast<uefi::protos::file_info*>(&buffer);
-
-	size_t pages = memory::bytes_to_pages(info->file_size);
-	void *data = nullptr;
-	try_or_raise(
-		m_bs->allocate_pages(
-			uefi::allocate_type::any_pages,
-			mem_type, pages, &data),
-		L"Could not allocate pages to load file");
-
-	size = info->file_size;
-	try_or_raise(
-		m_file->read(&size, data),
-		L"Could not read from file");
-
-	*out_size = size;
-	return data;
-}
-
-file
-get_boot_volume(uefi::handle image, uefi::boot_services *bs)
-{
-	status_line status(L"Looking up boot volume");
-
-	const uefi::guid le_guid = uefi::protos::loaded_image::guid;
-	uefi::protos::loaded_image *loaded_image = nullptr;
-
-	try_or_raise(
-		bs->handle_protocol(image, &le_guid,
-			reinterpret_cast<void**>(&loaded_image)),
-		L"Could not find currently running UEFI loaded image");
-
-	const uefi::guid sfs_guid = uefi::protos::simple_file_system::guid;
-	uefi::protos::simple_file_system *fs;
-	try_or_raise(
-		bs->handle_protocol(loaded_image->device_handle, &sfs_guid,
-			reinterpret_cast<void**>(&fs)),
-		L"Could not find filesystem protocol for boot volume");
-
-	uefi::protos::file *f;
-	try_or_raise(
-		fs->open_volume(&f),
-		L"Could not open the boot volume");
-
-	return file(f, bs);
-}
-
-} // namespace fs
-} // namespace boot
-

src/boot/fs.h

@@ -1,47 +0,0 @@
-/// \file fs.h
-/// Definitions for dealing with UEFI's disk access functions
-#pragma once
-
-#include <uefi/types.h>
-#include <uefi/boot_services.h>
-#include <uefi/protos/file.h>
-
-namespace boot {
-namespace fs {
-
-/// A file or directory in a filesystem.
-class file
-{
-public:
-	file(file &&o);
-	file(file &o);
-	~file();
-
-	/// Open another file or directory, relative to this one.
-	/// \arg path  Relative path to the target file from this one
-	file open(const wchar_t *path);
-
-	/// Load the contents of this file into memory.
-	/// \arg out_size  _out:_ The number of bytes loaded
-	/// \arg mem_type  The UEFI memory type to use for allocation
-	/// \returns       A pointer to the loaded memory. Memory will be
-	///                page-aligned.
-	void * load(
-		size_t *out_size,
-		uefi::memory_type mem_type = uefi::memory_type::loader_data);
-
-private:
-	friend file get_boot_volume(uefi::handle, uefi::boot_services*);
-
-	file(uefi::protos::file *f, uefi::boot_services *bs);
-
-	uefi::protos::file *m_file;
-	uefi::boot_services *m_bs;
-};
-
-/// Get the filesystem this loader was loaded from.
-/// \returns  A `file` object representing the root directory of the volume
-file get_boot_volume(uefi::handle image, uefi::boot_services *bs);
-
-} // namespace fs
-} // namespace boot

src/boot/hardware.cpp

@@ -1,54 +0,0 @@
-#include "hardware.h"
-#include "console.h"
-#include "error.h"
-
-namespace boot {
-namespace hw {
-
-void *
-find_acpi_table(uefi::system_table *st)
-{
-	status_line status(L"Searching for ACPI table");
-
-	// Find ACPI tables. Ignore ACPI 1.0 if a 2.0 table is found.
-	uintptr_t acpi1_table = 0;
-
-	for (size_t i = 0; i < st->number_of_table_entries; ++i) {
-		uefi::configuration_table *table = &st->configuration_table[i];
-
-		// If we find an ACPI 2.0 table, return it immediately
-		if (table->vendor_guid == uefi::vendor_guids::acpi2)
-			return table->vendor_table;
-
-		if (table->vendor_guid == uefi::vendor_guids::acpi1) {
-			// Mark a v1 table with the LSB high
-			acpi1_table = reinterpret_cast<uintptr_t>(table->vendor_table);
-			acpi1_table |= 1;
-		}
-	}
-
-	if (!acpi1_table) {
-		error::raise(uefi::status::not_found, L"Could not find ACPI table");
-	} else if (acpi1_table & 1) {
-		status_line::warn(L"Only found ACPI 1.0 table");
-	}
-
-	return reinterpret_cast<void*>(acpi1_table);
-}
-
-void
-setup_cr4()
-{
-	uint64_t cr4 = 0;
-	asm volatile ( "mov %%cr4, %0" : "=r" (cr4) );
-	cr4 |=
-		0x000080 | // Enable global pages
-		0x000200 | // Enable FXSAVE/FXRSTOR
-		0x010000 | // Enable FSGSBASE
-		0x020000 | // Enable PCIDs
-		0;
-	asm volatile ( "mov %0, %%cr4" :: "r" (cr4) );
-}
-
-} // namespace hw
-} // namespace boot

src/boot/hardware.h

@@ -1,20 +0,0 @@
-/// \file hardware.h
-/// Functions and definitions for detecting and dealing with hardware
-#pragma once
-
-#include <uefi/tables.h>
-
-namespace boot {
-namespace hw {
-
-/// Find the ACPI table in the system configuration tables
-/// and return a pointer to it. If only an ACPI 1.0 table is
-/// available, the returned pointer will have its least
-/// significant bit set to 1.
-void * find_acpi_table(uefi::system_table *st);
-
-/// Enable CPU options in CR4 for the kernel starting state.
-void setup_cr4();
-
-} // namespace hw
-} // namespace boot

src/boot/loader.cpp

@@ -1,74 +1,298 @@
-#include <uefi/boot_services.h>
-#include <uefi/types.h>
-
-#include "loader.h"
-#include "console.h"
 #include "elf.h"
-#include "error.h"
+#include "guids.h"
+#include "loader.h"
 #include "memory.h"
-#include "paging.h"
+#include "utility.h"
 
-namespace boot {
-namespace loader {
+#define PAGE_SIZE 0x1000
 
-static bool
-is_elfheader_valid(const elf::header *header)
+static wchar_t kernel_name[] = KERNEL_FILENAME;
+static wchar_t initrd_name[] = INITRD_FILENAME;
+
+EFI_STATUS
+loader_alloc_aligned(
+	EFI_BOOT_SERVICES *bootsvc,
+	EFI_MEMORY_TYPE mem_type,
+	size_t *length,
+	void **pages)
 {
-	return
-		header->magic[0] == 0x7f &&
-		header->magic[1] == 'E' &&
-		header->magic[2] == 'L' &&
-		header->magic[3] == 'F' &&
-		header->word_size == elf::word_size &&
-		header->endianness == elf::endianness &&
-		header->os_abi == elf::os_abi &&
-		header->machine == elf::machine &&
-		header->header_version == elf::version;
-}
+	EFI_STATUS status;
+	EFI_PHYSICAL_ADDRESS addr;
 
-kernel::entrypoint
-load(
-	const void *data, size_t size,
-	kernel::args::header *args,
-	uefi::boot_services *bs)
-{
-	status_line status(L"Loading kernel ELF binary");
-	const elf::header *header = reinterpret_cast<const elf::header*>(data);
+	size_t alignment = PAGE_SIZE;
+	while (alignment < *length)
+		alignment *= 2;
 
-	if (size < sizeof(elf::header) || !is_elfheader_valid(header))
-		error::raise(uefi::status::load_error, L"Kernel ELF not valid");
+	size_t page_count = alignment / PAGE_SIZE;
+	*length = alignment;
 
-	paging::page_table *pml4 = reinterpret_cast<paging::page_table*>(args->pml4);
+	con_debug(L"Trying to find %d aligned pages for %x", page_count, mem_type);
 
-	for (int i = 0; i < header->ph_num; ++i) {
-		ptrdiff_t offset = header->ph_offset + i * header->ph_entsize;
-		const elf::program_header *pheader =
-			offset_ptr<elf::program_header>(data, offset);
+	status = bootsvc->AllocatePages(AllocateAnyPages, mem_type, page_count * 2, &addr);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Allocating %d pages for alignment", page_count * 2);
+	con_debug(L"    Found %d pages at %lx", page_count * 2, addr);
 
-		if (pheader->type != elf::PT_LOAD)
-			continue;
+	EFI_PHYSICAL_ADDRESS aligned = addr;
+	aligned = ((aligned - 1) & ~(alignment - 1)) + alignment;
+	con_debug(L"    Aligning %lx to %lx", addr, aligned);
 
-		size_t num_pages = memory::bytes_to_pages(pheader->mem_size);
-		void *pages = nullptr;
+	size_t before = 
+		(reinterpret_cast<uint64_t>(aligned) -
+		reinterpret_cast<uint64_t>(addr)) /
+		PAGE_SIZE;
 
-		try_or_raise(
-			bs->allocate_pages(uefi::allocate_type::any_pages,
-				memory::kernel_type, num_pages, &pages),
-			L"Failed allocating space for kernel code");
-
-		void *data_start = offset_ptr<void>(data, pheader->offset);
-		bs->copy_mem(pages, data_start, pheader->mem_size);
-
-		console::print(L"    section %d phys: 0x%lx\r\n", i, pages);
-		console::print(L"    section %d virt: 0x%lx\r\n", i, pheader->vaddr);
-
-		// TODO: set appropriate RWX permissions
-		paging::map_pages(pml4, args, reinterpret_cast<uintptr_t>(pages), pheader->vaddr, pheader->mem_size);
+	if (before) {
+		con_debug(L"    Freeing %d initial pages", before);
+		bootsvc->FreePages(addr, before);
 	}
 
-	console::print(L"    entrypoint:     0x%lx\r\n", header->entrypoint);
-	return reinterpret_cast<kernel::entrypoint>(header->entrypoint);
+	size_t after = page_count - before;
+	if (after) {
+		EFI_PHYSICAL_ADDRESS end = 
+			reinterpret_cast<EFI_PHYSICAL_ADDRESS>(
+				reinterpret_cast<uint64_t>(aligned) +
+				page_count * PAGE_SIZE);
+		con_debug(L"    Freeing %d remaining pages", after);
+		bootsvc->FreePages(end, after);
+	}
+
+	*pages = (void *)aligned;
+	return EFI_SUCCESS;
 }
 
-} // namespace loader
-} // namespace boot
+EFI_STATUS
+loader_alloc_pages(
+	EFI_BOOT_SERVICES *bootsvc,
+	EFI_MEMORY_TYPE mem_type,
+	size_t *length,
+	void **pages)
+{
+	EFI_STATUS status;
+
+	size_t page_count = ((*length - 1) / PAGE_SIZE) + 1;
+	EFI_PHYSICAL_ADDRESS addr = (EFI_PHYSICAL_ADDRESS)*pages;
+
+	con_debug(L"Trying to find %d non-aligned pages for %x at %lx",
+			page_count, mem_type, addr);
+
+	status = bootsvc->AllocatePages(AllocateAddress, mem_type, page_count, &addr);
+	CHECK_EFI_STATUS_OR_RETURN(status,
+		L"Allocating %d kernel pages type %x",
+		page_count, mem_type);
+
+	*length = page_count * PAGE_SIZE;
+	*pages = (void *)addr;
+
+	return EFI_SUCCESS;
+}
+
+EFI_STATUS
+loader_load_initrd(
+	EFI_BOOT_SERVICES *bootsvc,
+	EFI_FILE_PROTOCOL *root,
+	struct loader_data *data)
+{
+	EFI_STATUS status;
+
+	EFI_FILE_PROTOCOL *file = NULL;
+	status = root->Open(root, &file, (wchar_t *)initrd_name, EFI_FILE_MODE_READ,
+						EFI_FILE_READ_ONLY | EFI_FILE_HIDDEN | EFI_FILE_SYSTEM);
+
+	if (status == EFI_NOT_FOUND)
+		return status;
+
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Opening file %s", initrd_name);
+
+	char info[sizeof(EFI_FILE_INFO) + 100];
+	size_t info_length = sizeof(info);
+
+	status = file->GetInfo(file, &guid_file_info, &info_length, info);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Getting file info");
+
+	data->initrd_length = ((EFI_FILE_INFO *)info)->FileSize;
+
+	status = loader_alloc_aligned(
+			bootsvc,
+			memtype_initrd,
+			&data->initrd_length,
+			&data->initrd);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Allocating pages");
+
+	status = file->Read(file, &data->initrd_length, data->initrd);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Reading file");
+
+	status = file->Close(file);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Closing file handle");
+
+	return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+loader_load_elf(
+	EFI_BOOT_SERVICES *bootsvc,
+	EFI_FILE_PROTOCOL *root,
+	struct loader_data *data)
+{
+	EFI_STATUS status;
+
+	con_debug(L"Opening kernel file %s", (wchar_t *)kernel_name);
+
+	EFI_FILE_PROTOCOL *file = NULL;
+	status = root->Open(root, &file, (wchar_t *)kernel_name, EFI_FILE_MODE_READ,
+						EFI_FILE_READ_ONLY | EFI_FILE_HIDDEN | EFI_FILE_SYSTEM);
+
+	if (status == EFI_NOT_FOUND)
+		return status;
+
+	uint64_t length = 0;
+	data->kernel = 0;
+	data->kernel_entry = 0;
+	data->kernel_length = 0;
+
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Opening file %s", kernel_name);
+
+	struct elf_header header;
+
+	length = sizeof(struct elf_header);
+	status = file->Read(file, &length, &header);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Reading ELF header");
+
+	con_debug(L"Read %u bytes of ELF header", length);
+
+	if (length < sizeof(struct elf_header))
+		CHECK_EFI_STATUS_OR_RETURN(EFI_LOAD_ERROR, L"Incomplete read of ELF header");
+
+	static const char expected[] = {0x7f, 'E', 'L', 'F'};
+	for (int i = 0; i < sizeof(expected); ++i) {
+		if (header.ident.magic[i] != expected[i])
+			CHECK_EFI_STATUS_OR_RETURN(EFI_LOAD_ERROR, L"Bad ELF magic number");
+	}
+
+	if (header.ident.word_size != ELF_WORDSIZE)
+		CHECK_EFI_STATUS_OR_RETURN(EFI_LOAD_ERROR, L"ELF load error: 32 bit ELF not supported");
+
+	if (header.ph_entsize != sizeof(struct elf_program_header))
+		CHECK_EFI_STATUS_OR_RETURN(EFI_LOAD_ERROR, L"ELF load error: program header size mismatch");
+
+	if (header.ident.version != ELF_VERSION ||
+		header.version != ELF_VERSION)
+		CHECK_EFI_STATUS_OR_RETURN(EFI_LOAD_ERROR, L"ELF load error: wrong ELF version");
+
+	if (header.ident.endianness != 1 ||
+		header.ident.os_abi != 0 ||
+		header.machine != 0x3e)
+		CHECK_EFI_STATUS_OR_RETURN(EFI_LOAD_ERROR, L"ELF load error: wrong machine architecture");
+
+	con_debug(L"ELF is valid, entrypoint %lx", header.entrypoint);
+
+	data->kernel_entry = (void *)header.entrypoint;
+
+	struct elf_program_header prog_header;
+	for (int i = 0; i < header.ph_num; ++i) {
+
+		status = file->SetPosition(file, header.ph_offset + i * header.ph_entsize);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"Setting ELF file position");
+
+		length = header.ph_entsize;
+		status = file->Read(file, &length, &prog_header);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"Reading ELF program header");
+
+		if (prog_header.type != ELF_PT_LOAD) continue;
+
+		length = prog_header.mem_size;
+		void *addr = (void *)(prog_header.vaddr - KERNEL_VIRT_ADDRESS);
+		status = loader_alloc_pages(bootsvc, memtype_kernel, &length, &addr);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"Allocating kernel pages");
+
+		if (data->kernel == 0)
+			data->kernel = addr;
+		data->kernel_length = (uint64_t)addr + length - (uint64_t)data->kernel;
+	}
+	con_debug(L"Read %d ELF program headers", header.ph_num);
+
+	struct elf_section_header sec_header;
+	for (int i = 0; i < header.sh_num; ++i) {
+		status = file->SetPosition(file, header.sh_offset + i * header.sh_entsize);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"Setting ELF file position");
+
+		length = header.sh_entsize;
+		status = file->Read(file, &length, &sec_header);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"Reading ELF section header");
+
+		if ((sec_header.flags & ELF_SHF_ALLOC) == 0) {
+			continue;
+		}
+
+		void *addr = (void *)(sec_header.addr - KERNEL_VIRT_ADDRESS);
+
+		if (sec_header.type == ELF_ST_PROGBITS) {
+			status = file->SetPosition(file, sec_header.offset);
+			CHECK_EFI_STATUS_OR_RETURN(status, L"Setting ELF file position");
+
+			length = sec_header.size;
+			status = file->Read(file, &length, addr);
+			CHECK_EFI_STATUS_OR_RETURN(status, L"Reading file");
+		} else if (sec_header.type == ELF_ST_NOBITS) {
+			bootsvc->SetMem(addr, sec_header.size, 0);
+		}
+	}
+	con_debug(L"Read %d ELF section headers", header.ph_num);
+
+	status = file->Close(file);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"Closing file handle");
+
+	return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+loader_load_kernel(
+	EFI_BOOT_SERVICES *bootsvc,
+	struct loader_data *data)
+{
+	if (data == NULL)
+		CHECK_EFI_STATUS_OR_RETURN(EFI_INVALID_PARAMETER, L"NULL loader_data");
+
+	EFI_STATUS status;
+	EFI_HANDLE *handles = NULL;
+	size_t handleCount = 0;
+
+	status = bootsvc->LocateHandleBuffer(ByProtocol, &guid_simple_filesystem, NULL, &handleCount, &handles);
+	CHECK_EFI_STATUS_OR_RETURN(status, L"LocateHandleBuffer");
+
+	for (unsigned i = 0; i < handleCount; ++i) {
+		EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *fileSystem = NULL;
+
+		status = bootsvc->HandleProtocol(handles[i], &guid_simple_filesystem, (void **)&fileSystem);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"HandleProtocol");
+
+		EFI_FILE_PROTOCOL *root = NULL;
+		status = fileSystem->OpenVolume(fileSystem, &root);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"OpenVolume");
+
+		status = loader_load_elf(bootsvc, root, data);
+		if (status == EFI_NOT_FOUND)
+			continue;
+
+		CHECK_EFI_STATUS_OR_RETURN(status, L"loader_load_elf: %s", kernel_name);
+
+		data->data = (void *)((uint64_t)data->kernel + data->kernel_length);
+		data->data_length += PAGE_SIZE; // extra page for map growth
+
+		status = loader_alloc_aligned(
+				bootsvc,
+				memtype_data,
+				&data->data_length,
+				&data->data);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"loader_alloc_aligned: kernel data");
+
+		data->initrd = (void *)((uint64_t)data->data + data->data_length);
+		status = loader_load_initrd(bootsvc, root, data);
+		CHECK_EFI_STATUS_OR_RETURN(status, L"loader_load_file: %s", initrd_name);
+
+		return EFI_SUCCESS;
+	}
+
+	return EFI_NOT_FOUND;
+}

src/boot/loader.h

@@ -1,23 +1,35 @@
-/// \file loader.h
-/// Definitions for loading the kernel into memory
 #pragma once
+#include <efi/efi.h>
+#include <stddef.h>
 
-#include <uefi/boot_services.h>
+#define PAGE_SIZE 0x1000
 
-#include "kernel_args.h"
+#ifndef KERNEL_PHYS_ADDRESS
+#define KERNEL_PHYS_ADDRESS 0x100000
+#endif
 
-namespace boot {
-namespace loader {
+#ifndef KERNEL_VIRT_ADDRESS
+#define KERNEL_VIRT_ADDRESS 0xFFFFFF0000000000
+#endif
 
-/// Parse and load an ELF file in memory into a loaded image.
-/// \arg data  The start of the ELF file in memory
-/// \arg size  The size of the ELF file in memory
-/// \arg args  The kernel args, used for modifying page tables
-/// \returns   A descriptor defining the loaded image
-kernel::entrypoint load(
-	const void *data, size_t size,
-	kernel::args::header *args,
-	uefi::boot_services *bs);
+#ifndef KERNEL_FILENAME
+#define KERNEL_FILENAME L"kernel.elf"
+#endif
 
-} // namespace loader
-} // namespace boot
+#ifndef INITRD_FILENAME
+#define INITRD_FILENAME L"initrd.img"
+#endif
+
+struct loader_data {
+	void *kernel;
+	void *kernel_entry;
+	size_t kernel_length;
+
+	void *initrd;
+	size_t initrd_length;
+
+	void *data;
+	size_t data_length;
+};
+
+EFI_STATUS loader_load_kernel(EFI_BOOT_SERVICES *bootsvc, struct loader_data *data);

src/boot/main.cpp

@@ -1,165 +1,227 @@
-#include <uefi/types.h>
-#include <uefi/guid.h>
-#include <uefi/tables.h>
-#include <uefi/protos/simple_text_output.h>
-
 #include <stdalign.h>
 #include <stddef.h>
-#include <stdint.h>
+
+#include <efi/efi.h>
 
 #include "console.h"
-#include "error.h"
-#include "fs.h"
-#include "hardware.h"
+#include "guids.h"
+#include "kernel_args.h"
 #include "loader.h"
 #include "memory.h"
-#include "paging.h"
+#include "utility.h"
 
-#include "kernel_args.h"
+#ifndef SCRATCH_PAGES
+#define SCRATCH_PAGES 64
+#endif
 
-namespace kernel {
-#include "kernel_memory.h"
+#ifndef GIT_VERSION_WIDE
+#define GIT_VERSION_WIDE L"no version"
+#endif
+
+#define KERNEL_HEADER_MAGIC   0x600db007
+#define KERNEL_HEADER_VERSION 1
+
+#pragma pack(push, 1)
+struct kernel_header {
+	uint32_t magic;
+	uint16_t version;
+	uint16_t length;
+
+	uint8_t major;
+	uint8_t minor;
+	uint16_t patch;
+	uint32_t gitsha;
+};
+#pragma pack(pop)
+
+using kernel_entry = void (*)(kernel_args *);
+
+static void
+type_to_wchar(wchar_t *into, uint32_t type)
+{
+	for (int j=0; j<4; ++j)
+		into[j] = static_cast<wchar_t>(reinterpret_cast<char *>(&type)[j]);
 }
 
-namespace boot {
+EFI_STATUS
+detect_debug_mode(EFI_RUNTIME_SERVICES *run, kernel_args *header) {
+	wchar_t var_name[] = L"debug";
 
-constexpr int max_modules = 10; // Max modules to allocate room for
+	EFI_STATUS status;
+	uint8_t debug = 0;
+	UINTN var_size = sizeof(debug);
 
-/// Change a pointer to point to the higher-half linear-offset version
-/// of the address it points to.
-template <typename T>
-void change_pointer(T *&pointer)
-{
-	pointer = offset_ptr<T>(pointer, kernel::memory::page_offset);
+#ifdef __JSIX_SET_DEBUG_UEFI_VAR__
+	debug = __JSIX_SET_DEBUG_UEFI_VAR__;
+	uint32_t attrs =
+		EFI_VARIABLE_NON_VOLATILE |
+		EFI_VARIABLE_BOOTSERVICE_ACCESS |
+		EFI_VARIABLE_RUNTIME_ACCESS;
+	status = run->SetVariable(
+			var_name,
+			&guid_jsix_vendor,
+			attrs,
+			var_size,
+			&debug);
+	CHECK_EFI_STATUS_OR_RETURN(status, "detect_debug_mode::SetVariable");
+#endif
+
+	status = run->GetVariable(
+			var_name,
+			&guid_jsix_vendor,
+			nullptr,
+			&var_size,
+			&debug);
+	CHECK_EFI_STATUS_OR_RETURN(status, "detect_debug_mode::GetVariable");
+
+	if (debug)
+		header->flags |= JSIX_FLAG_DEBUG;
+
+	return EFI_SUCCESS;
 }
 
-/// Allocate space for kernel args. Allocates enough space from pool
-/// memory for the args header and `max_modules` module headers.
-kernel::args::header *
-allocate_args_structure(
-	uefi::boot_services *bs,
-	size_t max_modules)
+extern "C" EFI_STATUS
+efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE *system_table)
 {
-	status_line status(L"Setting up kernel args memory");
+	EFI_STATUS status;
+	EFI_BOOT_SERVICES *bootsvc = system_table->BootServices;
+	EFI_RUNTIME_SERVICES *runsvc = system_table->RuntimeServices;
 
-	kernel::args::header *args = nullptr;
+	console con(system_table);
 
-	size_t args_size =
-		sizeof(kernel::args::header) + // The header itself
-		max_modules * sizeof(kernel::args::module); // The module structures
+	// When checking console initialization, use CHECK_EFI_STATUS_OR_RETURN
+	// because we can't be sure if the console was fully set up
+	status = con.initialize(GIT_VERSION_WIDE);
+	CHECK_EFI_STATUS_OR_RETURN(status, "console::initialize");
+	// From here on out, we can use CHECK_EFI_STATUS_OR_FAIL instead
 
-	try_or_raise(
-		bs->allocate_pool(memory::args_type, args_size,
-			reinterpret_cast<void**>(&args)),
-		L"Could not allocate argument memory");
+	memory_init_pointer_fixup(bootsvc, runsvc, SCRATCH_PAGES);
 
-	bs->set_mem(args, args_size, 0);
-
-	args->modules =
-		reinterpret_cast<kernel::args::module*>(args + 1);
-	args->num_modules = 0;
-
-	return args;
-}
-
-/// Load a file from disk into memory. Also adds an entry to the kernel
-/// args module headers pointing at the loaded data.
-/// \arg disk  The opened UEFI filesystem to load from
-/// \arg args  The kernel args header to update with module information
-/// \arg name  Name of the module (informational only)
-/// \arg path  Path on `disk` of the file to load
-/// \arg type  Type specifier of this module (eg, initrd or kernel)
-kernel::args::module *
-load_module(
-	fs::file &disk,
-	kernel::args::header *args,
-	const wchar_t *name,
-	const wchar_t *path,
-	kernel::args::mod_type type)
-{
-	status_line status(L"Loading module", name);
-
-	fs::file file = disk.open(path);
-	kernel::args::module &module = args->modules[args->num_modules++];
-	module.type = type;
-	module.location = file.load(&module.size, memory::module_type);
-
-	console::print(L"    Loaded at: 0x%lx, %d bytes\r\n", module.location, module.size);
-	return &module;
-}
-
-/// The main procedure for the portion of the loader that runs while
-/// UEFI is still in control of the machine. (ie, while the loader still
-/// has access to boot services.
-kernel::args::header *
-bootloader_main_uefi(
-	uefi::handle image,
-	uefi::system_table *st,
-	console &con,
-	kernel::entrypoint *kentry)
-{
-	error::uefi_handler handler(con);
-	status_line status(L"Performing UEFI pre-boot");
-
-	uefi::boot_services *bs = st->boot_services;
-	uefi::runtime_services *rs = st->runtime_services;
-	memory::init_pointer_fixup(bs, rs);
-
-	kernel::args::header *args =
-		allocate_args_structure(bs, max_modules);
-
-	args->magic = kernel::args::magic;
-	args->version = kernel::args::version;
-	args->runtime_services = rs;
-	args->acpi_table = hw::find_acpi_table(st);
-
-	memory::mark_pointer_fixup(&args->runtime_services);
-
-	fs::file disk = fs::get_boot_volume(image, bs);
-	load_module(disk, args, L"initrd", L"initrd.img", kernel::args::mod_type::initrd);
-
-	kernel::args::module *kernel =
-		load_module(disk, args, L"kernel", L"jsix.elf", kernel::args::mod_type::kernel);
-
-	paging::allocate_tables(args, bs);
-	*kentry = loader::load(kernel->location, kernel->size, args, bs);
-
-	for (unsigned i = 0; i < args->num_modules; ++i) {
-		kernel::args::module &mod = args->modules[i];
-		change_pointer(mod.location);
+	// Find ACPI tables. Ignore ACPI 1.0 if a 2.0 table is found.
+	//
+	void *acpi_table = NULL;
+	for (size_t i=0; i<system_table->NumberOfTableEntries; ++i) {
+		EFI_CONFIGURATION_TABLE *efi_table = &system_table->ConfigurationTable[i];
+		if (is_guid(&efi_table->VendorGuid, &guid_acpi2)) {
+			acpi_table = efi_table->VendorTable;
+			break;
+		} else if (is_guid(&efi_table->VendorGuid, &guid_acpi1)) {
+			// Mark a v1 table with the LSB high
+			acpi_table = (void *)((intptr_t)efi_table->VendorTable | 0x1);
+		}
 	}
 
-	return args;
+	// Compute necessary number of data pages
+	//
+	size_t data_length = 0;
+	status = memory_get_map_length(bootsvc, &data_length);
+	CHECK_EFI_STATUS_OR_FAIL(status);
+
+	size_t header_size = sizeof(kernel_args);
+	const size_t header_align = alignof(kernel_args);
+	if (header_size % header_align)
+		header_size += header_align - (header_size % header_align);
+
+	data_length += header_size;
+
+	// Load the kernel image from disk and check it
+	//
+	console::print(L"Loading kernel into memory...\r\n");
+
+	struct loader_data load;
+	load.data_length = data_length;
+	status = loader_load_kernel(bootsvc, &load);
+	CHECK_EFI_STATUS_OR_FAIL(status);
+
+	console::print(L"    %x image bytes  at 0x%x\r\n", load.kernel_length, load.kernel);
+	console::print(L"    %x data bytes   at 0x%x\r\n", load.data_length, load.data);
+	console::print(L"    %x initrd bytes at 0x%x\r\n", load.initrd_length, load.initrd);
+
+	struct kernel_header *version = (struct kernel_header *)load.kernel;
+	if (version->magic != KERNEL_HEADER_MAGIC) {
+		console::print(L"    bad magic %x\r\n", version->magic);
+		CHECK_EFI_STATUS_OR_FAIL(EFI_CRC_ERROR);
+	}
+
+	console::print(L"    Kernel version %d.%d.%d %x%s\r\n",
+			version->major, version->minor, version->patch, version->gitsha & 0x0fffffff,
+			version->gitsha & 0xf0000000 ? L"*" : L"");
+	console::print(L"    Entrypoint 0x%x\r\n", load.kernel_entry);
+
+	kernel_entry kernel_main =
+		reinterpret_cast<kernel_entry>(load.kernel_entry);
+	memory_mark_pointer_fixup((void **)&kernel_main);
+
+	// Set up the kernel data pages to pass to the kernel
+	//
+	struct kernel_args *data_header = (struct kernel_args *)load.data;
+	memory_mark_pointer_fixup((void **)&data_header);
+
+	data_header->magic = DATA_HEADER_MAGIC;
+	data_header->version = DATA_HEADER_VERSION;
+	data_header->length = sizeof(struct kernel_args);
+
+	data_header->scratch_pages = SCRATCH_PAGES;
+	data_header->flags = 0;
+
+	data_header->initrd = load.initrd;
+	data_header->initrd_length = load.initrd_length;
+	memory_mark_pointer_fixup((void **)&data_header->initrd);
+
+	data_header->data = load.data;
+	data_header->data_length = load.data_length;
+	memory_mark_pointer_fixup((void **)&data_header->data);
+
+	data_header->memory_map = (EFI_MEMORY_DESCRIPTOR *)(data_header + 1);
+	memory_mark_pointer_fixup((void **)&data_header->memory_map);
+
+	data_header->runtime = runsvc;
+	memory_mark_pointer_fixup((void **)&data_header->runtime);
+
+	data_header->acpi_table = acpi_table;
+	memory_mark_pointer_fixup((void **)&data_header->acpi_table);
+
+	data_header->_reserved0 = 0;
+	data_header->_reserved1 = 0;
+
+	// Figure out the framebuffer (if any) and add that to the data header
+	//
+	status = con_get_framebuffer(
+			bootsvc, 
+			&data_header->frame_buffer,
+			&data_header->frame_buffer_length,
+			&data_header->hres,
+			&data_header->vres,
+			&data_header->rmask,
+			&data_header->gmask,
+			&data_header->bmask);
+	CHECK_EFI_STATUS_OR_FAIL(status);
+	memory_mark_pointer_fixup((void **)&data_header->frame_buffer);
+
+	// Save the memory map and tell the firmware we're taking control.
+	//
+	struct memory_map map;
+	map.length = (load.data_length - header_size);
+	map.entries =
+		reinterpret_cast<EFI_MEMORY_DESCRIPTOR *>(data_header->memory_map);
+
+	status = memory_get_map(bootsvc, &map);
+	CHECK_EFI_STATUS_OR_FAIL(status);
+
+	data_header->memory_map_length = map.length;
+	data_header->memory_map_desc_size = map.size;
+
+	detect_debug_mode(runsvc, data_header);
+
+	// bootsvc->Stall(5000000);
+
+	status = bootsvc->ExitBootServices(image_handle, map.key);
+	CHECK_EFI_STATUS_OR_ASSERT(status, 0);
+
+	memory_virtualize(runsvc, &map);
+
+	// Hand control to the kernel
+	//
+	kernel_main(data_header);
+	return EFI_LOAD_ERROR;
 }
-
-} // namespace boot
-
-/// The UEFI entrypoint for the loader.
-extern "C" uefi::status
-efi_main(uefi::handle image_handle, uefi::system_table *st)
-{
-	using namespace boot;
-
-	error::cpu_assert_handler handler;
-	console con(st->boot_services, st->con_out);
-
-	kernel::entrypoint kentry = nullptr;
-	kernel::args::header *args =
-		bootloader_main_uefi(image_handle, st, con, &kentry);
-
-	memory::efi_mem_map map =
-		memory::build_kernel_mem_map(args, st->boot_services);
-
-	try_or_raise(
-		st->boot_services->exit_boot_services(image_handle, map.key),
-		L"Failed to exit boot services");
-
-	memory::virtualize(args->pml4, map, st->runtime_services);
-	change_pointer(args->pml4);
-	hw::setup_cr4();
-
-	kentry(args);
-	debug_break();
-	return uefi::status::unsupported;
-}
-

src/boot/memory.cpp

@@ -1,275 +1,215 @@
 #include <stddef.h>
-#include <uefi/types.h>
 
-#include "kernel_memory.h"
-
-#include "console.h"
-#include "error.h"
+#include "loader.h"
 #include "memory.h"
-#include "paging.h"
+#include "utility.h"
 
-namespace boot {
-namespace memory {
+const EFI_MEMORY_TYPE memtype_kernel  = static_cast<EFI_MEMORY_TYPE>(0x80000000);
+const EFI_MEMORY_TYPE memtype_data    = static_cast<EFI_MEMORY_TYPE>(0x80000001);
+const EFI_MEMORY_TYPE memtype_initrd  = static_cast<EFI_MEMORY_TYPE>(0x80000002);
+const EFI_MEMORY_TYPE memtype_scratch = static_cast<EFI_MEMORY_TYPE>(0x80000003);
 
-using mem_entry = kernel::args::mem_entry;
-using mem_type = kernel::args::mem_type;
+#define INCREMENT_DESC(p, b)  (EFI_MEMORY_DESCRIPTOR*)(((uint8_t*)(p))+(b))
 
 size_t fixup_pointer_index = 0;
 void **fixup_pointers[64];
+uint64_t *new_pml4 = 0;
 
-static const wchar_t *memory_type_names[] = {
-	L"reserved memory type",
-	L"loader code",
-	L"loader data",
-	L"boot services code",
-	L"boot services data",
-	L"runtime services code",
-	L"runtime services data",
-	L"conventional memory",
-	L"unusable memory",
-	L"acpi reclaim memory",
-	L"acpi memory nvs",
-	L"memory mapped io",
-	L"memory mapped io port space",
-	L"pal code",
-	L"persistent memory"
+const wchar_t *memory_type_names[] = {
+	L"EfiReservedMemoryType",
+	L"EfiLoaderCode",
+	L"EfiLoaderData",
+	L"EfiBootServicesCode",
+	L"EfiBootServicesData",
+	L"EfiRuntimeServicesCode",
+	L"EfiRuntimeServicesData",
+	L"EfiConventionalMemory",
+	L"EfiUnusableMemory",
+	L"EfiACPIReclaimMemory",
+	L"EfiACPIMemoryNVS",
+	L"EfiMemoryMappedIO",
+	L"EfiMemoryMappedIOPortSpace",
+	L"EfiPalCode",
+	L"EfiPersistentMemory",
 };
 
 static const wchar_t *
-memory_type_name(uefi::memory_type t)
+memory_type_name(UINT32 value)
 {
-	if (t < uefi::memory_type::max_memory_type) {
-		return memory_type_names[static_cast<uint32_t>(t)];
-	}
-
-	switch(t) {
-		case args_type:		return L"jsix kernel args";
-		case module_type:	return L"jsix bootloader module";
-		case kernel_type:	return L"jsix kernel code";
-		case table_type:	return L"jsix page tables";
-		default: return L"Bad Type Value";
+	if (value >= (sizeof(memory_type_names) / sizeof(wchar_t *))) {
+		switch (value) {
+			case memtype_kernel:  return L"Kernel Data";
+			case memtype_data:    return L"Kernel Data";
+			case memtype_initrd:  return L"Initial Ramdisk";
+			case memtype_scratch: return L"Kernel Scratch Space";
+			default: return L"Bad Type Value";
+		}
 	}
+	return memory_type_names[value];
 }
 
-void
-update_marked_addresses(uefi::event, void *context)
+void EFIAPI
+memory_update_marked_addresses(EFI_EVENT UNUSED *event, void *context)
 {
-	uefi::runtime_services *rs =
-		reinterpret_cast<uefi::runtime_services*>(context);
-
+	EFI_RUNTIME_SERVICES *runsvc = (EFI_RUNTIME_SERVICES*)context;
 	for (size_t i = 0; i < fixup_pointer_index; ++i) {
 		if (fixup_pointers[i])
-			rs->convert_pointer(0, fixup_pointers[i]);
+			runsvc->ConvertPointer(0, fixup_pointers[i]);
 	}
 }
 
-void
-init_pointer_fixup(uefi::boot_services *bs, uefi::runtime_services *rs)
+EFI_STATUS
+memory_init_pointer_fixup(EFI_BOOT_SERVICES *bootsvc, EFI_RUNTIME_SERVICES *runsvc, unsigned scratch_pages)
 {
-	status_line status(L"Initializing pointer virtualization event");
+	EFI_STATUS status;
+	EFI_EVENT event;
 
-	uefi::event event;
-	bs->set_mem(&fixup_pointers, sizeof(fixup_pointers), 0);
-	fixup_pointer_index = 0;
+	status = bootsvc->CreateEvent(
+			EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
+			TPL_CALLBACK,
+			(EFI_EVENT_NOTIFY)&memory_update_marked_addresses,
+			runsvc,
+			&event);
 
-	try_or_raise(
-		bs->create_event(
-			uefi::evt::signal_virtual_address_change,
-			uefi::tpl::callback,
-			(uefi::event_notify)&update_marked_addresses,
-			rs,
-			&event),
-		L"Error creating memory virtualization event");
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to initialize pointer update event.");
+
+	// Reserve a page for our replacement PML4, plus some pages for the kernel to use
+	// as page tables while it gets started.
+	EFI_PHYSICAL_ADDRESS addr = 0;
+	status = bootsvc->AllocatePages(AllocateAnyPages, memtype_scratch, scratch_pages, &addr);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate page table pages.");
+
+	new_pml4 = (uint64_t *)addr;
+	return EFI_SUCCESS;
 }
 
 void
-mark_pointer_fixup(void **p)
+memory_mark_pointer_fixup(void **p)
 {
+	if (fixup_pointer_index == 0) {
+		const size_t count = sizeof(fixup_pointers) / sizeof(void*);
+		for (size_t i = 0; i < count; ++i) fixup_pointers[i] = 0;
+	}
 	fixup_pointers[fixup_pointer_index++] = p;
 }
 
-bool
-can_merge(mem_entry &prev, mem_type type, uefi::memory_descriptor *next)
+void
+copy_desc(EFI_MEMORY_DESCRIPTOR *src, EFI_MEMORY_DESCRIPTOR *dst, size_t len)
 {
-	return
-		prev.type == type &&
-		prev.start + (page_size * prev.pages) == next->physical_start &&
-		prev.attr == (next->attribute & 0xffffffff);
+	uint8_t *srcb = (uint8_t *)src;
+	uint8_t *dstb = (uint8_t *)dst;
+	uint8_t *endb = srcb + len;
+	while (srcb < endb)
+		*dstb++ = *srcb++;
+}
+
+EFI_STATUS
+memory_get_map_length(EFI_BOOT_SERVICES *bootsvc, size_t *size)
+{
+	if (size == NULL)
+		return EFI_INVALID_PARAMETER;
+
+	EFI_STATUS status;
+	size_t key, desc_size;
+	uint32_t desc_version;
+	*size = 0;
+	status = bootsvc->GetMemoryMap(size, 0, &key, &desc_size, &desc_version);
+	if (status != EFI_BUFFER_TOO_SMALL) {
+		CHECK_EFI_STATUS_OR_RETURN(status, "Failed to get memory map size");
+	}
+	return EFI_SUCCESS;
+}
+
+EFI_STATUS
+memory_get_map(EFI_BOOT_SERVICES *bootsvc, struct memory_map *map)
+{
+	EFI_STATUS status;
+
+	if (map == NULL)
+		return EFI_INVALID_PARAMETER;
+
+	size_t needs_size = 0;
+	status = memory_get_map_length(bootsvc, &needs_size);
+	if (EFI_ERROR(status)) return status;
+
+	if (map->length < needs_size)
+		return EFI_BUFFER_TOO_SMALL;
+
+	status = bootsvc->GetMemoryMap(&map->length, map->entries, &map->key, &map->size, &map->version);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map");
+	return EFI_SUCCESS;
+}
+
+EFI_STATUS
+memory_dump_map(struct memory_map *map)
+{
+	if (map == NULL)
+		return EFI_INVALID_PARAMETER;
+
+	const size_t count = map->length / map->size;
+
+	console::print(L"Memory map:\n");
+	console::print(L"\t	Descriptor Count: %d (%d bytes)\n", count, map->length);
+	console::print(L"\t  Descriptor Size: %d bytes\n", map->size);
+	console::print(L"\t      Type offset: %d\n\n", offsetof(EFI_MEMORY_DESCRIPTOR, Type));
+
+	EFI_MEMORY_DESCRIPTOR *end = INCREMENT_DESC(map->entries, map->length);
+	EFI_MEMORY_DESCRIPTOR *d = map->entries;
+	while (d < end) {
+		int runtime = (d->Attribute & EFI_MEMORY_RUNTIME) == EFI_MEMORY_RUNTIME;
+		console::print(L"%s%s ", memory_type_name(d->Type), runtime ? L"*" : L" ");
+		console::print(L"%lx ", d->PhysicalStart);
+		console::print(L"%lx ", d->VirtualStart);
+		console::print(L"[%4d]\n", d->NumberOfPages);
+
+		d = INCREMENT_DESC(d, map->size);
+	}
+
+	return EFI_SUCCESS;
 }
 
 void
-get_uefi_mappings(efi_mem_map *map, bool allocate, uefi::boot_services *bs)
+memory_virtualize(EFI_RUNTIME_SERVICES *runsvc, struct memory_map *map)
 {
-	status_line(L"Getting UEFI memory map");
+	memory_mark_pointer_fixup((void **)&runsvc);
+	memory_mark_pointer_fixup((void **)&map);
 
-	uefi::status status = bs->get_memory_map(
-		&map->length, nullptr, &map->key, &map->size, &map->version);
+	// Get the pointer to the start of PML4
+	uint64_t* cr3 = 0;
+	__asm__ __volatile__ ( "mov %%cr3, %0" : "=r" (cr3) );
 
-	if (status != uefi::status::buffer_too_small)
-		error::raise(status, L"Error getting memory map size");
+	// PML4 is indexed with bits 39:47 of the virtual address
+	uint64_t offset = (KERNEL_VIRT_ADDRESS >> 39) & 0x1ff;
 
-	if (allocate) {
-		map->length += 10*map->size;
-
-		try_or_raise(
-			bs->allocate_pool(
-				uefi::memory_type::loader_data, map->length,
-				reinterpret_cast<void**>(&map->entries)),
-			L"Allocating space for memory map");
-
-		try_or_raise(
-			bs->get_memory_map(&map->length, map->entries, &map->key, &map->size, &map->version),
-			L"Getting UEFI memory map");
-	}
-}
-
-efi_mem_map
-build_kernel_mem_map(kernel::args::header *args, uefi::boot_services *bs)
-{
-	status_line(L"Creating kernel memory map");
-
-	efi_mem_map efi_map;
-	get_uefi_mappings(&efi_map, false, bs);
-
-	size_t map_size = efi_map.num_entries() * sizeof(mem_entry);
-
-	kernel::args::mem_entry *kernel_map = nullptr;
-	try_or_raise(
-		bs->allocate_pages(
-			uefi::allocate_type::any_pages,
-			module_type,
-			bytes_to_pages(map_size),
-			reinterpret_cast<void**>(&kernel_map)),
-		L"Error allocating kernel memory map module space");
-
-	bs->set_mem(kernel_map, map_size, 0);
-	get_uefi_mappings(&efi_map, true, bs);
-
-	size_t i = 0;
-	bool first = true;
-	for (auto desc : efi_map) {
-		/*
-		console::print(L"   Range %lx (%lx) %x(%s) [%lu]\r\n",
-			desc->physical_start, desc->attribute, desc->type, memory_type_name(desc->type), desc->number_of_pages);
-		*/
-
-		mem_type type;
-		switch (desc->type) {
-			case uefi::memory_type::reserved:
-			case uefi::memory_type::unusable_memory:
-			case uefi::memory_type::acpi_memory_nvs:
-			case uefi::memory_type::pal_code:
-				continue;
-
-			case uefi::memory_type::loader_code:
-			case uefi::memory_type::loader_data:
-			case uefi::memory_type::boot_services_code:
-			case uefi::memory_type::boot_services_data:
-			case uefi::memory_type::conventional_memory:
-				type = mem_type::free;
-				break;
-
-			case uefi::memory_type::runtime_services_code:
-			case uefi::memory_type::runtime_services_data:
-				type = mem_type::uefi_runtime;
-				break;
-
-			case uefi::memory_type::acpi_reclaim_memory:
-				type = mem_type::acpi;
-				break;
-
-			case uefi::memory_type::memory_mapped_io:
-			case uefi::memory_type::memory_mapped_io_port_space:
-				type = mem_type::mmio;
-				break;
-
-			case uefi::memory_type::persistent_memory:
-				type = mem_type::persistent;
-				break;
-
-			case args_type:
-				type = mem_type::args;
-				break;
-
-			case module_type:
-				type = mem_type::module;
-				break;
-
-			case kernel_type:
-				type = mem_type::kernel;
-				break;
-
-			case table_type:
-				type = mem_type::table;
-				break;
-
-			default:
-				error::raise(
-					uefi::status::invalid_parameter,
-					L"Got an unexpected memory type from UEFI memory map");
-		}
-
-		// TODO: validate uefi's map is sorted
-		if (first) {
-			first = false;
-			kernel_map[i].start = desc->physical_start;
-			kernel_map[i].pages = desc->number_of_pages;
-			kernel_map[i].type = type;
-			kernel_map[i].attr = (desc->attribute & 0xffffffff);
-			continue;
-		}
-
-		mem_entry &prev = kernel_map[i];
-		if (can_merge(prev, type, desc)) {
-			prev.pages += desc->number_of_pages;
-		} else {
-			mem_entry &next = kernel_map[++i];
-			next.start = desc->physical_start;
-			next.pages = desc->number_of_pages;
-			next.type = type;
-			next.attr = (desc->attribute & 0xffffffff);
-		}
+	// Double map the lower half pages that are present into the higher half
+	for (unsigned i = 0; i < offset; ++i) {
+		if (cr3[i] & 0x1)
+			new_pml4[i] = new_pml4[offset+i] = cr3[i];
+		else
+			new_pml4[i] = new_pml4[offset+i] = 0;
 	}
 
-	// Give just the actually-set entries in the header
-	args->mem_map = kernel_map;
-	args->num_map_entries = i;
+	// Write our new PML4 pointer back to CR3
+	__asm__ __volatile__ ( "mov %0, %%cr3" :: "r" (new_pml4) );
 
-	// But pass the entire allocated area in a module as well
-	kernel::args::module &module = args->modules[args->num_modules++];
-	module.location = reinterpret_cast<void*>(kernel_map);
-	module.size = map_size;
-	module.type = kernel::args::mod_type::memory_map;
+	EFI_MEMORY_DESCRIPTOR *end = INCREMENT_DESC(map->entries, map->length);
+	EFI_MEMORY_DESCRIPTOR *d = map->entries;
+	while (d < end) {
+		switch (d->Type) {
+		case memtype_kernel:
+		case memtype_data:
+		case memtype_initrd:
+		case memtype_scratch:
+			d->Attribute |= EFI_MEMORY_RUNTIME;
+			d->VirtualStart = d->PhysicalStart + KERNEL_VIRT_ADDRESS;
 
-	/*
-	for (size_t i = 0; i<map.num_entries(); ++i) {
-		mem_entry &ent = kernel_map[i];
-		console::print(L"   Range %lx (%x) %d [%lu]\r\n",
-			ent.start, ent.attr, ent.type, ent.pages);
+		default:
+			if (d->Attribute & EFI_MEMORY_RUNTIME) {
+				d->VirtualStart = d->PhysicalStart + KERNEL_VIRT_ADDRESS;
+			}
+		}
+		d = INCREMENT_DESC(d, map->size);
 	}
-	*/
 
-	return efi_map;
+	runsvc->SetVirtualAddressMap(map->length, map->size, map->version, map->entries);
 }
-
-void
-virtualize(void *pml4, efi_mem_map &map, uefi::runtime_services *rs)
-{
-	paging::add_current_mappings(reinterpret_cast<paging::page_table*>(pml4));
-
-	for (auto desc : map)
-		desc->virtual_start = desc->physical_start + ::memory::page_offset;
-
-	// Write our new PML4 pointer to CR3
-	asm volatile ( "mov %0, %%cr3" :: "r" (pml4) );
-	__sync_synchronize();
-
-	try_or_raise(
-		rs->set_virtual_address_map(
-			map.length, map.size, map.version, map.entries),
-		L"Error setting virtual address map");
-}
-
-
-} // namespace boot
-} // namespace memory

src/boot/memory.h

@@ -1,97 +1,27 @@
-/// \file memory.h
-/// Memory-related constants and functions.
 #pragma once
-#include <uefi/boot_services.h>
-#include <uefi/runtime_services.h>
-#include <stdint.h>
-#include "kernel_args.h"
-#include "pointer_manipulation.h"
+#include <efi/efi.h>
 
-namespace boot {
-namespace memory {
+extern const EFI_MEMORY_TYPE memtype_kernel;
+extern const EFI_MEMORY_TYPE memtype_data;
+extern const EFI_MEMORY_TYPE memtype_initrd;
+extern const EFI_MEMORY_TYPE memtype_scratch;
 
-/// UEFI specifies that pages are always 4 KiB.
-constexpr size_t page_size = 0x1000;
-
-/// Get the number of pages needed to hold `bytes` bytes
-inline constexpr size_t bytes_to_pages(size_t bytes) {
-	return ((bytes - 1) / page_size) + 1;
-}
-
-/// \defgroup memory_types
-/// Custom UEFI memory type values used for data being passed to the kernel
-/// @{
-
-/// Memory containing the kernel args structure
-constexpr uefi::memory_type args_type =
-	static_cast<uefi::memory_type>(0x80000000);
-
-/// Memory containing any loaded modules to be passed to the kernel
-constexpr uefi::memory_type module_type =
-	static_cast<uefi::memory_type>(0x80000001);
-
-/// Memory containing loaded kernel code and data sections
-constexpr uefi::memory_type kernel_type =
-	static_cast<uefi::memory_type>(0x80000002);
-
-/// Memory containing page tables set up by the loader
-constexpr uefi::memory_type table_type =
-	static_cast<uefi::memory_type>(0x80000003);
-
-/// @}
-
-/// \defgroup pointer_fixup
-/// Memory virtualization pointer fixup functions. Handles changing affected pointers
-/// when calling UEFI's `set_virtual_address_map` function to change the location of
-/// runtime services in virtual memory.
-/// @{
-
-/// Set up the pointer fixup UEFI events. This registers the necessary callbacks for
-/// runtime services to call when `set_virtual_address_map` is called.
-void init_pointer_fixup(uefi::boot_services *bs, uefi::runtime_services *rs);
-
-/// Mark a given pointer as needing to be updated when doing pointer fixup.
-void mark_pointer_fixup(void **p);
-
-/// @}
-
-/// Struct that represents UEFI's memory map. Contains a pointer to the map data
-/// as well as the data on how to read it.
-struct efi_mem_map
-{
-	using desc = uefi::memory_descriptor;
-	using iterator = offset_iterator<desc>;
-
-	size_t length;     ///< Total length of the map data
-	size_t size;       ///< Size of an entry in the array
-	size_t key;        ///< Key for detecting changes
-	uint32_t version;  ///< Version of the `memory_descriptor` struct
-	desc *entries;     ///< The array of UEFI descriptors
-
-	efi_mem_map() : length(0), size(0), key(0), version(0), entries(nullptr) {}
-
-	/// Get the count of entries in the array
-	inline size_t num_entries() const { return length / size; }
-
-	/// Return an iterator to the beginning of the array
-	iterator begin() { return iterator(entries, size); }
-
-	/// Return an iterator to the end of the array
-	iterator end() { return offset_ptr<desc>(entries, length); }
+struct memory_map {
+	size_t length;
+	size_t size;
+	size_t key;
+	uint32_t version;
+	EFI_MEMORY_DESCRIPTOR *entries;
 };
 
-/// Add the kernel's memory map as a module to the kernel args.
-/// \returns  The uefi memory map used to build the kernel map
-efi_mem_map build_kernel_mem_map(kernel::args::header *args, uefi::boot_services *bs);
+EFI_STATUS memory_init_pointer_fixup(
+		EFI_BOOT_SERVICES *bootsvc,
+		EFI_RUNTIME_SERVICES *runsvc,
+		unsigned scratch_pages);
+void memory_mark_pointer_fixup(void **p);
 
-/// Activate the given memory mappings. Sets the given page tables live as well
-/// as informs UEFI runtime services of the new mappings.
-/// \arg pml4  The root page table for the new mappings
-/// \arg map   The UEFI memory map, used to update runtime services
-void virtualize(
-	void *pml4,
-	efi_mem_map &map,
-	uefi::runtime_services *rs);
+EFI_STATUS memory_get_map_length(EFI_BOOT_SERVICES *bootsvc, size_t *size);
+EFI_STATUS memory_get_map(EFI_BOOT_SERVICES *bootsvc, struct memory_map *map);
+EFI_STATUS memory_dump_map(struct memory_map *map);
 
-} // namespace boot
-} // namespace memory
+void memory_virtualize(EFI_RUNTIME_SERVICES *runsvc, struct memory_map *map);

src/boot/paging.cpp

@@ -1,234 +0,0 @@
-#include "kernel_memory.h"
-
-#include "console.h"
-#include "error.h"
-#include "loader.h"
-#include "memory.h"
-#include "paging.h"
-#include "pointer_manipulation.h"
-
-namespace boot {
-namespace paging {
-
-using memory::page_size;
-
-// Flags: 0 0 0 1  0 0 0 0  0 0 1 1 = 0x0103
-//         IGN  |  | | | |  | | | +- Present
-//              |  | | | |  | | +--- Writeable
-//              |  | | | |  | +----- Usermode access (supervisor only)
-//              |  | | | |  +------- PWT (determining memory type for page)
-//              |  | | | +---------- PCD (determining memory type for page)
-//              |  | | +------------ Accessed flag (not accessed yet)
-//              |  | +-------------- Dirty (not dirtied yet)
-//              |  +---------------- PAT (determining memory type for page)
-//              +------------------- Global
-/// Page table entry flags for entries pointing at a page
-constexpr uint16_t page_flags = 0x103;
-
-// Flags: 0  0 0 0 1  1 0 0 0  0 0 1 1 = 0x0183
-//        |   IGN  |  | | | |  | | | +- Present
-//        |        |  | | | |  | | +--- Writeable
-//        |        |  | | | |  | +----- Supervisor only
-//        |        |  | | | |  +------- PWT (determining memory type for page)
-//        |        |  | | | +---------- PCD (determining memory type for page)
-//        |        |  | | +------------ Accessed flag (not accessed yet)
-//        |        |  | +-------------- Dirty (not dirtied yet)
-//        |        |  +---------------- Page size (1GiB page)
-//        |        +------------------- Global
-//        +---------------------------- PAT (determining memory type for page)
-/// Page table entry flags for entries pointing at a huge page
-constexpr uint16_t huge_page_flags = 0x183;
-
-// Flags: 0 0 0 0  0 0 0 0  0 0 1 1 = 0x0003
-//        IGNORED  | | | |  | | | +- Present
-//                 | | | |  | | +--- Writeable
-//                 | | | |  | +----- Usermode access (Supervisor only)
-//                 | | | |  +------- PWT (determining memory type for pdpt)
-//                 | | | +---------- PCD (determining memory type for pdpt)
-//                 | | +------------ Accessed flag (not accessed yet)
-//                 | +-------------- Ignored
-//                 +---------------- Reserved 0 (Table pointer, not page)
-/// Page table entry flags for entries pointing at another table
-constexpr uint16_t table_flags = 0x003;
-
-/// Iterator over page table entries.
-template <unsigned D = 4>
-class page_entry_iterator
-{
-public:
-	/// Constructor.
-	/// \arg virt       Virtual address this iterator is starting at
-	/// \arg pml4       Root of the page tables to iterate
-	/// \arg page_cache Pointer to pages that can be used for page tables
-	/// \arg page_count Number of pages pointed to by `page_cache`
-	page_entry_iterator(
-			uintptr_t virt,
-			page_table *pml4,
-			void *&page_cache,
-			uint32_t &cache_count) :
-		m_page_cache(page_cache),
-		m_cache_count(cache_count)
-	{
-		m_table[0] = pml4;
-		for (unsigned i = 0; i < D; ++i) {
-			m_index[i] = static_cast<uint16_t>((virt >> (12 + 9*(3-i))) & 0x1ff);
-			ensure_table(i);
-		}
-	}
-
-	uintptr_t vaddress() const {
-		uintptr_t address = 0;
-		for (unsigned i = 0; i < D; ++i)
-			address |= static_cast<uintptr_t>(m_index[i]) << (12 + 9*(3-i));
-		if (address & (1ull<<47)) // canonicalize the address
-			address |= (0xffffull<<48);
-		return address;
-	}
-
-	void increment()
-	{
-		for (unsigned i = D - 1; i >= 0; --i) {
-			if (++m_index[i] <= 511) {
-				for (unsigned j = i + 1; j < D; ++j)
-					ensure_table(j);
-				return;
-			}
-
-			m_index[i] = 0;
-		}
-	}
-
-	uint64_t & operator*() { return entry(D-1); }
-
-private:
-	inline uint64_t & entry(unsigned level) { return m_table[level]->entries[m_index[level]]; }
-
-	void ensure_table(unsigned level)
-	{
-		// We're only dealing with D levels of paging, and
-		// there must always be a PML4.
-		if (level < 1 || level >= D)
-			return;
-
-		// Entry in the parent that points to the table we want
-		uint64_t & parent_ent = entry(level - 1);
-
-		if (!(parent_ent & 1)) {
-			if (!m_cache_count--)
-				error::raise(uefi::status::out_of_resources, L"Page table cache empty");
-
-			page_table *table = reinterpret_cast<page_table*>(m_page_cache);
-			m_page_cache = offset_ptr<void>(m_page_cache, page_size);
-
-			parent_ent = (reinterpret_cast<uintptr_t>(table) & ~0xfffull) | table_flags;
-			m_table[level] = table;
-		} else {
-			m_table[level] = reinterpret_cast<page_table*>(parent_ent & ~0xfffull);
-		}
-	}
-
-	void *&m_page_cache;
-	uint32_t &m_cache_count;
-	page_table *m_table[D];
-	uint16_t m_index[D];
-};
-
-
-static void
-add_offset_mappings(page_table *pml4, void *&page_cache, uint32_t &num_pages)
-{
-	uintptr_t phys = 0;
-	uintptr_t virt = ::memory::page_offset; // Start of offset-mapped area
-	size_t pages = 64 * 1024; // 64 TiB of 1 GiB pages
-	constexpr size_t GiB = 0x40000000ull;
-
-	page_entry_iterator<2> iterator{
-		virt, pml4,
-		page_cache,
-		num_pages};
-
-	while (true) {
-		*iterator = phys | huge_page_flags;
-		if (--pages == 0)
-			break;
-
-		iterator.increment();
-		phys += GiB;
-	}
-}
-
-void
-add_current_mappings(page_table *new_pml4)
-{
-	// Get the pointer to the current PML4
-	page_table *old_pml4 = 0;
-	asm volatile ( "mov %%cr3, %0" : "=r" (old_pml4) );
-
-	// Only copy mappings in the lower half
-	for (int i = 0; i < ::memory::pml4e_kernel; ++i) {
-		uint64_t entry = old_pml4->entries[i];
-		if (entry & 1)
-			new_pml4->entries[i] = entry;
-	}
-}
-
-void
-allocate_tables(kernel::args::header *args, uefi::boot_services *bs)
-{
-	status_line status(L"Allocating initial page tables");
-
-	static constexpr size_t offset_map_tables = 128 + 1;
-	static constexpr size_t tables_needed = offset_map_tables + 49;
-
-	void *addr = nullptr;
-	try_or_raise(
-		bs->allocate_pages(
-			uefi::allocate_type::any_pages,
-			memory::table_type,
-			tables_needed,
-			&addr),
-		L"Error allocating page table pages.");
-
-	bs->set_mem(addr, tables_needed*page_size, 0);
-
-	kernel::args::module &mod = args->modules[++args->num_modules];
-	mod.type = kernel::args::mod_type::page_tables;
-	mod.location = addr;
-	mod.size = tables_needed*page_size;
-
-	args->pml4 = addr;
-	args->num_free_tables = tables_needed - 1;
-	args->page_table_cache = offset_ptr<void>(addr, page_size);
-
-	page_table *pml4 = reinterpret_cast<page_table*>(addr);
-	add_offset_mappings(pml4, args->page_table_cache, args->num_free_tables);
-
-	console::print(L"    Set up initial mappings, %d spare tables.\r\n", args->num_free_tables);
-}
-
-void
-map_pages(
-	page_table *pml4,
-	kernel::args::header *args,
-	uintptr_t phys, uintptr_t virt,
-	size_t size)
-{
-	size_t pages = memory::bytes_to_pages(size);
-	page_entry_iterator<4> iterator{
-		virt, pml4,
-		args->page_table_cache,
-		args->num_free_tables};
-
-	while (true) {
-		*iterator = phys | page_flags;
-		if (--pages == 0)
-			break;
-
-		iterator.increment();
-		phys += page_size;
-	}
-}
-
-
-} // namespace paging
-} // namespace boot

src/boot/paging.h

@@ -1,54 +0,0 @@
-#pragma once
-/// \file paging.h
-/// Page table structure and related definitions
-#include <stdint.h>
-#include <uefi/boot_services.h>
-#include "kernel_args.h"
-
-namespace boot {
-namespace paging {
-
-/// Struct to allow easy accessing of a memory page being used as a page table.
-struct page_table
-{
-	uint64_t entries[512];
-
-	inline page_table * get(int i, uint16_t *flags = nullptr) const {
-		uint64_t entry = entries[i];
-		if ((entry & 1) == 0) return nullptr;
-		if (flags) *flags = entry & 0xfff;
-		return reinterpret_cast<page_table *>(entry & ~0xfffull);
-	}
-
-	inline void set(int i, void *p, uint16_t flags) {
-		entries[i] = reinterpret_cast<uint64_t>(p) | (flags & 0xfff);
-	}
-};
-
-/// Allocate memory to be used for initial page tables. Initial offset-mapped
-/// page tables are pre-filled. All pages are saved as a module in kernel args
-/// and kernel args' `page_table_cache` and `num_free_tables` are updated with
-/// the leftover space.
-void allocate_tables(
-	kernel::args::header *args,
-	uefi::boot_services *bs);
-
-/// Copy existing page table entries to a new page table. Does not do a deep
-/// copy - the new PML4 is updated to point to the existing next-level page
-/// tables in the current PML4.
-void add_current_mappings(page_table *new_pml4);
-
-/// Map a physical address to a virtual address in the given page tables.
-/// \arg pml4  The root of the set of page tables to be updated
-/// \arg args  The kernel args header, used for the page table cache
-/// \arg phys  The phyiscal address to map in
-/// \arg virt  The virtual address to map in
-/// \arg size  The size in bytes of the mapping 
-void map_pages(
-	page_table *pml4,
-	kernel::args::header *args,
-	uintptr_t phys, uintptr_t virt,
-	size_t bytes);
-
-} // namespace paging
-} // namespace boot

src/boot/pointer_manipulation.h

@@ -1,41 +0,0 @@
-/// \file pointer_manipulation.h
-/// Helper functions and types for doing type-safe byte-wise pointer math.
-#pragma once
-
-namespace boot {
-
-/// Return a pointer offset from `input` by `offset` bytes.
-/// \tparam T  Cast the return value to a pointer to `T`
-/// \tparam S  The type pointed to by the `input` pointer
-template <typename T, typename S>
-inline T* offset_ptr(S* input, ptrdiff_t offset) {
-	return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(input) + offset);
-}
-
-/// Iterator for an array of `T` whose size is known at runtime
-/// \tparam T  Type of the objects in the array, whose size might not be
-///            what is returned by sizeof(T).
-template <typename T>
-class offset_iterator
-{
-public:
-	/// Constructor.
-	/// \arg t    Pointer to the first item in the array
-	/// \arg off  Offset applied to reach successive items. Default is 0,
-	///           which creates an effectively constant iterator.
-	offset_iterator(T* t, size_t off=0) : m_t(t), m_off(off) {}
-
-	T* operator++() { m_t = offset_ptr<T>(m_t, m_off); return m_t; }
-	T* operator++(int) { T* tmp = m_t; operator++(); return tmp; }
-	bool operator==(T* p) { return p == m_t; }
-
-	T* operator*() const { return m_t; }
-	operator T*() const { return m_t; }
-	T* operator->() const { return m_t; }
-
-private:
-	T* m_t;
-	size_t m_off;
-};
-
-} // namespace boot

src/boot/reloc.cpp

@@ -0,0 +1,97 @@
+/* reloc_x86_64.c - position independent x86_64 ELF shared object relocator
+   Copyright (C) 1999 Hewlett-Packard Co.
+	Contributed by David Mosberger <davidm@hpl.hp.com>.
+   Copyright (C) 2005 Intel Co.
+	Contributed by Fenghua Yu <fenghua.yu@intel.com>.
+
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials
+      provided with the distribution.
+    * Neither the name of Hewlett-Packard Co. nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+    CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+    BE LIABLE FOR ANYDIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+    OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+    SUCH DAMAGE.
+*/
+
+#include <efi/efi.h>
+#include <elf.h>
+
+extern "C"
+EFI_STATUS _relocate (long ldbase, Elf64_Dyn *dyn,
+		      EFI_HANDLE image EFI_UNUSED,
+		      EFI_SYSTEM_TABLE *systab EFI_UNUSED)
+{
+	long relsz = 0, relent = 0;
+	Elf64_Rel *rel = 0;
+	unsigned long *addr;
+	int i;
+
+	for (i = 0; dyn[i].d_tag != DT_NULL; ++i) {
+		switch (dyn[i].d_tag) {
+			case DT_RELA:
+				rel = (Elf64_Rel*)
+					((unsigned long)dyn[i].d_un.d_ptr
+					 + ldbase);
+				break;
+
+			case DT_RELASZ:
+				relsz = dyn[i].d_un.d_val;
+				break;
+
+			case DT_RELAENT:
+				relent = dyn[i].d_un.d_val;
+				break;
+
+			default:
+				break;
+		}
+	}
+
+        if (!rel && relent == 0)
+                return EFI_SUCCESS;
+
+	if (!rel || relent == 0)
+		return EFI_LOAD_ERROR;
+
+	while (relsz > 0) {
+		/* apply the relocs */
+		switch (ELF64_R_TYPE (rel->r_info)) {
+			case R_X86_64_NONE:
+				break;
+
+			case R_X86_64_RELATIVE:
+				addr = (unsigned long *)
+					(ldbase + rel->r_offset);
+				*addr += ldbase;
+				break;
+
+			default:
+				break;
+		}
+		rel = (Elf64_Rel*) ((char *) rel + relent);
+		relsz -= relent;
+	}
+	return EFI_SUCCESS;
+}

src/boot/support.cpp

@@ -1,39 +0,0 @@
-#include <stdint.h>
-
-#include "error.h"
-
-extern "C" {
-
-/// Basic memcpy() implementation for clang. Clang requires freestanding code
-/// implement memcpy(), as it may emit references to it. This basic memcpy is
-/// not the most efficient, but will get linked if no other memcpy exists.
-__attribute__ ((__weak__))
-void *memcpy(void *dest, const void *src, size_t n)
-{
-	uint8_t *cdest = reinterpret_cast<uint8_t*>(dest);
-	const uint8_t *csrc = reinterpret_cast<const uint8_t*>(src);
-	for (size_t i = 0; i < n; ++i)
-		cdest[i] = csrc[i];
-	return dest;
-}
-
-/// Basic memset() implementation for clang. Clang requires freestanding code
-/// implement memset(), as it may emit references to it. This basic memset is
-/// not the most efficient, but will get linked if no other memcpy exists.
-__attribute__ ((__weak__))
-void *memset(void *dest, int c, size_t n)
-{
-	uint8_t *cdest = reinterpret_cast<uint8_t*>(dest);
-	for (size_t i = 0; i < n; ++i)
-		cdest[i] = static_cast<uint8_t>(c);
-	return dest;
-}
-
-int _purecall()
-{
-	::boot::error::raise(uefi::status::unsupported, L"Pure virtual call");
-}
-
-} // extern "C"
-
-void operator delete (void *) {}

src/boot/utility.cpp

@@ -0,0 +1,71 @@
+#include "utility.h"
+
+struct error_code_desc {
+	EFI_STATUS code;
+	const wchar_t *name;
+};
+
+// Based off the gnu-efi table
+struct error_code_desc error_table[] = {
+	{ EFI_SUCCESS,               L"Success" },
+	{ EFI_LOAD_ERROR,            L"Load Error" },
+	{ EFI_INVALID_PARAMETER,     L"Invalid Parameter" },
+	{ EFI_UNSUPPORTED,           L"Unsupported" },
+	{ EFI_BAD_BUFFER_SIZE,       L"Bad Buffer Size" },
+	{ EFI_BUFFER_TOO_SMALL,      L"Buffer Too Small" },
+	{ EFI_NOT_READY,             L"Not Ready" },
+	{ EFI_DEVICE_ERROR,          L"Device Error" },
+	{ EFI_WRITE_PROTECTED,       L"Write Protected" },
+	{ EFI_OUT_OF_RESOURCES,      L"Out of Resources" },
+	{ EFI_VOLUME_CORRUPTED,      L"Volume Corrupt" },
+	{ EFI_VOLUME_FULL,           L"Volume Full" },
+	{ EFI_NO_MEDIA,              L"No Media" },
+	{ EFI_MEDIA_CHANGED,         L"Media changed" },
+	{ EFI_NOT_FOUND,             L"Not Found" },
+	{ EFI_ACCESS_DENIED,         L"Access Denied" },
+	{ EFI_NO_RESPONSE,           L"No Response" },
+	{ EFI_NO_MAPPING,            L"No mapping" },
+	{ EFI_TIMEOUT,               L"Time out" },
+	{ EFI_NOT_STARTED,           L"Not started" },
+	{ EFI_ALREADY_STARTED,       L"Already started" },
+	{ EFI_ABORTED,               L"Aborted" },
+	{ EFI_ICMP_ERROR,            L"ICMP Error" },
+	{ EFI_TFTP_ERROR,            L"TFTP Error" },
+	{ EFI_PROTOCOL_ERROR,        L"Protocol Error" },
+	{ EFI_INCOMPATIBLE_VERSION,  L"Incompatible Version" },
+	{ EFI_SECURITY_VIOLATION,    L"Security Policy Violation" },
+	{ EFI_CRC_ERROR,             L"CRC Error" },
+	{ EFI_END_OF_MEDIA,          L"End of Media" },
+	{ EFI_END_OF_FILE,           L"End of File" },
+	{ EFI_INVALID_LANGUAGE,      L"Invalid Languages" },
+	{ EFI_COMPROMISED_DATA,      L"Compromised Data" },
+
+	{ EFI_WARN_UNKOWN_GLYPH,     L"Warning Unknown Glyph" },
+	{ EFI_WARN_DELETE_FAILURE,   L"Warning Delete Failure" },
+	{ EFI_WARN_WRITE_FAILURE,    L"Warning Write Failure" },
+	{ EFI_WARN_BUFFER_TOO_SMALL, L"Warning Buffer Too Small" },
+	{ 0, NULL }
+};
+
+const wchar_t *
+util_error_message(EFI_STATUS status)
+{
+	int32_t i = -1;
+	while (error_table[++i].name != NULL) {
+		if (error_table[i].code == status) return error_table[i].name;
+	}
+
+	if (EFI_ERROR(status))
+		return L"Unknown Error";
+	else
+		return L"Unknown Warning";
+}
+
+size_t
+wstrlen(const wchar_t *s)
+{
+	size_t count = 0;
+	while (s && *s++) count++;
+	return count;
+}
+

src/boot/utility.h

@@ -0,0 +1,40 @@
+#include <stddef.h>
+#include <efi/efi.h>
+
+#include "console.h"
+
+#define UNUSED __attribute__((unused))
+
+size_t wstrlen(const wchar_t *s);
+const wchar_t *util_error_message(EFI_STATUS status);
+
+#define CHECK_EFI_STATUS_OR_RETURN(s, msg, ...) \
+	if (EFI_ERROR((s))) { \
+		console::print(L"ERROR: " msg L": %s\r\n", ##__VA_ARGS__, util_error_message(s)); \
+		return (s); \
+	}
+
+#define CHECK_EFI_STATUS_OR_FAIL(s) \
+	if (EFI_ERROR((s))) { \
+		console::get().status_fail(util_error_message(s)); \
+		while (1) __asm__("hlt"); \
+	}
+
+#define CHECK_EFI_STATUS_OR_ASSERT(s, d) \
+	if (EFI_ERROR((s))) { \
+		__asm__ __volatile__( \
+			"movq %0, %%r8;" \
+			"movq %1, %%r9;" \
+			"movq %2, %%r10;" \
+			"movq $0, %%rdx;" \
+			"divq %%rdx;" \
+			: \
+			: "r"((uint64_t)s), "r"((uint64_t)d), "r"((uint64_t)__LINE__) \
+			: "rax", "rdx", "r8", "r9", "r10"); \
+	}
+
+#ifdef BOOTLOADER_DEBUG
+#define con_debug(msg, ...) console::print(L"DEBUG: " msg L"\r\n", __VA_ARGS__)
+#else
+#define con_debug(msg, ...)
+#endif

src/include/efi/efi.h

@@ -0,0 +1,62 @@
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efi.h
+
+Abstract:
+
+    Public EFI header files
+
+
+
+Revision History
+
+--*/
+
+
+// Add a predefined macro to detect usage of the library
+#ifndef _GNU_EFI
+#define _GNU_EFI
+#endif
+
+//
+// Build flags on input
+//  EFI32
+//  EFI_DEBUG               - Enable debugging code
+//  EFI_NT_EMULATOR         - Building for running under NT
+//
+
+
+#ifndef _EFI_INCLUDE_
+#define _EFI_INCLUDE_
+
+#define EFI_FIRMWARE_VENDOR         L"INTEL"
+#define EFI_FIRMWARE_MAJOR_REVISION 12
+#define EFI_FIRMWARE_MINOR_REVISION 33
+#define EFI_FIRMWARE_REVISION ((EFI_FIRMWARE_MAJOR_REVISION <<16) | (EFI_FIRMWARE_MINOR_REVISION))
+
+#include <efi/efibind.h>
+#include <efi/eficompiler.h>
+#include <efi/efidef.h>
+#include <efi/efidevp.h>
+#include <efi/efipciio.h>
+#include <efi/efiprot.h>
+#include <efi/eficon.h>
+#include <efi/efiser.h>
+#include <efi/efi_nii.h>
+#include <efi/efipxebc.h>
+#include <efi/efinet.h>
+#include <efi/efiapi.h>
+#include <efi/efifs.h>
+#include <efi/efierr.h>
+#include <efi/efiui.h>
+#include <efi/efiip.h>
+#include <efi/efiudp.h>
+#include <efi/efitcp.h>
+#include <efi/efipoint.h>
+#include <efi/efisetjmp.h>
+
+#endif

src/include/efi/efi_nii.h

@@ -0,0 +1,78 @@
+#ifndef _EFI_NII_H
+#define _EFI_NII_H
+
+/*++
+Copyright (c) 2000  Intel Corporation
+
+Module name:
+    efi_nii.h
+
+Abstract:
+
+Revision history:
+    2000-Feb-18 M(f)J   GUID updated.
+                Structure order changed for machine word alignment.
+                Added StringId[4] to structure.
+
+    2000-Feb-14 M(f)J   Genesis.
+--*/
+
+#define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID \
+    { 0xE18541CD, 0xF755, 0x4f73, {0x92, 0x8D, 0x64, 0x3C, 0x8A, 0x79, 0xB2, 0x29} }
+
+#define EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION  0x00010000
+#define EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE_REVISION EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_REVISION
+
+typedef enum {
+    EfiNetworkInterfaceUndi = 1
+} EFI_NETWORK_INTERFACE_TYPE;
+
+typedef struct _EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL {
+
+    UINT64 Revision;
+    // Revision of the network interface identifier protocol interface.
+
+    UINT64 ID;
+    // Address of the first byte of the identifying structure for this
+    // network interface.  This is set to zero if there is no structure.
+    //
+    // For PXE/UNDI this is the first byte of the !PXE structure.
+
+    UINT64 ImageAddr;
+    // Address of the UNrelocated driver/ROM image.  This is set
+    // to zero if there is no driver/ROM image.
+    //
+    // For 16-bit UNDI, this is the first byte of the option ROM in
+    // upper memory.
+    //
+    // For 32/64-bit S/W UNDI, this is the first byte of the EFI ROM
+    // image.
+    //
+    // For H/W UNDI, this is set to zero.
+
+    UINT32 ImageSize;
+    // Size of the UNrelocated driver/ROM image of this network interface.
+    // This is set to zero if there is no driver/ROM image.
+
+    CHAR8 StringId[4];
+    // 4 char ASCII string to go in class identifier (option 60) in DHCP
+    // and Boot Server discover packets.
+    // For EfiNetworkInterfaceUndi this field is "UNDI".
+    // For EfiNetworkInterfaceSnp this field is "SNPN".
+
+    UINT8 Type;
+    UINT8 MajorVer;
+    UINT8 MinorVer;
+    // Information to be placed into the PXE DHCP and Discover packets.
+    // This is the network interface type and version number that will
+    // be placed into DHCP option 94 (client network interface identifier).
+    BOOLEAN Ipv6Supported;
+    UINT8   IfNum;	// interface number to be used with pxeid structure
+} EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL, EFI_NETWORK_INTERFACE_IDENTIFIER_INTERFACE;
+
+// Note: Because it conflicted with the EDK2 struct name, the
+// 'EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL' GUID definition,
+// from older versions of gnu-efi, is now obsoleted.
+// Use 'EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID' instead.
+
+#endif // _EFI_NII_H

src/include/efi/efiapi.h

@@ -0,0 +1,967 @@
+#ifndef _EFI_API_H
+#define _EFI_API_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efiapi.h
+
+Abstract:
+
+    Global EFI runtime & boot service interfaces
+
+
+
+
+Revision History
+
+--*/
+
+//
+// EFI Specification Revision
+//
+
+#define EFI_SPECIFICATION_MAJOR_REVISION 1
+#define EFI_SPECIFICATION_MINOR_REVISION 02
+
+//
+// Declare forward referenced data structures
+//
+
+INTERFACE_DECL(_EFI_SYSTEM_TABLE);
+
+//
+// EFI Memory
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ALLOCATE_PAGES) (
+    IN EFI_ALLOCATE_TYPE            Type,
+    IN EFI_MEMORY_TYPE              MemoryType,
+    IN UINTN                        NoPages,
+    OUT EFI_PHYSICAL_ADDRESS        *Memory
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FREE_PAGES) (
+    IN EFI_PHYSICAL_ADDRESS         Memory,
+    IN UINTN                        NoPages
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_MEMORY_MAP) (
+    IN OUT UINTN                    *MemoryMapSize,
+    IN OUT EFI_MEMORY_DESCRIPTOR    *MemoryMap,
+    OUT UINTN                       *MapKey,
+    OUT UINTN                       *DescriptorSize,
+    OUT UINT32                      *DescriptorVersion
+    );
+
+#define NextMemoryDescriptor(Ptr,Size)  ((EFI_MEMORY_DESCRIPTOR *) (((UINT8 *) Ptr) + Size))
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ALLOCATE_POOL) (
+    IN EFI_MEMORY_TYPE              PoolType,
+    IN UINTN                        Size,
+    OUT VOID                        **Buffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_FREE_POOL) (
+    IN VOID                         *Buffer
+    );
+
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_SET_VIRTUAL_ADDRESS_MAP) (
+    IN UINTN                        MemoryMapSize,
+    IN UINTN                        DescriptorSize,
+    IN UINT32                       DescriptorVersion,
+    IN EFI_MEMORY_DESCRIPTOR        *VirtualMap
+    );
+
+
+#define EFI_OPTIONAL_PTR            0x00000001
+#define EFI_INTERNAL_FNC            0x00000002      // Pointer to internal runtime fnc
+#define EFI_INTERNAL_PTR            0x00000004      // Pointer to internal runtime data
+
+
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_CONVERT_POINTER) (
+    IN UINTN                        DebugDisposition,
+    IN OUT VOID                     **Address
+    );
+
+
+//
+// EFI Events
+//
+
+#define EVT_TIMER                           0x80000000
+#define EVT_RUNTIME                         0x40000000
+#define EVT_RUNTIME_CONTEXT                 0x20000000
+
+#define EVT_NOTIFY_WAIT                     0x00000100
+#define EVT_NOTIFY_SIGNAL                   0x00000200
+
+#define EVT_SIGNAL_EXIT_BOOT_SERVICES       0x00000201
+#define EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE   0x60000202
+
+#define EVT_EFI_SIGNAL_MASK                 0x000000FF
+#define EVT_EFI_SIGNAL_MAX                  4
+
+#define EFI_EVENT_TIMER                         EVT_TIMER
+#define EFI_EVENT_RUNTIME                       EVT_RUNTIME
+#define EFI_EVENT_RUNTIME_CONTEXT               EVT_RUNTIME_CONTEXT
+#define EFI_EVENT_NOTIFY_WAIT                   EVT_NOTIFY_WAIT
+#define EFI_EVENT_NOTIFY_SIGNAL                 EVT_NOTIFY_SIGNAL
+#define EFI_EVENT_SIGNAL_EXIT_BOOT_SERVICES     EVT_SIGNAL_EXIT_BOOT_SERVICES
+#define EFI_EVENT_SIGNAL_VIRTUAL_ADDRESS_CHANGE EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE
+#define EFI_EVENT_EFI_SIGNAL_MASK               EVT_EFI_SIGNAL_MASK
+#define EFI_EVENT_EFI_SIGNAL_MAX                EVT_EFI_SIGNAL_MAX
+
+
+typedef
+VOID
+(EFIAPI *EFI_EVENT_NOTIFY) (
+    IN EFI_EVENT                Event,
+    IN VOID                     *Context
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREATE_EVENT) (
+    IN UINT32                       Type,
+    IN EFI_TPL                      NotifyTpl,
+    IN EFI_EVENT_NOTIFY             NotifyFunction,
+    IN VOID                         *NotifyContext,
+    OUT EFI_EVENT                   *Event
+    );
+
+typedef enum {
+    TimerCancel,
+    TimerPeriodic,
+    TimerRelative,
+    TimerTypeMax
+} EFI_TIMER_DELAY;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_TIMER) (
+    IN EFI_EVENT                Event,
+    IN EFI_TIMER_DELAY          Type,
+    IN UINT64                   TriggerTime
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIGNAL_EVENT) (
+    IN EFI_EVENT                Event
+    );
+
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_WAIT_FOR_EVENT) (
+    IN UINTN                    NumberOfEvents,
+    IN EFI_EVENT                *Event,
+    OUT UINTN                   *Index
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CLOSE_EVENT) (
+    IN EFI_EVENT                Event
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CHECK_EVENT) (
+    IN EFI_EVENT                Event
+    );
+
+//
+// Task priority level
+//
+
+#define TPL_APPLICATION       4
+#define TPL_CALLBACK          8
+#define TPL_NOTIFY           16
+#define TPL_HIGH_LEVEL       31
+#define EFI_TPL_APPLICATION  TPL_APPLICATION
+#define EFI_TPL_CALLBACK     TPL_CALLBACK
+#define EFI_TPL_NOTIFY       TPL_NOTIFY
+#define EFI_TPL_HIGH_LEVEL   TPL_HIGH_LEVEL
+typedef
+EFI_TPL
+(EFIAPI *EFI_RAISE_TPL) (
+    IN EFI_TPL      NewTpl
+    );
+
+typedef
+VOID
+(EFIAPI *EFI_RESTORE_TPL) (
+    IN EFI_TPL      OldTpl
+    );
+
+
+//
+// EFI platform varibles
+//
+
+#define EFI_GLOBAL_VARIABLE     \
+    { 0x8BE4DF61, 0x93CA, 0x11d2, {0xAA, 0x0D, 0x00, 0xE0, 0x98, 0x03, 0x2B, 0x8C} }
+
+// Variable attributes
+#define EFI_VARIABLE_NON_VOLATILE                          0x00000001
+#define EFI_VARIABLE_BOOTSERVICE_ACCESS                    0x00000002
+#define EFI_VARIABLE_RUNTIME_ACCESS                        0x00000004
+#define EFI_VARIABLE_HARDWARE_ERROR_RECORD                 0x00000008
+#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS            0x00000010
+#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x00000020
+#define EFI_VARIABLE_APPEND_WRITE                          0x00000040
+
+// Variable size limitation
+#define EFI_MAXIMUM_VARIABLE_SIZE           1024
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_VARIABLE) (
+    IN CHAR16                       *VariableName,
+    IN EFI_GUID                     *VendorGuid,
+    OUT UINT32                      *Attributes OPTIONAL,
+    IN OUT UINTN                    *DataSize,
+    OUT VOID                        *Data
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_NEXT_VARIABLE_NAME) (
+    IN OUT UINTN                    *VariableNameSize,
+    IN OUT CHAR16                   *VariableName,
+    IN OUT EFI_GUID                 *VendorGuid
+    );
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_VARIABLE) (
+    IN CHAR16                       *VariableName,
+    IN EFI_GUID                     *VendorGuid,
+    IN UINT32                       Attributes,
+    IN UINTN                        DataSize,
+    IN VOID                         *Data
+    );
+
+
+//
+// EFI Time
+//
+
+typedef struct {
+        UINT32                      Resolution;     // 1e-6 parts per million
+        UINT32                      Accuracy;       // hertz
+        BOOLEAN                     SetsToZero;     // Set clears sub-second time
+} EFI_TIME_CAPABILITIES;
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_TIME) (
+    OUT EFI_TIME                    *Time,
+    OUT EFI_TIME_CAPABILITIES       *Capabilities OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_TIME) (
+    IN EFI_TIME                     *Time
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_WAKEUP_TIME) (
+    OUT BOOLEAN                     *Enabled,
+    OUT BOOLEAN                     *Pending,
+    OUT EFI_TIME                    *Time
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_WAKEUP_TIME) (
+    IN BOOLEAN                      Enable,
+    IN EFI_TIME                     *Time OPTIONAL
+    );
+
+
+//
+// Image functions
+//
+
+
+// PE32+ Subsystem type for EFI images
+
+#if !defined(IMAGE_SUBSYSTEM_EFI_APPLICATION)
+#define IMAGE_SUBSYSTEM_EFI_APPLICATION             10
+#define IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER     11
+#define IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER          12
+#endif
+
+// PE32+ Machine type for EFI images
+
+#if !defined(EFI_IMAGE_MACHINE_IA32)
+#define EFI_IMAGE_MACHINE_IA32      0x014c
+#endif
+
+#if !defined(EFI_IMAGE_MACHINE_IA64)
+#define EFI_IMAGE_MACHINE_IA64      0x0200
+#endif
+
+#if !defined(EFI_IMAGE_MACHINE_EBC)
+#define EFI_IMAGE_MACHINE_EBC      0x0EBC
+#endif
+
+#if !defined(EFI_IMAGE_MACHINE_X64)
+#define EFI_IMAGE_MACHINE_X64       0x8664
+#endif
+
+#if !defined(EFI_IMAGE_MACHINE_ARMTHUMB_MIXED)
+#define EFI_IMAGE_MACHINE_ARMTHUMB_MIXED 0x01C2
+#endif
+
+#if !defined(EFI_IMAGE_MACHINE_AARCH64)
+#define EFI_IMAGE_MACHINE_AARCH64   0xAA64
+#endif
+
+// Image Entry prototype
+
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IMAGE_ENTRY_POINT) (
+    IN EFI_HANDLE                   ImageHandle,
+    IN struct _EFI_SYSTEM_TABLE     *SystemTable
+    );
+
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IMAGE_LOAD) (
+    IN BOOLEAN                      BootPolicy,
+    IN EFI_HANDLE                   ParentImageHandle,
+    IN EFI_DEVICE_PATH              *FilePath,
+    IN VOID                         *SourceBuffer   OPTIONAL,
+    IN UINTN                        SourceSize,
+    OUT EFI_HANDLE                  *ImageHandle
+    );
+
+typedef 
+EFI_STATUS
+(EFIAPI *EFI_IMAGE_START) (
+    IN EFI_HANDLE                   ImageHandle,
+    OUT UINTN                       *ExitDataSize,
+    OUT CHAR16                      **ExitData  OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXIT) (
+    IN EFI_HANDLE                   ImageHandle,
+    IN EFI_STATUS                   ExitStatus,
+    IN UINTN                        ExitDataSize,
+    IN CHAR16                       *ExitData OPTIONAL
+    );
+
+
+// Image handle
+/*#define LOADED_IMAGE_PROTOCOL      \
+    { 0x5B1B31A1, 0x9562, 0x11d2, {0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B} }
+
+#define EFI_IMAGE_INFORMATION_REVISION      0x1000
+typedef struct {
+    UINT32                          Revision;
+    EFI_HANDLE                      ParentHandle;
+    struct _EFI_SYSTEM_TABLE        *SystemTable;
+
+    // Source location of image
+    EFI_HANDLE                      DeviceHandle;
+    EFI_DEVICE_PATH                 *FilePath;
+    VOID                            *Reserved;
+
+    // Images load options
+    UINT32                          LoadOptionsSize;
+    VOID                            *LoadOptions;
+
+    // Location of where image was loaded
+    VOID                            *ImageBase;
+    UINT64                          ImageSize;
+    EFI_MEMORY_TYPE                 ImageCodeType;
+    EFI_MEMORY_TYPE                 ImageDataType;
+
+    // If the driver image supports a dynamic unload request
+    EFI_IMAGE_UNLOAD                Unload;
+
+} EFI_LOADED_IMAGE;*/
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_EXIT_BOOT_SERVICES) (
+    IN EFI_HANDLE                   ImageHandle,
+    IN UINTN                        MapKey
+    );
+
+//
+// Misc
+//
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STALL) (
+    IN UINTN                    Microseconds
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SET_WATCHDOG_TIMER) (
+    IN UINTN                    Timeout,
+    IN UINT64                   WatchdogCode,
+    IN UINTN                    DataSize,
+    IN CHAR16                   *WatchdogData OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CONNECT_CONTROLLER) (
+    IN EFI_HANDLE               ControllerHandle,
+    IN EFI_HANDLE               *DriverImageHandle OPTIONAL,
+    IN EFI_DEVICE_PATH          *RemainingDevicePath OPTIONAL,
+    IN BOOLEAN                  Recursive
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DISCONNECT_CONTROLLER) (
+    IN EFI_HANDLE               ControllerHandle,
+    IN EFI_HANDLE               DriverImageHandle OPTIONAL,
+    IN EFI_HANDLE               ChildHandle OPTIONAL
+    );
+
+#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL  0x00000001
+#define EFI_OPEN_PROTOCOL_GET_PROTOCOL        0x00000002
+#define EFI_OPEN_PROTOCOL_TEST_PROTOCOL       0x00000004
+#define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008
+#define EFI_OPEN_PROTOCOL_BY_DRIVER           0x00000010
+#define EFI_OPEN_PROTOCOL_EXCLUSIVE           0x00000020
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_OPEN_PROTOCOL) (
+    IN EFI_HANDLE               Handle,
+    IN EFI_GUID                 *Protocol,
+    OUT VOID                    **Interface OPTIONAL,
+    IN EFI_HANDLE               AgentHandle,
+    IN EFI_HANDLE               ControllerHandle,
+    IN UINT32                   Attributes
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CLOSE_PROTOCOL) (
+    IN EFI_HANDLE               Handle,
+    IN EFI_GUID                 *Protocol,
+    IN EFI_HANDLE               AgentHandle,
+    IN EFI_HANDLE               ControllerHandle
+    );
+
+typedef struct {
+    EFI_HANDLE                  AgentHandle;
+    EFI_HANDLE                  ControllerHandle;
+    UINT32                      Attributes;
+    UINT32                      OpenCount;
+} EFI_OPEN_PROTOCOL_INFORMATION_ENTRY;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_OPEN_PROTOCOL_INFORMATION) (
+    IN EFI_HANDLE               Handle,
+    IN EFI_GUID                 *Protocol,
+    OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer,
+    OUT UINTN                   *EntryCount
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PROTOCOLS_PER_HANDLE) (
+    IN EFI_HANDLE               Handle,
+    OUT EFI_GUID                ***ProtocolBuffer,
+    OUT UINTN                   *ProtocolBufferCount
+    );
+
+typedef enum {
+    AllHandles,
+    ByRegisterNotify,
+    ByProtocol
+} EFI_LOCATE_SEARCH_TYPE;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_HANDLE_BUFFER) (
+    IN EFI_LOCATE_SEARCH_TYPE   SearchType,
+    IN EFI_GUID                 *Protocol OPTIONAL,
+    IN VOID                     *SearchKey OPTIONAL,
+    IN OUT UINTN                *NoHandles,
+    OUT EFI_HANDLE              **Buffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_PROTOCOL) (
+    IN EFI_GUID                 *Protocol,
+    IN VOID                     *Registration OPTIONAL,
+    OUT VOID                    **Interface
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES) (
+    IN OUT EFI_HANDLE           *Handle,
+    ...
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES) (
+    IN OUT EFI_HANDLE           Handle,
+    ...
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CALCULATE_CRC32) (
+    IN VOID                     *Data,
+    IN UINTN                    DataSize,
+    OUT UINT32                  *Crc32
+    );
+
+typedef
+VOID
+(EFIAPI *EFI_COPY_MEM) (
+    IN VOID                     *Destination,
+    IN VOID                     *Source,
+    IN UINTN                    Length
+    );
+
+typedef
+VOID
+(EFIAPI *EFI_SET_MEM) (
+    IN VOID                     *Buffer,
+    IN UINTN                    Size,
+    IN UINT8                    Value
+    );
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_CREATE_EVENT_EX) (
+    IN UINT32                   Type,
+    IN EFI_TPL                  NotifyTpl,
+    IN EFI_EVENT_NOTIFY         NotifyFunction OPTIONAL,
+    IN const VOID               *NotifyContext OPTIONAL,
+    IN const EFI_GUID           EventGroup OPTIONAL,
+    OUT EFI_EVENT               *Event
+    );
+
+typedef enum {
+    EfiResetCold,
+    EfiResetWarm,
+    EfiResetShutdown
+} EFI_RESET_TYPE;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RESET_SYSTEM) (
+    IN EFI_RESET_TYPE           ResetType,
+    IN EFI_STATUS               ResetStatus,
+    IN UINTN                    DataSize,
+    IN CHAR16                   *ResetData OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_NEXT_MONOTONIC_COUNT) (
+    OUT UINT64                  *Count
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_NEXT_HIGH_MONO_COUNT) (
+    OUT UINT32                  *HighCount
+    );
+
+typedef struct {
+    UINT64                      Length;
+    union {
+        EFI_PHYSICAL_ADDRESS    DataBlock;
+       EFI_PHYSICAL_ADDRESS    ContinuationPointer;
+    } Union;
+} EFI_CAPSULE_BLOCK_DESCRIPTOR;
+
+typedef struct {
+    EFI_GUID                    CapsuleGuid;
+    UINT32                      HeaderSize;
+    UINT32                      Flags;
+    UINT32                      CapsuleImageSize;
+} EFI_CAPSULE_HEADER;
+
+#define CAPSULE_FLAGS_PERSIST_ACROSS_RESET    0x00010000
+#define CAPSULE_FLAGS_POPULATE_SYSTEM_TABLE   0x00020000
+#define CAPSULE_FLAGS_INITIATE_RESET          0x00040000
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UPDATE_CAPSULE) (
+    IN EFI_CAPSULE_HEADER       **CapsuleHeaderArray,
+    IN UINTN                    CapsuleCount,
+    IN EFI_PHYSICAL_ADDRESS     ScatterGatherList OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_QUERY_CAPSULE_CAPABILITIES) (
+    IN  EFI_CAPSULE_HEADER       **CapsuleHeaderArray,
+    IN  UINTN                    CapsuleCount,
+    OUT UINT64                   *MaximumCapsuleSize,
+    OUT EFI_RESET_TYPE           *ResetType
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_QUERY_VARIABLE_INFO) (
+    IN  UINT32                  Attributes,
+    OUT UINT64                  *MaximumVariableStorageSize,
+    OUT UINT64                  *RemainingVariableStorageSize,
+    OUT UINT64                  *MaximumVariableSize
+    );
+
+//
+// Protocol handler functions
+//
+
+typedef enum {
+    EFI_NATIVE_INTERFACE,
+    EFI_PCODE_INTERFACE
+} EFI_INTERFACE_TYPE;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INSTALL_PROTOCOL_INTERFACE) (
+    IN OUT EFI_HANDLE           *Handle,
+    IN EFI_GUID                 *Protocol,
+    IN EFI_INTERFACE_TYPE       InterfaceType,
+    IN VOID                     *Interface
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REINSTALL_PROTOCOL_INTERFACE) (
+    IN EFI_HANDLE               Handle,
+    IN EFI_GUID                 *Protocol,
+    IN VOID                     *OldInterface,
+    IN VOID                     *NewInterface
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UNINSTALL_PROTOCOL_INTERFACE) (
+    IN EFI_HANDLE               Handle,
+    IN EFI_GUID                 *Protocol,
+    IN VOID                     *Interface
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_HANDLE_PROTOCOL) (
+    IN EFI_HANDLE               Handle,
+    IN EFI_GUID                 *Protocol,
+    OUT VOID                    **Interface
+    );
+
+typedef
+EFI_STATUS 
+(EFIAPI *EFI_REGISTER_PROTOCOL_NOTIFY) (
+    IN EFI_GUID                 *Protocol,
+    IN EFI_EVENT                Event,
+    OUT VOID                    **Registration
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_HANDLE) (
+    IN EFI_LOCATE_SEARCH_TYPE   SearchType,
+    IN EFI_GUID                 *Protocol OPTIONAL,
+    IN VOID                     *SearchKey OPTIONAL,
+    IN OUT UINTN                *BufferSize,
+    OUT EFI_HANDLE              *Buffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_LOCATE_DEVICE_PATH) (
+    IN EFI_GUID                 *Protocol,
+    IN OUT EFI_DEVICE_PATH      **DevicePath,
+    OUT EFI_HANDLE              *Device
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INSTALL_CONFIGURATION_TABLE) (
+    IN EFI_GUID                 *Guid,
+    IN VOID                     *Table
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_RESERVED_SERVICE) (
+    );
+
+//
+// Standard EFI table header
+//
+
+typedef struct _EFI_TABLE_HEADER {
+    UINT64                      Signature;
+    UINT32                      Revision;
+    UINT32                      HeaderSize;
+    UINT32                      CRC32;
+    UINT32                      Reserved;
+} EFI_TABLE_HEADER;
+
+
+//
+// EFI Runtime Serivces Table
+//
+
+#define EFI_RUNTIME_SERVICES_SIGNATURE  0x56524553544e5552
+#define EFI_RUNTIME_SERVICES_REVISION   (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION)
+
+typedef struct  {
+    EFI_TABLE_HEADER                Hdr;
+
+    //
+    // Time services
+    //
+
+    EFI_GET_TIME                    GetTime;
+    EFI_SET_TIME                    SetTime;
+    EFI_GET_WAKEUP_TIME             GetWakeupTime;
+    EFI_SET_WAKEUP_TIME             SetWakeupTime;
+
+    //
+    // Virtual memory services
+    //
+
+    EFI_SET_VIRTUAL_ADDRESS_MAP     SetVirtualAddressMap;
+    EFI_CONVERT_POINTER             ConvertPointer;
+
+    //
+    // Variable serviers
+    //
+
+    EFI_GET_VARIABLE                GetVariable;
+    EFI_GET_NEXT_VARIABLE_NAME      GetNextVariableName;
+    EFI_SET_VARIABLE                SetVariable;
+
+    //
+    // Misc
+    //
+
+    EFI_GET_NEXT_HIGH_MONO_COUNT    GetNextHighMonotonicCount;
+    EFI_RESET_SYSTEM                ResetSystem;
+
+    EFI_UPDATE_CAPSULE              UpdateCapsule;
+    EFI_QUERY_CAPSULE_CAPABILITIES  QueryCapsuleCapabilities;
+    EFI_QUERY_VARIABLE_INFO         QueryVariableInfo;
+} EFI_RUNTIME_SERVICES;
+
+
+//
+// EFI Boot Services Table
+//
+
+#define EFI_BOOT_SERVICES_SIGNATURE     0x56524553544f4f42
+#define EFI_BOOT_SERVICES_REVISION      (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION)
+
+typedef struct _EFI_BOOT_SERVICES {
+
+    EFI_TABLE_HEADER                Hdr;
+
+    //
+    // Task priority functions
+    //
+
+    EFI_RAISE_TPL                   RaiseTPL;
+    EFI_RESTORE_TPL                 RestoreTPL;
+
+    //
+    // Memory functions
+    //
+
+    EFI_ALLOCATE_PAGES              AllocatePages;
+    EFI_FREE_PAGES                  FreePages;
+    EFI_GET_MEMORY_MAP              GetMemoryMap;
+    EFI_ALLOCATE_POOL               AllocatePool;
+    EFI_FREE_POOL                   FreePool;
+
+    //
+    // Event & timer functions
+    //
+
+    EFI_CREATE_EVENT                CreateEvent;
+    EFI_SET_TIMER                   SetTimer;
+    EFI_WAIT_FOR_EVENT              WaitForEvent;
+    EFI_SIGNAL_EVENT                SignalEvent;
+    EFI_CLOSE_EVENT                 CloseEvent;
+    EFI_CHECK_EVENT                 CheckEvent;
+
+    //
+    // Protocol handler functions
+    //
+
+    EFI_INSTALL_PROTOCOL_INTERFACE  InstallProtocolInterface;
+    EFI_REINSTALL_PROTOCOL_INTERFACE ReinstallProtocolInterface;
+    EFI_UNINSTALL_PROTOCOL_INTERFACE UninstallProtocolInterface;
+    EFI_HANDLE_PROTOCOL             HandleProtocol;
+    EFI_HANDLE_PROTOCOL             PCHandleProtocol;
+    EFI_REGISTER_PROTOCOL_NOTIFY    RegisterProtocolNotify;
+    EFI_LOCATE_HANDLE               LocateHandle;
+    EFI_LOCATE_DEVICE_PATH          LocateDevicePath;
+    EFI_INSTALL_CONFIGURATION_TABLE InstallConfigurationTable;
+
+    //
+    // Image functions
+    //
+
+    EFI_IMAGE_LOAD                  LoadImage;
+    EFI_IMAGE_START                 StartImage;
+    EFI_EXIT                        Exit;
+    EFI_IMAGE_UNLOAD                UnloadImage;
+    EFI_EXIT_BOOT_SERVICES          ExitBootServices;
+
+    //
+    // Misc functions
+    //
+
+    EFI_GET_NEXT_MONOTONIC_COUNT    GetNextMonotonicCount;
+    EFI_STALL                       Stall;
+    EFI_SET_WATCHDOG_TIMER          SetWatchdogTimer;
+
+    //
+    // DriverSupport Services
+    //
+
+    EFI_CONNECT_CONTROLLER          ConnectController;
+    EFI_DISCONNECT_CONTROLLER       DisconnectController;
+
+    //
+    // Open and Close Protocol Services
+    //
+    EFI_OPEN_PROTOCOL               OpenProtocol;
+    EFI_CLOSE_PROTOCOL              CloseProtocol;
+    EFI_OPEN_PROTOCOL_INFORMATION   OpenProtocolInformation;
+
+    //
+    // Library Services
+    //
+    EFI_PROTOCOLS_PER_HANDLE        ProtocolsPerHandle;
+    EFI_LOCATE_HANDLE_BUFFER        LocateHandleBuffer;
+    EFI_LOCATE_PROTOCOL             LocateProtocol;
+    EFI_INSTALL_MULTIPLE_PROTOCOL_INTERFACES InstallMultipleProtocolInterfaces;
+    EFI_UNINSTALL_MULTIPLE_PROTOCOL_INTERFACES UninstallMultipleProtocolInterfaces;
+
+    //
+    // 32-bit CRC Services
+    //
+    EFI_CALCULATE_CRC32             CalculateCrc32;
+
+    //
+    // Misc Services
+    //
+    EFI_COPY_MEM                    CopyMem;
+    EFI_SET_MEM                     SetMem;
+    EFI_CREATE_EVENT_EX             CreateEventEx;
+} EFI_BOOT_SERVICES;
+
+
+//
+// EFI Configuration Table and GUID definitions
+//
+
+#define MPS_TABLE_GUID    \
+    { 0xeb9d2d2f, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+
+#define ACPI_TABLE_GUID    \
+    { 0xeb9d2d30, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+
+#define ACPI_20_TABLE_GUID  \
+    { 0x8868e871, 0xe4f1, 0x11d3, {0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} }
+
+#define SMBIOS_TABLE_GUID    \
+    { 0xeb9d2d31, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+
+#define SMBIOS3_TABLE_GUID    \
+    { 0xf2fd1544, 0x9794, 0x4a2c, {0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94} }
+
+#define SAL_SYSTEM_TABLE_GUID    \
+    { 0xeb9d2d32, 0x2d88, 0x11d3, {0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+
+
+typedef struct _EFI_CONFIGURATION_TABLE {
+    EFI_GUID                VendorGuid;
+    VOID                    *VendorTable;
+} EFI_CONFIGURATION_TABLE;
+
+
+//
+// EFI System Table
+//
+
+
+
+
+#define EFI_SYSTEM_TABLE_SIGNATURE      0x5453595320494249
+#define EFI_SYSTEM_TABLE_REVISION      (EFI_SPECIFICATION_MAJOR_REVISION<<16) | (EFI_SPECIFICATION_MINOR_REVISION)
+
+typedef struct _EFI_SYSTEM_TABLE {
+    EFI_TABLE_HEADER                Hdr;
+
+    CHAR16                          *FirmwareVendor;
+    UINT32                          FirmwareRevision;
+
+    EFI_HANDLE                      ConsoleInHandle;
+    SIMPLE_INPUT_INTERFACE          *ConIn;
+
+    EFI_HANDLE                      ConsoleOutHandle;
+    SIMPLE_TEXT_OUTPUT_INTERFACE    *ConOut;
+
+    EFI_HANDLE                      StandardErrorHandle;
+    SIMPLE_TEXT_OUTPUT_INTERFACE    *StdErr;
+
+    EFI_RUNTIME_SERVICES            *RuntimeServices;
+    EFI_BOOT_SERVICES               *BootServices;
+
+    UINTN                           NumberOfTableEntries;
+    EFI_CONFIGURATION_TABLE         *ConfigurationTable;
+
+} EFI_SYSTEM_TABLE;
+
+#endif
+

src/include/efi/eficompiler.h

@@ -0,0 +1,30 @@
+/*++
+
+Copyright (c) 2016 Pete Batard <pete@akeo.ie>
+
+Module Name:
+
+    eficompiler.h
+
+Abstract:
+
+    Compiler specific adjustments
+
+--*/
+
+#ifdef _MSC_EXTENSIONS
+#define EFI_UNUSED
+#else
+#define EFI_UNUSED __attribute__((__unused__))
+#endif
+
+#ifdef _MSC_EXTENSIONS
+#define ALIGN(x) __declspec(align(x))
+#else
+#define ALIGN(x) __attribute__((__aligned__(x)))
+#endif
+
+/* Also add a catch-all on __attribute__() for MS compilers */
+#ifdef _MSC_EXTENSIONS
+#define __attribute__(x)
+#endif

src/include/efi/eficon.h

@@ -0,0 +1,306 @@
+#ifndef _EFI_CON_H
+#define _EFI_CON_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    eficon.h
+
+Abstract:
+
+    EFI console protocols
+
+
+
+Revision History
+
+--*/
+
+//
+// Text output protocol
+//
+
+#define EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID \
+    { 0x387477c2, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
+#define SIMPLE_TEXT_OUTPUT_PROTOCOL EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID
+
+INTERFACE_DECL(_SIMPLE_TEXT_OUTPUT_INTERFACE);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_RESET) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN BOOLEAN                      ExtendedVerification
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_OUTPUT_STRING) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN CHAR16                       *String
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_TEST_STRING) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN CHAR16                       *String
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_QUERY_MODE) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN UINTN                        ModeNumber,
+    OUT UINTN                       *Columns,
+    OUT UINTN                       *Rows
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_MODE) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN UINTN                        ModeNumber
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_ATTRIBUTE) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN UINTN                        Attribute
+    );
+
+#define EFI_BLACK   0x00
+#define EFI_BLUE    0x01
+#define EFI_GREEN   0x02
+#define EFI_CYAN            (EFI_BLUE | EFI_GREEN)
+#define EFI_RED     0x04
+#define EFI_MAGENTA         (EFI_BLUE | EFI_RED)
+#define EFI_BROWN           (EFI_GREEN | EFI_RED)
+#define EFI_LIGHTGRAY       (EFI_BLUE | EFI_GREEN | EFI_RED)
+#define EFI_BRIGHT  0x08
+#define EFI_DARKGRAY        (EFI_BRIGHT)
+#define EFI_LIGHTBLUE       (EFI_BLUE | EFI_BRIGHT)
+#define EFI_LIGHTGREEN      (EFI_GREEN | EFI_BRIGHT)
+#define EFI_LIGHTCYAN       (EFI_CYAN | EFI_BRIGHT)
+#define EFI_LIGHTRED        (EFI_RED | EFI_BRIGHT)
+#define EFI_LIGHTMAGENTA    (EFI_MAGENTA | EFI_BRIGHT)
+#define EFI_YELLOW          (EFI_BROWN | EFI_BRIGHT)
+#define EFI_WHITE           (EFI_BLUE | EFI_GREEN | EFI_RED | EFI_BRIGHT)
+
+#define EFI_TEXT_ATTR(f,b)  ((f) | ((b) << 4))
+
+#define EFI_BACKGROUND_BLACK        0x00
+#define EFI_BACKGROUND_BLUE         0x10
+#define EFI_BACKGROUND_GREEN        0x20
+#define EFI_BACKGROUND_CYAN         (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN)
+#define EFI_BACKGROUND_RED          0x40
+#define EFI_BACKGROUND_MAGENTA      (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_RED)
+#define EFI_BACKGROUND_BROWN        (EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED)
+#define EFI_BACKGROUND_LIGHTGRAY    (EFI_BACKGROUND_BLUE | EFI_BACKGROUND_GREEN | EFI_BACKGROUND_RED)
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_CLEAR_SCREEN) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_SET_CURSOR_POSITION) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN UINTN                        Column,
+    IN UINTN                        Row
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TEXT_ENABLE_CURSOR) (
+    IN struct _SIMPLE_TEXT_OUTPUT_INTERFACE     *This,
+    IN BOOLEAN                      Enable
+    );
+
+typedef struct {
+    INT32                           MaxMode;
+    // current settings
+    INT32                           Mode;
+    INT32                           Attribute;
+    INT32                           CursorColumn;
+    INT32                           CursorRow;
+    BOOLEAN                         CursorVisible;
+} SIMPLE_TEXT_OUTPUT_MODE;
+
+typedef struct _SIMPLE_TEXT_OUTPUT_INTERFACE {
+    EFI_TEXT_RESET                  Reset;
+
+    EFI_TEXT_OUTPUT_STRING          OutputString;
+    EFI_TEXT_TEST_STRING            TestString;
+
+    EFI_TEXT_QUERY_MODE             QueryMode;
+    EFI_TEXT_SET_MODE               SetMode;
+    EFI_TEXT_SET_ATTRIBUTE          SetAttribute;
+
+    EFI_TEXT_CLEAR_SCREEN           ClearScreen;
+    EFI_TEXT_SET_CURSOR_POSITION    SetCursorPosition;
+    EFI_TEXT_ENABLE_CURSOR          EnableCursor;
+
+    // Current mode
+    SIMPLE_TEXT_OUTPUT_MODE         *Mode;
+} SIMPLE_TEXT_OUTPUT_INTERFACE, EFI_SIMPLE_TEXT_OUT_PROTOCOL;
+
+//
+// Define's for required EFI Unicode Box Draw character
+//
+
+#define BOXDRAW_HORIZONTAL                  0x2500
+#define BOXDRAW_VERTICAL                    0x2502
+#define BOXDRAW_DOWN_RIGHT                  0x250c
+#define BOXDRAW_DOWN_LEFT                   0x2510
+#define BOXDRAW_UP_RIGHT                    0x2514
+#define BOXDRAW_UP_LEFT                     0x2518
+#define BOXDRAW_VERTICAL_RIGHT              0x251c
+#define BOXDRAW_VERTICAL_LEFT               0x2524
+#define BOXDRAW_DOWN_HORIZONTAL             0x252c
+#define BOXDRAW_UP_HORIZONTAL               0x2534
+#define BOXDRAW_VERTICAL_HORIZONTAL         0x253c
+
+#define BOXDRAW_DOUBLE_HORIZONTAL           0x2550
+#define BOXDRAW_DOUBLE_VERTICAL             0x2551
+#define BOXDRAW_DOWN_RIGHT_DOUBLE           0x2552
+#define BOXDRAW_DOWN_DOUBLE_RIGHT           0x2553
+#define BOXDRAW_DOUBLE_DOWN_RIGHT           0x2554
+
+#define BOXDRAW_DOWN_LEFT_DOUBLE            0x2555
+#define BOXDRAW_DOWN_DOUBLE_LEFT            0x2556
+#define BOXDRAW_DOUBLE_DOWN_LEFT            0x2557
+
+#define BOXDRAW_UP_RIGHT_DOUBLE             0x2558
+#define BOXDRAW_UP_DOUBLE_RIGHT             0x2559
+#define BOXDRAW_DOUBLE_UP_RIGHT             0x255a
+
+#define BOXDRAW_UP_LEFT_DOUBLE              0x255b
+#define BOXDRAW_UP_DOUBLE_LEFT              0x255c
+#define BOXDRAW_DOUBLE_UP_LEFT              0x255d
+
+#define BOXDRAW_VERTICAL_RIGHT_DOUBLE       0x255e
+#define BOXDRAW_VERTICAL_DOUBLE_RIGHT       0x255f
+#define BOXDRAW_DOUBLE_VERTICAL_RIGHT       0x2560
+
+#define BOXDRAW_VERTICAL_LEFT_DOUBLE        0x2561
+#define BOXDRAW_VERTICAL_DOUBLE_LEFT        0x2562
+#define BOXDRAW_DOUBLE_VERTICAL_LEFT        0x2563
+
+#define BOXDRAW_DOWN_HORIZONTAL_DOUBLE      0x2564
+#define BOXDRAW_DOWN_DOUBLE_HORIZONTAL      0x2565
+#define BOXDRAW_DOUBLE_DOWN_HORIZONTAL      0x2566
+
+#define BOXDRAW_UP_HORIZONTAL_DOUBLE        0x2567
+#define BOXDRAW_UP_DOUBLE_HORIZONTAL        0x2568
+#define BOXDRAW_DOUBLE_UP_HORIZONTAL        0x2569
+
+#define BOXDRAW_VERTICAL_HORIZONTAL_DOUBLE  0x256a
+#define BOXDRAW_VERTICAL_DOUBLE_HORIZONTAL  0x256b
+#define BOXDRAW_DOUBLE_VERTICAL_HORIZONTAL  0x256c
+
+//
+// EFI Required Block Elements Code Chart
+//
+
+#define BLOCKELEMENT_FULL_BLOCK             0x2588
+#define BLOCKELEMENT_LIGHT_SHADE            0x2591
+//
+// EFI Required Geometric Shapes Code Chart
+//
+
+#define GEOMETRICSHAPE_UP_TRIANGLE           0x25b2
+#define GEOMETRICSHAPE_RIGHT_TRIANGLE        0x25ba
+#define GEOMETRICSHAPE_DOWN_TRIANGLE         0x25bc
+#define GEOMETRICSHAPE_LEFT_TRIANGLE         0x25c4
+
+//
+// EFI Required Arrow shapes
+//
+
+#define ARROW_UP                            0x2191
+#define ARROW_DOWN                          0x2193
+
+//
+// Text input protocol
+//
+
+#define EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID \
+    { 0x387477c1, 0x69c7, 0x11d2, {0x8e, 0x39, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
+#define SIMPLE_TEXT_INPUT_PROTOCOL EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID
+
+INTERFACE_DECL(_SIMPLE_INPUT_INTERFACE);
+
+typedef struct {
+    UINT16                              ScanCode;
+    CHAR16                              UnicodeChar;
+} EFI_INPUT_KEY;
+
+//
+// Baseline unicode control chars
+//
+
+#define CHAR_NULL                       0x0000
+#define CHAR_BACKSPACE                  0x0008
+#define CHAR_TAB                        0x0009
+#define CHAR_LINEFEED                   0x000A
+#define CHAR_CARRIAGE_RETURN            0x000D
+
+//
+// Scan codes for base line keys
+//
+
+#define SCAN_NULL                       0x0000
+#define SCAN_UP                         0x0001
+#define SCAN_DOWN                       0x0002
+#define SCAN_RIGHT                      0x0003
+#define SCAN_LEFT                       0x0004
+#define SCAN_HOME                       0x0005
+#define SCAN_END                        0x0006
+#define SCAN_INSERT                     0x0007
+#define SCAN_DELETE                     0x0008
+#define SCAN_PAGE_UP                    0x0009
+#define SCAN_PAGE_DOWN                  0x000A
+#define SCAN_F1                         0x000B
+#define SCAN_F2                         0x000C
+#define SCAN_F3                         0x000D
+#define SCAN_F4                         0x000E
+#define SCAN_F5                         0x000F
+#define SCAN_F6                         0x0010
+#define SCAN_F7                         0x0011
+#define SCAN_F8                         0x0012
+#define SCAN_F9                         0x0013
+#define SCAN_F10                        0x0014
+#define SCAN_F11                        0x0015
+#define SCAN_F12                        0x0016
+#define SCAN_ESC                        0x0017
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_RESET) (
+    IN struct _SIMPLE_INPUT_INTERFACE   *This,
+    IN BOOLEAN                          ExtendedVerification
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INPUT_READ_KEY) (
+    IN struct _SIMPLE_INPUT_INTERFACE   *This,
+    OUT EFI_INPUT_KEY                   *Key
+    );
+
+typedef struct _SIMPLE_INPUT_INTERFACE {
+    EFI_INPUT_RESET                     Reset;
+    EFI_INPUT_READ_KEY                  ReadKeyStroke;
+    EFI_EVENT                           WaitForKey;
+} SIMPLE_INPUT_INTERFACE, EFI_SIMPLE_TEXT_IN_PROTOCOL;
+
+#endif
+

src/include/efi/efidebug.h

@@ -0,0 +1,620 @@
+#ifndef _EFI_DEBUG_H
+#define _EFI_DEBUG_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efidebug.h
+
+Abstract:
+
+    EFI library debug functions
+
+
+
+Revision History
+
+--*/
+
+extern UINTN     EFIDebug;
+
+#if EFI_DEBUG
+
+    #define DBGASSERT(a)        DbgAssert(__FILE__, __LINE__, #a)
+    #define DEBUG(a)            DbgPrint a
+    
+#else
+
+    #define DBGASSERT(a)
+    #define DEBUG(a)
+    
+#endif
+
+#if EFI_DEBUG_CLEAR_MEMORY
+
+    #define DBGSETMEM(a,l)      SetMem(a,l,(CHAR8)BAD_POINTER)
+
+#else
+
+    #define DBGSETMEM(a,l)
+
+#endif
+
+#define D_INIT        0x00000001          // Initialization style messages
+#define D_WARN        0x00000002          // Warnings
+#define D_LOAD        0x00000004          // Load events
+#define D_FS          0x00000008          // EFI File system
+#define D_POOL        0x00000010          // Alloc & Free's
+#define D_PAGE        0x00000020          // Alloc & Free's
+#define D_INFO        0x00000040          // Verbose
+#define D_VAR         0x00000100          // Variable
+#define D_PARSE       0x00000200          // Command parsing
+#define D_BM          0x00000400          // Boot manager
+#define D_BLKIO       0x00001000          // BlkIo Driver
+#define D_BLKIO_ULTRA 0x00002000          // BlkIo Driver
+#define D_NET         0x00004000          // SNI Driver
+#define D_NET_ULTRA   0x00008000          // SNI Driver
+#define D_TXTIN       0x00010000          // Simple Input Driver
+#define D_TXTOUT      0x00020000          // Simple Text Output Driver
+#define D_ERROR_ATA	  0x00040000		  		// ATA error messages 
+#define D_ERROR       0x80000000          // Error
+
+#define D_RESERVED    0x7fffC880          // Bits not reserved above
+
+//
+// Current Debug level of the system, value of EFIDebug
+//
+//#define EFI_DBUG_MASK   (D_ERROR | D_WARN | D_LOAD | D_BLKIO | D_INIT)
+#define EFI_DBUG_MASK   (D_ERROR)
+
+//
+//
+//
+
+#if EFI_DEBUG
+
+    #define ASSERT(a)               if(!(a))       DBGASSERT(a)
+    #define ASSERT_LOCKED(l)        if(!(l)->Lock) DBGASSERT(l not locked)
+    #define ASSERT_STRUCT(p,t)      DBGASSERT(t not structure), p
+
+#else
+
+    #define ASSERT(a)               
+    #define ASSERT_LOCKED(l)        
+    #define ASSERT_STRUCT(p,t)      
+
+#endif
+
+//
+// Prototypes
+//
+
+INTN
+DbgAssert (
+    CONST CHAR8   *file,
+    INTN          lineno,
+    CONST CHAR8   *string
+    );
+
+INTN
+DbgPrint (
+    INTN          mask,
+    CONST CHAR8   *format,
+    ...
+    );
+
+//
+// Instruction Set Architectures definitions for debuggers
+//
+
+typedef INTN EFI_EXCEPTION_TYPE;
+
+// IA32
+#define EXCEPT_IA32_DIVIDE_ERROR    0
+#define EXCEPT_IA32_DEBUG           1
+#define EXCEPT_IA32_NMI             2
+#define EXCEPT_IA32_BREAKPOINT      3
+#define EXCEPT_IA32_OVERFLOW        4
+#define EXCEPT_IA32_BOUND           5
+#define EXCEPT_IA32_INVALID_OPCODE  6
+#define EXCEPT_IA32_DOUBLE_FAULT    8
+#define EXCEPT_IA32_INVALID_TSS     10
+#define EXCEPT_IA32_SEG_NOT_PRESENT 11
+#define EXCEPT_IA32_STACK_FAULT     12
+#define EXCEPT_IA32_GP_FAULT        13
+#define EXCEPT_IA32_PAGE_FAULT      14
+#define EXCEPT_IA32_FP_ERROR        16
+#define EXCEPT_IA32_ALIGNMENT_CHECK 17
+#define EXCEPT_IA32_MACHINE_CHECK   18
+#define EXCEPT_IA32_SIMD            19
+
+typedef struct {
+    UINT16  Fcw;
+    UINT16  Fsw;
+    UINT16  Ftw;
+    UINT16  Opcode;
+    UINT32  Eip;
+    UINT16  Cs;
+    UINT16  Reserved1;
+    UINT32  DataOffset;
+    UINT16  Ds;
+    UINT8   Reserved2[10];
+    UINT8   St0Mm0[10], Reserved3[6];
+    UINT8   St1Mm1[10], Reserved4[6];
+    UINT8   St2Mm2[10], Reserved5[6];
+    UINT8   St3Mm3[10], Reserved6[6];
+    UINT8   St4Mm4[10], Reserved7[6];
+    UINT8   St5Mm5[10], Reserved8[6];
+    UINT8   St6Mm6[10], Reserved9[6];
+    UINT8   St7Mm7[10], Reserved10[6];
+    UINT8   Xmm0[16];
+    UINT8   Xmm1[16];
+    UINT8   Xmm2[16];
+    UINT8   Xmm3[16];
+    UINT8   Xmm4[16];
+    UINT8   Xmm5[16];
+    UINT8   Xmm6[16];
+    UINT8   Xmm7[16];
+    UINT8   Reserved11[14 * 16];
+} EFI_FX_SAVE_STATE_IA32;
+
+typedef struct {
+    UINT32                 ExceptionData;
+    EFI_FX_SAVE_STATE_IA32 FxSaveState;
+    UINT32                 Dr0;
+    UINT32                 Dr1;
+    UINT32                 Dr2;
+    UINT32                 Dr3;
+    UINT32                 Dr6;
+    UINT32                 Dr7;
+    UINT32                 Cr0;
+    UINT32                 Cr1;
+    UINT32                 Cr2;
+    UINT32                 Cr3;
+    UINT32                 Cr4;
+    UINT32                 Eflags;
+    UINT32                 Ldtr;
+    UINT32                 Tr;
+    UINT32                 Gdtr[2];
+    UINT32                 Idtr[2];
+    UINT32                 Eip;
+    UINT32                 Gs;
+    UINT32                 Fs;
+    UINT32                 Es;
+    UINT32                 Ds;
+    UINT32                 Cs;
+    UINT32                 Ss;
+    UINT32                 Edi;
+    UINT32                 Esi;
+    UINT32                 Ebp;
+    UINT32                 Esp;
+    UINT32                 Ebx;
+    UINT32                 Edx;
+    UINT32                 Ecx;
+    UINT32                 Eax;
+} EFI_SYSTEM_CONTEXT_IA32;
+
+// X64
+#define EXCEPT_X64_DIVIDE_ERROR    0
+#define EXCEPT_X64_DEBUG           1
+#define EXCEPT_X64_NMI             2
+#define EXCEPT_X64_BREAKPOINT      3
+#define EXCEPT_X64_OVERFLOW        4
+#define EXCEPT_X64_BOUND           5
+#define EXCEPT_X64_INVALID_OPCODE  6
+#define EXCEPT_X64_DOUBLE_FAULT    8
+#define EXCEPT_X64_INVALID_TSS     10
+#define EXCEPT_X64_SEG_NOT_PRESENT 11
+#define EXCEPT_X64_STACK_FAULT     12
+#define EXCEPT_X64_GP_FAULT        13
+#define EXCEPT_X64_PAGE_FAULT      14
+#define EXCEPT_X64_FP_ERROR        16
+#define EXCEPT_X64_ALIGNMENT_CHECK 17
+#define EXCEPT_X64_MACHINE_CHECK   18
+#define EXCEPT_X64_SIMD            19
+
+typedef struct {
+    UINT16  Fcw;
+    UINT16  Fsw;
+    UINT16  Ftw;
+    UINT16  Opcode;
+    UINT64  Rip;
+    UINT64  DataOffset;
+    UINT8   Reserved1[8];
+    UINT8   St0Mm0[10], Reserved2[6];
+    UINT8   St1Mm1[10], Reserved3[6];
+    UINT8   St2Mm2[10], Reserved4[6];
+    UINT8   St3Mm3[10], Reserved5[6];
+    UINT8   St4Mm4[10], Reserved6[6];
+    UINT8   St5Mm5[10], Reserved7[6];
+    UINT8   St6Mm6[10], Reserved8[6];
+    UINT8   St7Mm7[10], Reserved9[6];
+    UINT8   Xmm0[16];
+    UINT8   Xmm1[16];
+    UINT8   Xmm2[16];
+    UINT8   Xmm3[16];
+    UINT8   Xmm4[16];
+    UINT8   Xmm5[16];
+    UINT8   Xmm6[16];
+    UINT8   Xmm7[16];
+    UINT8   Reserved11[14 * 16];
+} EFI_FX_SAVE_STATE_X64;
+
+typedef struct {
+    UINT64                ExceptionData;
+    EFI_FX_SAVE_STATE_X64 FxSaveState;
+    UINT64                Dr0;
+    UINT64                Dr1;
+    UINT64                Dr2;
+    UINT64                Dr3;
+    UINT64                Dr6;
+    UINT64                Dr7;
+    UINT64                Cr0;
+    UINT64                Cr1;
+    UINT64                Cr2;
+    UINT64                Cr3;
+    UINT64                Cr4;
+    UINT64                Cr8;
+    UINT64                Rflags;
+    UINT64                Ldtr;
+    UINT64                Tr;
+    UINT64                Gdtr[2];
+    UINT64                Idtr[2];
+    UINT64                Rip;
+    UINT64                Gs;
+    UINT64                Fs;
+    UINT64                Es;
+    UINT64                Ds;
+    UINT64                Cs;
+    UINT64                Ss;
+    UINT64                Rdi;
+    UINT64                Rsi;
+    UINT64                Rbp;
+    UINT64                Rsp;
+    UINT64                Rbx;
+    UINT64                Rdx;
+    UINT64                Rcx;
+    UINT64                Rax;
+    UINT64                R8;
+    UINT64                R9;
+    UINT64                R10;
+    UINT64                R11;
+    UINT64                R12;
+    UINT64                R13;
+    UINT64                R14;
+    UINT64                R15;
+} EFI_SYSTEM_CONTEXT_X64;
+
+/// IA64
+#define EXCEPT_IPF_VHTP_TRANSLATION               0
+#define EXCEPT_IPF_INSTRUCTION_TLB                1
+#define EXCEPT_IPF_DATA_TLB                       2
+#define EXCEPT_IPF_ALT_INSTRUCTION_TLB            3
+#define EXCEPT_IPF_ALT_DATA_TLB                   4
+#define EXCEPT_IPF_DATA_NESTED_TLB                5
+#define EXCEPT_IPF_INSTRUCTION_KEY_MISSED         6
+#define EXCEPT_IPF_DATA_KEY_MISSED                7
+#define EXCEPT_IPF_DIRTY_BIT                      8
+#define EXCEPT_IPF_INSTRUCTION_ACCESS_BIT         9
+#define EXCEPT_IPF_DATA_ACCESS_BIT                10
+#define EXCEPT_IPF_BREAKPOINT                     11
+#define EXCEPT_IPF_EXTERNAL_INTERRUPT             12
+#define EXCEPT_IPF_PAGE_NOT_PRESENT               20
+#define EXCEPT_IPF_KEY_PERMISSION                 21
+#define EXCEPT_IPF_INSTRUCTION_ACCESS_RIGHTS      22
+#define EXCEPT_IPF_DATA_ACCESS_RIGHTS             23
+#define EXCEPT_IPF_GENERAL_EXCEPTION              24
+#define EXCEPT_IPF_DISABLED_FP_REGISTER           25
+#define EXCEPT_IPF_NAT_CONSUMPTION                26
+#define EXCEPT_IPF_SPECULATION                    27
+#define EXCEPT_IPF_DEBUG                          29
+#define EXCEPT_IPF_UNALIGNED_REFERENCE            30
+#define EXCEPT_IPF_UNSUPPORTED_DATA_REFERENCE     31
+#define EXCEPT_IPF_FP_FAULT                       32
+#define EXCEPT_IPF_FP_TRAP                        33
+#define EXCEPT_IPF_LOWER_PRIVILEGE_TRANSFER_TRAP  34
+#define EXCEPT_IPF_TAKEN_BRANCH                   35
+#define EXCEPT_IPF_SINGLE_STEP                    36
+#define EXCEPT_IPF_IA32_EXCEPTION                 45
+#define EXCEPT_IPF_IA32_INTERCEPT                 46
+#define EXCEPT_IPF_IA32_INTERRUPT                 47
+
+typedef struct {
+    UINT64  Reserved;
+    UINT64  R1;
+    UINT64  R2;
+    UINT64  R3;
+    UINT64  R4;
+    UINT64  R5;
+    UINT64  R6;
+    UINT64  R7;
+    UINT64  R8;
+    UINT64  R9;
+    UINT64  R10;
+    UINT64  R11;
+    UINT64  R12;
+    UINT64  R13;
+    UINT64  R14;
+    UINT64  R15;
+    UINT64  R16;
+    UINT64  R17;
+    UINT64  R18;
+    UINT64  R19;
+    UINT64  R20;
+    UINT64  R21;
+    UINT64  R22;
+    UINT64  R23;
+    UINT64  R24;
+    UINT64  R25;
+    UINT64  R26;
+    UINT64  R27;
+    UINT64  R28;
+    UINT64  R29;
+    UINT64  R30;
+    UINT64  R31;
+    UINT64  F2[2];
+    UINT64  F3[2];
+    UINT64  F4[2];
+    UINT64  F5[2];
+    UINT64  F6[2];
+    UINT64  F7[2];
+    UINT64  F8[2];
+    UINT64  F9[2];
+    UINT64  F10[2];
+    UINT64  F11[2];
+    UINT64  F12[2];
+    UINT64  F13[2];
+    UINT64  F14[2];
+    UINT64  F15[2];
+    UINT64  F16[2];
+    UINT64  F17[2];
+    UINT64  F18[2];
+    UINT64  F19[2];
+    UINT64  F20[2];
+    UINT64  F21[2];
+    UINT64  F22[2];
+    UINT64  F23[2];
+    UINT64  F24[2];
+    UINT64  F25[2];
+    UINT64  F26[2];
+    UINT64  F27[2];
+    UINT64  F28[2];
+    UINT64  F29[2];
+    UINT64  F30[2];
+    UINT64  F31[2];
+    UINT64  Pr;
+    UINT64  B0;
+    UINT64  B1;
+    UINT64  B2;
+    UINT64  B3;
+    UINT64  B4;
+    UINT64  B5;
+    UINT64  B6;
+    UINT64  B7;
+    UINT64  ArRsc;
+    UINT64  ArBsp;
+    UINT64  ArBspstore;
+    UINT64  ArRnat;
+    UINT64  ArFcr;
+    UINT64  ArEflag;
+    UINT64  ArCsd;
+    UINT64  ArSsd;
+    UINT64  ArCflg;
+    UINT64  ArFsr;
+    UINT64  ArFir;
+    UINT64  ArFdr;
+    UINT64  ArCcv;
+    UINT64  ArUnat;
+    UINT64  ArFpsr;
+    UINT64  ArPfs;
+    UINT64  ArLc;
+    UINT64  ArEc;
+    UINT64  CrDcr;
+    UINT64  CrItm;
+    UINT64  CrIva;
+    UINT64  CrPta;
+    UINT64  CrIpsr;
+    UINT64  CrIsr;
+    UINT64  CrIip;
+    UINT64  CrIfa;
+    UINT64  CrItir;
+    UINT64  CrIipa;
+    UINT64  CrIfs;
+    UINT64  CrIim;
+    UINT64  CrIha;
+    UINT64  Dbr0;
+    UINT64  Dbr1;
+    UINT64  Dbr2;
+    UINT64  Dbr3;
+    UINT64  Dbr4;
+    UINT64  Dbr5;
+    UINT64  Dbr6;
+    UINT64  Dbr7;
+    UINT64  Ibr0;
+    UINT64  Ibr1;
+    UINT64  Ibr2;
+    UINT64  Ibr3;
+    UINT64  Ibr4;
+    UINT64  Ibr5;
+    UINT64  Ibr6;
+    UINT64  Ibr7;
+    UINT64  IntNat;
+} EFI_SYSTEM_CONTEXT_IPF;
+
+// EBC
+#define EXCEPT_EBC_UNDEFINED            0
+#define EXCEPT_EBC_DIVIDE_ERROR         1
+#define EXCEPT_EBC_DEBUG                2
+#define EXCEPT_EBC_BREAKPOINT           3
+#define EXCEPT_EBC_OVERFLOW             4
+#define EXCEPT_EBC_INVALID_OPCODE       5
+#define EXCEPT_EBC_STACK_FAULT          6
+#define EXCEPT_EBC_ALIGNMENT_CHECK      7
+#define EXCEPT_EBC_INSTRUCTION_ENCODING 8
+#define EXCEPT_EBC_BAD_BREAK            9
+#define EXCEPT_EBC_STEP                 10
+#define MAX_EBC_EXCEPTION               EXCEPT_EBC_STEP
+
+typedef struct {
+    UINT64  R0;
+    UINT64  R1;
+    UINT64  R2;
+    UINT64  R3;
+    UINT64  R4;
+    UINT64  R5;
+    UINT64  R6;
+    UINT64  R7;
+    UINT64  Flags;
+    UINT64  ControlFlags;
+    UINT64  Ip;
+} EFI_SYSTEM_CONTEXT_EBC;
+
+// ARM
+#define EXCEPT_ARM_RESET                    0
+#define EXCEPT_ARM_UNDEFINED_INSTRUCTION    1
+#define EXCEPT_ARM_SOFTWARE_INTERRUPT       2
+#define EXCEPT_ARM_PREFETCH_ABORT           3
+#define EXCEPT_ARM_DATA_ABORT               4
+#define EXCEPT_ARM_RESERVED                 5
+#define EXCEPT_ARM_IRQ                      6
+#define EXCEPT_ARM_FIQ                      7
+#define MAX_ARM_EXCEPTION                   EXCEPT_ARM_FIQ
+
+typedef struct {
+    UINT32  R0;
+    UINT32  R1;
+    UINT32  R2;
+    UINT32  R3;
+    UINT32  R4;
+    UINT32  R5;
+    UINT32  R6;
+    UINT32  R7;
+    UINT32  R8;
+    UINT32  R9;
+    UINT32  R10;
+    UINT32  R11;
+    UINT32  R12;
+    UINT32  SP;
+    UINT32  LR;
+    UINT32  PC;
+    UINT32  CPSR;
+    UINT32  DFSR;
+    UINT32  DFAR;
+    UINT32  IFSR;
+    UINT32  IFAR;
+} EFI_SYSTEM_CONTEXT_ARM;
+
+
+typedef union {
+    EFI_SYSTEM_CONTEXT_EBC  *SystemContextEbc;
+    EFI_SYSTEM_CONTEXT_IA32 *SystemContextIa32;
+    EFI_SYSTEM_CONTEXT_X64  *SystemContextX64;
+    EFI_SYSTEM_CONTEXT_IPF  *SystemContextIpf;
+    EFI_SYSTEM_CONTEXT_ARM  *SystemContextArm;
+} EFI_SYSTEM_CONTEXT;
+
+typedef
+VOID
+(EFIAPI *EFI_EXCEPTION_CALLBACK)(
+    IN     EFI_EXCEPTION_TYPE               ExceptionType,
+    IN OUT EFI_SYSTEM_CONTEXT               SystemContext);
+
+typedef
+VOID
+(EFIAPI *EFI_PERIODIC_CALLBACK)(
+    IN OUT EFI_SYSTEM_CONTEXT               SystemContext);
+
+typedef enum {
+    IsaIa32 = EFI_IMAGE_MACHINE_IA32,
+    IsaX64 = EFI_IMAGE_MACHINE_X64,
+    IsaIpf = EFI_IMAGE_MACHINE_IA64,
+    IsaEbc = EFI_IMAGE_MACHINE_EBC,
+    IsaArm = EFI_IMAGE_MACHINE_ARMTHUMB_MIXED,
+//	IsaArm64 = EFI_IMAGE_MACHINE_AARCH64
+} EFI_INSTRUCTION_SET_ARCHITECTURE;
+
+//
+// DEBUG_IMAGE_INFO
+//
+
+#define EFI_DEBUG_IMAGE_INFO_TABLE_GUID \
+    { 0x49152e77, 0x1ada, 0x4764, {0xb7, 0xa2, 0x7a, 0xfe, 0xfe, 0xd9, 0x5e, 0x8b} }
+
+#define EFI_DEBUG_IMAGE_INFO_UPDATE_IN_PROGRESS 0x01
+#define EFI_DEBUG_IMAGE_INFO_TABLE_MODIFIED     0x02
+#define EFI_DEBUG_IMAGE_INFO_INITIAL_SIZE       (EFI_PAGE_SIZE / sizeof (UINTN))
+#define EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL        0x01
+
+typedef struct {
+UINT64                Signature;
+EFI_PHYSICAL_ADDRESS  EfiSystemTableBase;
+UINT32                Crc32;
+} EFI_SYSTEM_TABLE_POINTER;
+
+typedef struct {
+UINT32                    ImageInfoType;
+EFI_LOADED_IMAGE_PROTOCOL *LoadedImageProtocolInstance;
+EFI_HANDLE                *ImageHandle;
+} EFI_DEBUG_IMAGE_INFO_NORMAL;
+
+typedef union {
+UINT32                      *ImageInfoType;
+EFI_DEBUG_IMAGE_INFO_NORMAL *NormalImage;
+} EFI_DEBUG_IMAGE_INFO;
+
+typedef struct {
+volatile UINT32       UpdateStatus;
+UINT32                TableSize;
+EFI_DEBUG_IMAGE_INFO  *EfiDebugImageInfoTable;
+} EFI_DEBUG_IMAGE_INFO_TABLE_HEADER;
+
+//
+// EFI_DEBUGGER_PROTOCOL
+//
+
+#define EFI_DEBUG_SUPPORT_PROTOCOL_GUID \
+    { 0x2755590c, 0x6f3c, 0x42fa, {0x9e, 0xa4, 0xa3, 0xba, 0x54, 0x3c, 0xda, 0x25} }
+
+INTERFACE_DECL(_EFI_DEBUG_SUPPORT_PROTOCOL);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_GET_MAXIMUM_PROCESSOR_INDEX)(
+    IN struct _EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+    OUT UINTN                              *MaxProcessorIndex);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_PERIODIC_CALLBACK)(
+    IN struct _EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+    IN UINTN                               ProcessorIndex,
+    IN EFI_PERIODIC_CALLBACK               PeriodicCallback);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_EXCEPTION_CALLBACK)(
+    IN struct _EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+    IN UINTN                               ProcessorIndex,
+    IN EFI_EXCEPTION_CALLBACK              ExceptionCallback,
+    IN EFI_EXCEPTION_TYPE                  ExceptionType);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_INVALIDATE_INSTRUCTION_CACHE)(
+    IN struct _EFI_DEBUG_SUPPORT_PROTOCOL  *This,
+    IN UINTN                               ProcessorIndex,
+    IN VOID                                *Start,
+    IN UINT64                              Length);
+
+typedef struct _EFI_DEBUG_SUPPORT_PROTOCOL {
+    EFI_INSTRUCTION_SET_ARCHITECTURE  Isa;
+    EFI_GET_MAXIMUM_PROCESSOR_INDEX   GetMaximumProcessorIndex;
+    EFI_REGISTER_PERIODIC_CALLBACK    RegisterPeriodicCallback;
+    EFI_REGISTER_EXCEPTION_CALLBACK   RegisterExceptionCallback;
+    EFI_INVALIDATE_INSTRUCTION_CACHE  InvalidateInstructionCache;
+} EFI_DEBUG_SUPPORT_PROTOCOL;
+
+#endif

src/include/efi/efidef.h

@@ -0,0 +1,220 @@
+#ifndef _EFI_DEF_H
+#define _EFI_DEF_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efidef.h
+
+Abstract:
+
+    EFI definitions
+
+
+
+
+Revision History
+
+--*/
+
+typedef wchar_t         CHAR16;
+typedef char            CHAR8;
+typedef uint8_t         BOOLEAN;
+#ifndef CONST
+   #define CONST const
+#endif
+#ifndef TRUE
+    #define TRUE    ((BOOLEAN) 1)
+    #define FALSE   ((BOOLEAN) 0)
+#endif
+
+#ifndef NULL
+    #define NULL    ((VOID *) 0)
+#endif
+
+typedef UINTN           EFI_STATUS;
+typedef UINT64          EFI_LBA;
+typedef UINTN           EFI_TPL;
+typedef VOID            *EFI_HANDLE;
+typedef VOID            *EFI_EVENT;
+
+
+//
+// Prototype argument decoration for EFI parameters to indicate
+// their direction
+//
+// IN - argument is passed into the function
+// OUT - argument (pointer) is returned from the function
+// OPTIONAL - argument is optional
+//
+
+#ifndef IN
+    #define IN
+    #define OUT
+    #define OPTIONAL
+#endif
+
+
+//
+// A GUID
+//
+
+typedef struct {          
+    UINT32  Data1;
+    UINT16  Data2;
+    UINT16  Data3;
+    UINT8   Data4[8]; 
+} EFI_GUID;
+
+
+//
+// Time
+//
+
+typedef struct {          
+    UINT16      Year;       // 1998 - 20XX
+    UINT8       Month;      // 1 - 12
+    UINT8       Day;        // 1 - 31
+    UINT8       Hour;       // 0 - 23
+    UINT8       Minute;     // 0 - 59
+    UINT8       Second;     // 0 - 59
+    UINT8       Pad1;
+    UINT32      Nanosecond; // 0 - 999,999,999
+    INT16       TimeZone;   // -1440 to 1440 or 2047
+    UINT8       Daylight;
+    UINT8       Pad2;
+} EFI_TIME;
+
+// Bit definitions for EFI_TIME.Daylight
+#define EFI_TIME_ADJUST_DAYLIGHT    0x01
+#define EFI_TIME_IN_DAYLIGHT        0x02
+
+// Value definition for EFI_TIME.TimeZone
+#define EFI_UNSPECIFIED_TIMEZONE    0x07FF
+
+
+
+//
+// Networking
+//
+
+typedef struct {
+    UINT8                   Addr[4];
+} EFI_IPv4_ADDRESS;
+
+typedef struct {
+    UINT8                   Addr[16];
+} EFI_IPv6_ADDRESS;
+
+typedef struct {
+    UINT8                   Addr[32];
+} EFI_MAC_ADDRESS;
+
+typedef struct {
+    UINT32 ReceivedQueueTimeoutValue;
+    UINT32 TransmitQueueTimeoutValue;
+    UINT16 ProtocolTypeFilter;
+    BOOLEAN EnableUnicastReceive;
+    BOOLEAN EnableMulticastReceive;
+    BOOLEAN EnableBroadcastReceive;
+    BOOLEAN EnablePromiscuousReceive;
+    BOOLEAN FlushQueuesOnReset;
+    BOOLEAN EnableReceiveTimestamps;
+    BOOLEAN DisableBackgroundPolling;
+} EFI_MANAGED_NETWORK_CONFIG_DATA;
+
+//
+// Memory
+//
+
+typedef UINT64          EFI_PHYSICAL_ADDRESS;
+typedef UINT64          EFI_VIRTUAL_ADDRESS;
+
+typedef enum {
+    AllocateAnyPages,
+    AllocateMaxAddress,
+    AllocateAddress,
+    MaxAllocateType
+} EFI_ALLOCATE_TYPE;
+
+//Preseve the attr on any range supplied.
+//ConventialMemory must have WB,SR,SW when supplied.
+//When allocating from ConventialMemory always make it WB,SR,SW
+//When returning to ConventialMemory always make it WB,SR,SW
+//When getting the memory map, or on RT for runtime types
+
+
+typedef enum {
+    EfiReservedMemoryType,
+    EfiLoaderCode,
+    EfiLoaderData,
+    EfiBootServicesCode,
+    EfiBootServicesData,
+    EfiRuntimeServicesCode,
+    EfiRuntimeServicesData,
+    EfiConventionalMemory,
+    EfiUnusableMemory,
+    EfiACPIReclaimMemory,
+    EfiACPIMemoryNVS,
+    EfiMemoryMappedIO,
+    EfiMemoryMappedIOPortSpace,
+    EfiPalCode,
+    EfiMaxMemoryType
+} EFI_MEMORY_TYPE;
+
+// possible caching types for the memory range
+#define EFI_MEMORY_UC           0x0000000000000001
+#define EFI_MEMORY_WC           0x0000000000000002
+#define EFI_MEMORY_WT           0x0000000000000004
+#define EFI_MEMORY_WB           0x0000000000000008
+#define EFI_MEMORY_UCE          0x0000000000000010  
+
+// physical memory protection on range 
+#define EFI_MEMORY_WP           0x0000000000001000
+#define EFI_MEMORY_RP           0x0000000000002000
+#define EFI_MEMORY_XP           0x0000000000004000
+
+// range requires a runtime mapping
+#define EFI_MEMORY_RUNTIME      0x8000000000000000
+
+#define EFI_MEMORY_DESCRIPTOR_VERSION  1
+typedef struct {
+    UINT32                          Type;           // Field size is 32 bits followed by 32 bit pad
+    UINT32                          Pad;
+    EFI_PHYSICAL_ADDRESS            PhysicalStart;  // Field size is 64 bits
+    EFI_VIRTUAL_ADDRESS             VirtualStart;   // Field size is 64 bits
+    UINT64                          NumberOfPages;  // Field size is 64 bits
+    UINT64                          Attribute;      // Field size is 64 bits
+} EFI_MEMORY_DESCRIPTOR;
+
+//
+// International Language
+//
+
+typedef UINT8   ISO_639_2;
+#define ISO_639_2_ENTRY_SIZE    3
+
+//
+//
+//
+
+#define EFI_PAGE_SIZE   4096
+#define EFI_PAGE_MASK   0xFFF
+#define EFI_PAGE_SHIFT  12
+
+#define EFI_SIZE_TO_PAGES(a)  \
+    ( ((a) >> EFI_PAGE_SHIFT) + ((a) & EFI_PAGE_MASK ? 1 : 0) )
+
+#define EFI_OS_INDICATIONS_BOOT_TO_FW_UI        0x0000000000000001
+#define EFI_OS_INDICATIONS_TIMESTAMP_REVOCATION 0x0000000000000002
+#define EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED \
+                                                0x0000000000000004
+#define EFI_OS_INDICATIONS_FMP_CAPSULE_SUPPORTED \
+                                                0x0000000000000008
+#define EFI_OS_INDICATIONS_CAPSULE_RESULT_VAR_SUPPORTED \
+                                                0x0000000000000010
+
+#endif

src/include/efi/efidevp.h

@@ -0,0 +1,582 @@
+#ifndef _DEVPATH_H
+#define _DEVPATH_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    devpath.h
+
+Abstract:
+
+    Defines for parsing the EFI Device Path structures
+
+
+
+Revision History
+
+--*/
+
+//
+// Device Path structures - Section C
+//
+
+typedef struct _EFI_DEVICE_PATH_PROTOCOL {
+        UINT8                           Type;
+        UINT8                           SubType;
+        UINT8                           Length[2];
+} EFI_DEVICE_PATH_PROTOCOL;
+
+typedef struct _EFI_DEVICE_PATH_PROTOCOL _EFI_DEVICE_PATH;
+typedef EFI_DEVICE_PATH_PROTOCOL EFI_DEVICE_PATH;
+
+#define EFI_DP_TYPE_MASK                    0x7F
+#define EFI_DP_TYPE_UNPACKED                0x80
+
+//#define END_DEVICE_PATH_TYPE                0xff
+#define END_DEVICE_PATH_TYPE                0x7f
+//#define END_DEVICE_PATH_TYPE_UNPACKED       0x7f
+
+#define END_ENTIRE_DEVICE_PATH_SUBTYPE      0xff
+#define END_INSTANCE_DEVICE_PATH_SUBTYPE    0x01
+#define END_DEVICE_PATH_LENGTH              (sizeof(EFI_DEVICE_PATH_PROTOCOL))
+
+
+#define DP_IS_END_TYPE(a)
+#define DP_IS_END_SUBTYPE(a)        ( ((a)->SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE )
+
+#define DevicePathType(a)           ( ((a)->Type) & EFI_DP_TYPE_MASK )
+#define DevicePathSubType(a)        ( (a)->SubType )
+#define DevicePathNodeLength(a)     ( ((a)->Length[0]) | ((a)->Length[1] << 8) )
+#define NextDevicePathNode(a)       ( (EFI_DEVICE_PATH_PROTOCOL *) ( ((UINT8 *) (a)) + DevicePathNodeLength(a)))
+//#define IsDevicePathEndType(a)      ( DevicePathType(a) == END_DEVICE_PATH_TYPE_UNPACKED )
+#define IsDevicePathEndType(a)      ( DevicePathType(a) == END_DEVICE_PATH_TYPE )
+#define IsDevicePathEndSubType(a)   ( (a)->SubType == END_ENTIRE_DEVICE_PATH_SUBTYPE )
+#define IsDevicePathEnd(a)          ( IsDevicePathEndType(a) && IsDevicePathEndSubType(a) )
+#define IsDevicePathUnpacked(a)     ( (a)->Type & EFI_DP_TYPE_UNPACKED )
+
+
+#define SetDevicePathNodeLength(a,l) {                  \
+            (a)->Length[0] = (UINT8) (l);               \
+            (a)->Length[1] = (UINT8) ((l) >> 8);        \
+            }
+
+#define SetDevicePathEndNode(a)  {                      \
+            (a)->Type = END_DEVICE_PATH_TYPE;           \
+            (a)->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;     \
+            (a)->Length[0] = sizeof(EFI_DEVICE_PATH_PROTOCOL); \
+            (a)->Length[1] = 0;                         \
+            }
+
+
+/*
+ * Hardware Device Path (UEFI 2.4 specification, version 2.4 § 9.3.2.)
+ */
+
+#define HARDWARE_DEVICE_PATH            0x01
+
+#define HW_PCI_DP                       0x01
+typedef struct _PCI_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT8                           Function;
+        UINT8                           Device;
+} PCI_DEVICE_PATH;
+
+#define HW_PCCARD_DP                    0x02
+typedef struct _PCCARD_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT8                           FunctionNumber ;
+} PCCARD_DEVICE_PATH;
+
+#define HW_MEMMAP_DP                    0x03
+typedef struct _MEMMAP_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          MemoryType;
+        EFI_PHYSICAL_ADDRESS            StartingAddress;
+        EFI_PHYSICAL_ADDRESS            EndingAddress;
+} MEMMAP_DEVICE_PATH;
+
+#define HW_VENDOR_DP                    0x04
+typedef struct _VENDOR_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        EFI_GUID                        Guid;
+} VENDOR_DEVICE_PATH;
+
+#define UNKNOWN_DEVICE_GUID \
+    { 0xcf31fac5, 0xc24e, 0x11d2,  {0x85, 0xf3, 0x0, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b}  }
+
+typedef struct _UKNOWN_DEVICE_VENDOR_DP {
+    VENDOR_DEVICE_PATH      DevicePath;
+    UINT8                   LegacyDriveLetter;
+} UNKNOWN_DEVICE_VENDOR_DEVICE_PATH;
+
+#define HW_CONTROLLER_DP            0x05
+typedef struct _CONTROLLER_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL  Header;
+        UINT32                    Controller;
+} CONTROLLER_DEVICE_PATH;
+
+
+/*
+ * ACPI Device Path (UEFI 2.4 specification, version 2.4 § 9.3.3 and 9.3.4.)
+ */
+#define ACPI_DEVICE_PATH                 0x02
+
+#define ACPI_DP                         0x01
+typedef struct _ACPI_HID_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          HID;
+        UINT32                          UID;
+} ACPI_HID_DEVICE_PATH;
+
+#define EXPANDED_ACPI_DP		0x02
+typedef struct _EXPANDED_ACPI_HID_DEVICE_PATH {
+	EFI_DEVICE_PATH_PROTOCOL	Header;
+	UINT32				HID;
+	UINT32				UID;
+	UINT32				CID;
+	UINT8				HidStr[1];
+} EXPANDED_ACPI_HID_DEVICE_PATH;
+
+#define ACPI_ADR_DP 3
+typedef struct _ACPI_ADR_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    UINT32 ADR ;
+} ACPI_ADR_DEVICE_PATH ;
+
+//
+// EISA ID Macro
+// EISA ID Definition 32-bits
+//  bits[15:0] - three character compressed ASCII EISA ID.
+//  bits[31:16] - binary number
+//   Compressed ASCII is 5 bits per character 0b00001 = 'A' 0b11010 = 'Z'
+//
+#define PNP_EISA_ID_CONST       0x41d0
+#define EISA_ID(_Name, _Num)    ((UINT32) ((_Name) | (_Num) << 16))
+#define EISA_PNP_ID(_PNPId)     (EISA_ID(PNP_EISA_ID_CONST, (_PNPId)))
+
+#define PNP_EISA_ID_MASK        0xffff
+#define EISA_ID_TO_NUM(_Id)     ((_Id) >> 16)
+
+
+/*
+ * Messaging Device Path (UEFI 2.4 specification, version 2.4 § 9.3.5.)
+ */
+#define MESSAGING_DEVICE_PATH           0x03
+
+#define MSG_ATAPI_DP                    0x01
+typedef struct _ATAPI_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT8                           PrimarySecondary;
+        UINT8                           SlaveMaster;
+        UINT16                          Lun;
+} ATAPI_DEVICE_PATH;
+
+#define MSG_SCSI_DP                     0x02
+typedef struct _SCSI_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT16                          Pun;
+        UINT16                          Lun;
+} SCSI_DEVICE_PATH;
+
+#define MSG_FIBRECHANNEL_DP             0x03
+typedef struct _FIBRECHANNEL_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          Reserved;
+        UINT64                          WWN;
+        UINT64                          Lun;
+} FIBRECHANNEL_DEVICE_PATH;
+
+/**
+ * Fibre Channel Ex SubType.
+ * UEFI 2.0 specification version 2.4 § 9.3.5.6.
+ */
+#define MSG_FIBRECHANNELEX_DP 21
+typedef struct _FIBRECHANNELEX_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    UINT32 Reserved ;
+    UINT8 WWN[ 8 ] ; /* World Wide Name */
+    UINT8 Lun[ 8 ] ; /* Logical unit, T-10 SCSI Architecture Model 4 specification */
+} FIBRECHANNELEX_DEVICE_PATH ;
+
+#define MSG_1394_DP                     0x04
+typedef struct _F1394_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          Reserved;
+        UINT64                          Guid;
+} F1394_DEVICE_PATH;
+
+#define MSG_USB_DP                      0x05
+typedef struct _USB_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT8                           Port;
+        UINT8                           Endpoint;
+} USB_DEVICE_PATH;
+
+/**
+ * SATA Device Path SubType.
+ * UEFI 2.0 specification version 2.4 § 9.3.5.6.
+ */
+#define MSG_SATA_DP 18
+typedef struct _SATA_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    UINT16 HBAPortNumber ;
+    UINT16 PortMultiplierPortNumber ;
+    UINT16 Lun ; /* Logical Unit Number */
+} SATA_DEVICE_PATH ;
+
+/**
+ * USB WWID Device Path SubType.
+ * UEFI 2.0 specification version 2.4 § 9.3.5.7.
+ */
+#define MSG_USB_WWID_DP 16
+typedef struct _USB_WWID_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    UINT16 InterfaceNumber ;
+    UINT16 VendorId ;
+    UINT16 ProductId ;
+    CHAR16 SerialNumber[ 1 ] ; /* UTF-16 characters of the USB serial number */
+} USB_WWID_DEVICE_PATH ;
+
+/**
+ * Device Logical Unit SubType.
+ * UEFI 2.0 specification version 2.4 § 9.3.5.8.
+ */
+#define MSG_DEVICE_LOGICAL_UNIT_DP 17
+typedef struct _DEVICE_LOGICAL_UNIT_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    UINT8 Lun ; /* Logical Unit Number */
+} DEVICE_LOGICAL_UNIT_DEVICE_PATH ;
+
+#define MSG_USB_CLASS_DP                0x0F
+typedef struct _USB_CLASS_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT16                          VendorId;
+        UINT16                          ProductId;
+        UINT8                           DeviceClass;
+        UINT8                           DeviceSubclass;
+        UINT8                           DeviceProtocol;
+} USB_CLASS_DEVICE_PATH;
+
+#define MSG_I2O_DP                      0x06
+typedef struct _I2O_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          Tid;
+} I2O_DEVICE_PATH;
+
+#define MSG_MAC_ADDR_DP                 0x0b
+typedef struct _MAC_ADDR_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        EFI_MAC_ADDRESS                 MacAddress;
+        UINT8                           IfType;
+} MAC_ADDR_DEVICE_PATH;
+
+#define MSG_IPv4_DP                     0x0c
+typedef struct _IPv4_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        EFI_IPv4_ADDRESS                LocalIpAddress;
+        EFI_IPv4_ADDRESS                RemoteIpAddress;
+        UINT16                          LocalPort;
+        UINT16                          RemotePort;
+        UINT16                          Protocol;
+        BOOLEAN                         StaticIpAddress;
+        /* new from UEFI version 2, code must check Length field in Header */
+        EFI_IPv4_ADDRESS                GatewayIpAddress ;
+        EFI_IPv4_ADDRESS                SubnetMask ;
+} IPv4_DEVICE_PATH;
+
+#define MSG_IPv6_DP                     0x0d
+typedef struct _IPv6_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        EFI_IPv6_ADDRESS                LocalIpAddress;
+        EFI_IPv6_ADDRESS                RemoteIpAddress;
+        UINT16                          LocalPort;
+        UINT16                          RemotePort;
+        UINT16                          Protocol;
+        BOOLEAN                         IPAddressOrigin ;
+        /* new from UEFI version 2, code must check Length field in Header */
+        UINT8                           PrefixLength ;
+        EFI_IPv6_ADDRESS                GatewayIpAddress ;
+} IPv6_DEVICE_PATH;
+
+
+/**
+ * Uniform Resource Identifiers SubType.
+ * UEFI 2.0 specification version 2.4C § 9.3.5.23.
+ */
+#define MSG_URI_DP                      24
+typedef struct _URI_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        CHAR8                           Uri[1];
+} URI_DEVICE_PATH;
+
+/**
+ * Device Logical Unit SubType.
+ * UEFI 2.0 specification version 2.4 § 9.3.5.8.
+ */
+#define MSG_VLAN_DP 20
+typedef struct _VLAN_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    UINT16 VlanId ;
+} VLAN_DEVICE_PATH;
+
+#define MSG_INFINIBAND_DP               0x09
+typedef struct _INFINIBAND_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          ResourceFlags ;
+        UINT64                          PortGid ;
+        UINT64                          ServiceId ;
+        UINT64                          TargetPortId ;
+        UINT64                          DeviceId ;
+} INFINIBAND_DEVICE_PATH;
+
+#define MSG_UART_DP                     0x0e
+typedef struct _UART_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          Reserved;
+        UINT64                          BaudRate;
+        UINT8                           DataBits;
+        UINT8                           Parity;
+        UINT8                           StopBits;
+} UART_DEVICE_PATH;
+
+#define MSG_VENDOR_DP                   0x0A
+/* Use VENDOR_DEVICE_PATH struct */
+
+#define EFI_PC_ANSI_GUID \
+    { 0xe0c14753, 0xf9be, 0x11d2, {0x9a, 0x0c, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+#define DEVICE_PATH_MESSAGING_PC_ANSI EFI_PC_ANSI_GUID
+
+#define EFI_VT_100_GUID \
+    { 0xdfa66065, 0xb419, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+#define DEVICE_PATH_MESSAGING_VT_100 EFI_VT_100_GUID
+
+#define EFI_VT_100_PLUS_GUID \
+    { 0x7baec70b, 0x57e0, 0x4c76, {0x8e, 0x87, 0x2f, 0x9e, 0x28, 0x08, 0x83, 0x43} }
+#define DEVICE_PATH_MESSAGING_VT_100_PLUS EFI_VT_100_PLUS_GUID
+
+#define EFI_VT_UTF8_GUID \
+    { 0xad15a0d6, 0x8bec, 0x4acf, {0xa0, 0x73, 0xd0, 0x1d, 0xe7, 0x7e, 0x2d, 0x88} }
+#define DEVICE_PATH_MESSAGING_VT_UTF8 EFI_VT_UTF8_GUID
+
+
+/*
+ * Media Device Path (UEFI 2.4 specification, version 2.4 § 9.3.6.)
+ */
+#define MEDIA_DEVICE_PATH               0x04
+
+#define MEDIA_HARDDRIVE_DP              0x01
+typedef struct _HARDDRIVE_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          PartitionNumber;
+        UINT64                          PartitionStart;
+        UINT64                          PartitionSize;
+        UINT8                           Signature[16];
+        UINT8                           MBRType;
+        UINT8                           SignatureType;
+} HARDDRIVE_DEVICE_PATH;
+
+#define MBR_TYPE_PCAT                       0x01
+#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02
+
+#define SIGNATURE_TYPE_MBR                  0x01
+#define SIGNATURE_TYPE_GUID                 0x02
+
+#define MEDIA_CDROM_DP                  0x02
+typedef struct _CDROM_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT32                          BootEntry;
+        UINT64                          PartitionStart;
+        UINT64                          PartitionSize;
+} CDROM_DEVICE_PATH;
+
+#define MEDIA_VENDOR_DP                 0x03
+/* Use VENDOR_DEVICE_PATH struct */
+
+#define MEDIA_FILEPATH_DP               0x04
+typedef struct _FILEPATH_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        CHAR16                          PathName[1];
+} FILEPATH_DEVICE_PATH;
+
+#define SIZE_OF_FILEPATH_DEVICE_PATH EFI_FIELD_OFFSET(FILEPATH_DEVICE_PATH,PathName)
+
+#define MEDIA_PROTOCOL_DP               0x05
+typedef struct _MEDIA_PROTOCOL_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        EFI_GUID                        Protocol;
+} MEDIA_PROTOCOL_DEVICE_PATH;
+
+/**
+ * PIWG Firmware File SubType.
+ * UEFI 2.0 specification version 2.4 § 9.3.6.6.
+ */
+#define MEDIA_PIWG_FW_FILE_DP 6
+typedef struct _MEDIA_FW_VOL_FILEPATH_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    EFI_GUID FvFileName ;
+} MEDIA_FW_VOL_FILEPATH_DEVICE_PATH ;
+
+/**
+ * PIWG Firmware Volume Device Path SubType.
+ * UEFI 2.0 specification version 2.4 § 9.3.6.7.
+ */
+#define MEDIA_PIWG_FW_VOL_DP 7
+typedef struct _MEDIA_FW_VOL_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    EFI_GUID FvName ;
+} MEDIA_FW_VOL_DEVICE_PATH ;
+
+/**
+ * Media relative offset range device path.
+ * UEFI 2.0 specification version 2.4 § 9.3.6.8.
+ */
+#define MEDIA_RELATIVE_OFFSET_RANGE_DP 8
+typedef struct _MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH {
+    EFI_DEVICE_PATH_PROTOCOL Header ;
+    UINT32 Reserved ;
+    UINT64 StartingOffset ;
+    UINT64 EndingOffset ;
+} MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH ;
+
+
+/*
+ * BIOS Boot Specification Device Path (UEFI 2.4 specification, version 2.4 § 9.3.7.)
+ */
+#define BBS_DEVICE_PATH                 0x05
+
+#define BBS_BBS_DP                      0x01
+typedef struct _BBS_BBS_DEVICE_PATH {
+        EFI_DEVICE_PATH_PROTOCOL        Header;
+        UINT16                          DeviceType;
+        UINT16                          StatusFlag;
+        CHAR8                           String[1];
+} BBS_BBS_DEVICE_PATH;
+
+/* DeviceType definitions - from BBS specification */
+#define BBS_TYPE_FLOPPY                 0x01
+#define BBS_TYPE_HARDDRIVE              0x02
+#define BBS_TYPE_CDROM                  0x03
+#define BBS_TYPE_PCMCIA                 0x04
+#define BBS_TYPE_USB                    0x05
+#define BBS_TYPE_EMBEDDED_NETWORK       0x06
+#define BBS_TYPE_DEV                    0x80
+#define BBS_TYPE_UNKNOWN                0xFF
+
+typedef union {
+    EFI_DEVICE_PATH_PROTOCOL             DevPath;
+    PCI_DEVICE_PATH                      Pci;
+    PCCARD_DEVICE_PATH                   PcCard;
+    MEMMAP_DEVICE_PATH                   MemMap;
+    VENDOR_DEVICE_PATH                   Vendor;
+    UNKNOWN_DEVICE_VENDOR_DEVICE_PATH    UnknownVendor;
+    CONTROLLER_DEVICE_PATH               Controller;
+    ACPI_HID_DEVICE_PATH                 Acpi;
+
+    ATAPI_DEVICE_PATH                    Atapi;
+    SCSI_DEVICE_PATH                     Scsi;
+    FIBRECHANNEL_DEVICE_PATH             FibreChannel;
+
+    F1394_DEVICE_PATH                    F1394;
+    USB_DEVICE_PATH                      Usb;
+    USB_CLASS_DEVICE_PATH                UsbClass;
+    I2O_DEVICE_PATH                      I2O;
+    MAC_ADDR_DEVICE_PATH                 MacAddr;
+    IPv4_DEVICE_PATH                     Ipv4;
+    IPv6_DEVICE_PATH                     Ipv6;
+    URI_DEVICE_PATH                      Uri;
+    INFINIBAND_DEVICE_PATH               InfiniBand;
+    UART_DEVICE_PATH                     Uart;
+
+    HARDDRIVE_DEVICE_PATH                HardDrive;
+    CDROM_DEVICE_PATH                    CD;
+
+    FILEPATH_DEVICE_PATH                 FilePath;
+    MEDIA_PROTOCOL_DEVICE_PATH           MediaProtocol;
+
+    BBS_BBS_DEVICE_PATH                  Bbs;
+
+} EFI_DEV_PATH;
+
+typedef union {
+    EFI_DEVICE_PATH_PROTOCOL             *DevPath;
+    PCI_DEVICE_PATH                      *Pci;
+    PCCARD_DEVICE_PATH                   *PcCard;
+    MEMMAP_DEVICE_PATH                   *MemMap;
+    VENDOR_DEVICE_PATH                   *Vendor;
+    UNKNOWN_DEVICE_VENDOR_DEVICE_PATH    *UnknownVendor;
+    CONTROLLER_DEVICE_PATH               *Controller;
+    ACPI_HID_DEVICE_PATH                 *Acpi;
+
+    ATAPI_DEVICE_PATH                    *Atapi;
+    SCSI_DEVICE_PATH                     *Scsi;
+    FIBRECHANNEL_DEVICE_PATH             *FibreChannel;
+
+    F1394_DEVICE_PATH                    *F1394;
+    USB_DEVICE_PATH                      *Usb;
+    USB_CLASS_DEVICE_PATH                *UsbClass;
+    I2O_DEVICE_PATH                      *I2O;
+    MAC_ADDR_DEVICE_PATH                 *MacAddr;
+    IPv4_DEVICE_PATH                     *Ipv4;
+    IPv6_DEVICE_PATH                     *Ipv6;
+    URI_DEVICE_PATH                      *Uri;
+    INFINIBAND_DEVICE_PATH               *InfiniBand;
+    UART_DEVICE_PATH                     *Uart;
+
+    HARDDRIVE_DEVICE_PATH                *HardDrive;
+
+    FILEPATH_DEVICE_PATH                 *FilePath;
+    MEDIA_PROTOCOL_DEVICE_PATH           *MediaProtocol;
+
+    CDROM_DEVICE_PATH                    *CD;
+    BBS_BBS_DEVICE_PATH                  *Bbs;
+
+} EFI_DEV_PATH_PTR;
+
+#define EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID \
+  { 0x8b843e20, 0x8132, 0x4852, {0x90, 0xcc, 0x55, 0x1a, 0x4e, 0x4a, 0x7f, 0x1c} }
+
+typedef
+CHAR16*
+(EFIAPI *EFI_DEVICE_PATH_TO_TEXT_NODE) (
+    IN CONST EFI_DEVICE_PATH_PROTOCOL    *DeviceNode,
+    IN BOOLEAN                           DisplayOnly,
+    IN BOOLEAN                           AllowShortcuts
+    );
+
+typedef
+CHAR16*
+(EFIAPI *EFI_DEVICE_PATH_TO_TEXT_PATH) (
+    IN CONST EFI_DEVICE_PATH_PROTOCOL    *DevicePath,
+    IN BOOLEAN                           DisplayOnly,
+    IN BOOLEAN                           AllowShortcuts
+    );
+
+typedef struct _EFI_DEVICE_PATH_TO_TEXT_PROTOCOL {
+	EFI_DEVICE_PATH_TO_TEXT_NODE         ConvertDeviceNodeToText;
+	EFI_DEVICE_PATH_TO_TEXT_PATH         ConvertDevicePathToText;
+} EFI_DEVICE_PATH_TO_TEXT_PROTOCOL;
+
+#define EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL_GUID \
+  { 0x5c99a21, 0xc70f, 0x4ad2, {0x8a, 0x5f, 0x35, 0xdf, 0x33, 0x43, 0xf5, 0x1e} }
+
+typedef
+EFI_DEVICE_PATH_PROTOCOL*
+(EFIAPI *EFI_DEVICE_PATH_FROM_TEXT_NODE) (
+    IN CONST CHAR16                      *TextDeviceNode
+    );
+
+typedef
+EFI_DEVICE_PATH_PROTOCOL*
+(EFIAPI *EFI_DEVICE_PATH_FROM_TEXT_PATH) (
+    IN CONST CHAR16                      *TextDevicePath
+    );
+
+typedef struct {
+    EFI_DEVICE_PATH_FROM_TEXT_NODE       ConvertTextToDeviceNode;
+    EFI_DEVICE_PATH_FROM_TEXT_PATH       ConvertTextToDevicePath;
+} EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL;
+
+#endif

src/include/efi/efierr.h

@@ -0,0 +1,67 @@
+#ifndef _EFI_ERR_H
+#define _EFI_ERR_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efierr.h
+
+Abstract:
+
+    EFI error codes
+
+
+
+
+Revision History
+
+--*/
+
+
+#define EFIWARN(a)                            (a)
+#define EFI_ERROR(a)              (((INTN) a) < 0)
+
+
+#define EFI_SUCCESS                             0
+#define EFI_LOAD_ERROR                  EFIERR(1)
+#define EFI_INVALID_PARAMETER           EFIERR(2)
+#define EFI_UNSUPPORTED                 EFIERR(3)
+#define EFI_BAD_BUFFER_SIZE             EFIERR(4)
+#define EFI_BUFFER_TOO_SMALL            EFIERR(5)
+#define EFI_NOT_READY                   EFIERR(6)
+#define EFI_DEVICE_ERROR                EFIERR(7)
+#define EFI_WRITE_PROTECTED             EFIERR(8)
+#define EFI_OUT_OF_RESOURCES            EFIERR(9)
+#define EFI_VOLUME_CORRUPTED            EFIERR(10)
+#define EFI_VOLUME_FULL                 EFIERR(11)
+#define EFI_NO_MEDIA                    EFIERR(12)
+#define EFI_MEDIA_CHANGED               EFIERR(13)
+#define EFI_NOT_FOUND                   EFIERR(14)
+#define EFI_ACCESS_DENIED               EFIERR(15)
+#define EFI_NO_RESPONSE                 EFIERR(16)
+#define EFI_NO_MAPPING                  EFIERR(17)
+#define EFI_TIMEOUT                     EFIERR(18)
+#define EFI_NOT_STARTED                 EFIERR(19)
+#define EFI_ALREADY_STARTED             EFIERR(20)
+#define EFI_ABORTED                     EFIERR(21)
+#define EFI_ICMP_ERROR                  EFIERR(22)
+#define EFI_TFTP_ERROR                  EFIERR(23)
+#define EFI_PROTOCOL_ERROR              EFIERR(24)
+#define EFI_INCOMPATIBLE_VERSION        EFIERR(25)
+#define EFI_SECURITY_VIOLATION          EFIERR(26)
+#define EFI_CRC_ERROR                   EFIERR(27)
+#define EFI_END_OF_MEDIA                EFIERR(28)
+#define EFI_END_OF_FILE                 EFIERR(31)
+#define EFI_INVALID_LANGUAGE            EFIERR(32)
+#define EFI_COMPROMISED_DATA            EFIERR(33)
+
+#define EFI_WARN_UNKOWN_GLYPH           EFIWARN(1)
+#define EFI_WARN_DELETE_FAILURE         EFIWARN(2)
+#define EFI_WARN_WRITE_FAILURE          EFIWARN(3)
+#define EFI_WARN_BUFFER_TOO_SMALL       EFIWARN(4)
+
+#endif
+

src/include/efi/efifs.h

@@ -0,0 +1,116 @@
+#ifndef _EFI_FS_H
+#define _EFI_FS_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efifs.h
+
+Abstract:
+
+    EFI File System structures
+
+
+
+Revision History
+
+--*/
+
+
+//
+// EFI Partition header (normaly starts in LBA 1)
+//
+
+#define EFI_PARTITION_SIGNATURE         0x5053595320494249
+#define EFI_PARTITION_REVISION          0x00010001
+#define MIN_EFI_PARTITION_BLOCK_SIZE    512
+#define EFI_PARTITION_LBA               1
+
+typedef struct _EFI_PARTITION_HEADER {
+    EFI_TABLE_HEADER    Hdr;
+    UINT32              DirectoryAllocationNumber;
+    UINT32              BlockSize;
+    EFI_LBA             FirstUsableLba;
+    EFI_LBA             LastUsableLba;
+    EFI_LBA             UnusableSpace;
+    EFI_LBA             FreeSpace;
+    EFI_LBA             RootFile;
+    EFI_LBA             SecutiryFile;
+} EFI_PARTITION_HEADER;
+
+
+//
+// File header
+//
+
+#define EFI_FILE_HEADER_SIGNATURE   0x454c494620494249
+#define EFI_FILE_HEADER_REVISION    0x00010000
+#define EFI_FILE_STRING_SIZE        260
+
+typedef struct _EFI_FILE_HEADER {
+    EFI_TABLE_HEADER    Hdr;
+    UINT32              Class;
+    UINT32              LBALOffset;
+    EFI_LBA             Parent;
+    UINT64              FileSize;
+    UINT64              FileAttributes;
+    EFI_TIME            FileCreateTime;
+    EFI_TIME            FileModificationTime;
+    EFI_GUID            VendorGuid;
+    CHAR16              FileString[EFI_FILE_STRING_SIZE];
+} EFI_FILE_HEADER;
+
+
+//
+// Return the file's first LBAL which is in the same
+// logical block as the file header
+//
+
+#define EFI_FILE_LBAL(a)    ((EFI_LBAL *) (((CHAR8 *) (a)) + (a)->LBALOffset))
+
+#define EFI_FILE_CLASS_FREE_SPACE   1
+#define EFI_FILE_CLASS_EMPTY        2
+#define EFI_FILE_CLASS_NORMAL       3
+
+
+//
+// Logical Block Address List - the fundemental block
+// description structure
+//
+
+#define EFI_LBAL_SIGNATURE      0x4c41424c20494249
+#define EFI_LBAL_REVISION       0x00010000
+
+typedef struct _EFI_LBAL {
+    EFI_TABLE_HEADER    Hdr;
+    UINT32              Class;
+    EFI_LBA             Parent;
+    EFI_LBA             Next;
+    UINT32              ArraySize;
+    UINT32              ArrayCount;
+} EFI_LBAL;
+
+// Array size 
+#define EFI_LBAL_ARRAY_SIZE(lbal,offs,blks)  \
+        (((blks) - (offs) - (lbal)->Hdr.HeaderSize) / sizeof(EFI_RL))
+
+//
+// Logical Block run-length
+//
+
+typedef struct {
+    EFI_LBA     Start;
+    UINT64      Length;
+} EFI_RL;
+
+//
+// Return the run-length structure from an LBAL header
+//
+
+#define EFI_LBAL_RL(a)      ((EFI_RL*) (((CHAR8 *) (a)) + (a)->Hdr.HeaderSize))
+
+#endif
+

src/include/efi/efigpt.h

@@ -0,0 +1,68 @@
+#ifndef _EFI_GPT_H
+#define _EFI_GPT_H
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    EfiGpt.h
+    
+Abstract:
+    Include file for EFI partitioning scheme
+
+
+
+Revision History
+
+--*/
+
+#define PRIMARY_PART_HEADER_LBA         1
+
+typedef struct {
+    EFI_TABLE_HEADER    Header;
+    EFI_LBA             MyLBA;
+    EFI_LBA             AlternateLBA;
+    EFI_LBA             FirstUsableLBA;
+    EFI_LBA             LastUsableLBA;
+    EFI_GUID            DiskGUID;
+    EFI_LBA             PartitionEntryLBA;
+    UINT32              NumberOfPartitionEntries;
+    UINT32              SizeOfPartitionEntry;
+    UINT32              PartitionEntryArrayCRC32;
+} EFI_PARTITION_TABLE_HEADER;
+
+#define EFI_PTAB_HEADER_ID  "EFI PART"
+
+typedef struct {
+    EFI_GUID    PartitionTypeGUID;
+    EFI_GUID    UniquePartitionGUID;
+    EFI_LBA     StartingLBA;
+    EFI_LBA     EndingLBA;
+    UINT64      Attributes;
+    CHAR16      PartitionName[36];
+} EFI_PARTITION_ENTRY;
+
+//
+// EFI Partition Attributes
+//
+#define EFI_PART_USED_BY_EFI            0x0000000000000001
+#define EFI_PART_REQUIRED_TO_FUNCTION   0x0000000000000002
+#define EFI_PART_USED_BY_OS             0x0000000000000004
+#define EFI_PART_REQUIRED_BY_OS         0x0000000000000008
+#define EFI_PART_BACKUP_REQUIRED        0x0000000000000010
+#define EFI_PART_USER_DATA              0x0000000000000020
+#define EFI_PART_CRITICAL_USER_DATA     0x0000000000000040
+#define EFI_PART_REDUNDANT_PARTITION    0x0000000000000080
+
+#define EFI_PART_TYPE_UNUSED_GUID   \
+    { 0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} }
+    
+#define EFI_PART_TYPE_EFI_SYSTEM_PART_GUID  \
+    { 0xc12a7328, 0xf81f, 0x11d2, {0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b} }
+
+#define EFI_PART_TYPE_LEGACY_MBR_GUID   \
+    { 0x024dee41, 0x33e7, 0x11d3, {0x9d, 0x69, 0x00, 0x08, 0xc7, 0x81, 0xf3, 0x9f} }
+
+#endif
+

src/include/efi/efiip.h

@@ -0,0 +1,459 @@
+#ifndef _EFI_IP_H
+#define _EFI_IP_H
+
+/*++
+Copyright (c) 2013  Intel Corporation
+
+--*/
+
+#define EFI_IP4_SERVICE_BINDING_PROTOCOL \
+   {0xc51711e7,0xb4bf,0x404a,{0xbf,0xb8,0x0a,0x04, 0x8e,0xf1,0xff,0xe4}}
+
+#define EFI_IP4_PROTOCOL \
+    {0x41d94cd2,0x35b6,0x455a,{0x82,0x58,0xd4,0xe5,0x13,0x34,0xaa,0xdd}}
+
+#define EFI_IP6_SERVICE_BINDING_PROTOCOL \
+    {0xec835dd3,0xfe0f,0x617b,{0xa6,0x21,0xb3,0x50,0xc3,0xe1,0x33,0x88}}
+
+#define EFI_IP6_PROTOCOL \
+    {0x2c8759d5,0x5c2d,0x66ef,{0x92,0x5f,0xb6,0x6c,0x10,0x19,0x57,0xe2}}
+
+INTERFACE_DECL(_EFI_IP4);
+INTERFACE_DECL(_EFI_IP6);
+
+typedef struct {
+    EFI_HANDLE       InstanceHandle;
+    EFI_IPv4_ADDRESS Ip4Address;
+    EFI_IPv4_ADDRESS SubnetMask;
+} EFI_IP4_ADDRESS_PAIR;
+
+typedef struct {
+    EFI_HANDLE           DriverHandle;
+    UINT32               AddressCount;
+    EFI_IP4_ADDRESS_PAIR AddressPairs[1];
+} EFI_IP4_VARIABLE_DATA;
+
+typedef struct {
+    UINT8            DefaultProtocol;
+    BOOLEAN          AcceptAnyProtocol;
+    BOOLEAN          AcceptIcmpErrors;
+    BOOLEAN          AcceptBroadcast;
+    BOOLEAN          AcceptPromiscuous;
+    BOOLEAN          UseDefaultAddress;
+    EFI_IPv4_ADDRESS StationAddress;
+    EFI_IPv4_ADDRESS SubnetMask;
+    UINT8            TypeOfService;
+    UINT8            TimeToLive;
+    BOOLEAN          DoNotFragment;
+    BOOLEAN          RawData;
+    UINT32           ReceiveTimeout;
+    UINT32           TransmitTimeout;
+} EFI_IP4_CONFIG_DATA;
+
+typedef struct {
+    EFI_IPv4_ADDRESS SubnetAddress;
+    EFI_IPv4_ADDRESS SubnetMask;
+    EFI_IPv4_ADDRESS GatewayAddress;
+} EFI_IP4_ROUTE_TABLE;
+
+typedef struct {
+    UINT8 Type;
+    UINT8 Code;
+} EFI_IP4_ICMP_TYPE;
+
+typedef struct {
+    BOOLEAN             IsStarted;
+    UINT32              MaxPacketSize;
+    EFI_IP4_CONFIG_DATA ConfigData;
+    BOOLEAN             IsConfigured;
+    UINT32              GroupCount;
+    EFI_IPv4_ADDRESS    *GroupTable;
+    UINT32              RouteCount;
+    EFI_IP4_ROUTE_TABLE *RouteTable;
+    UINT32              IcmpTypeCount;
+    EFI_IP4_ICMP_TYPE   *IcmpTypeList;
+} EFI_IP4_MODE_DATA;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_GET_MODE_DATA) (
+    IN struct _EFI_IP4                  *This,
+    OUT EFI_IP4_MODE_DATA               *Ip4ModeData   OPTIONAL,
+    OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL,
+    OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData   OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CONFIGURE) (
+    IN struct _EFI_IP4     *This,
+    IN EFI_IP4_CONFIG_DATA *IpConfigData OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_GROUPS) (
+    IN struct _EFI_IP4  *This,
+    IN BOOLEAN          JoinFlag,
+    IN EFI_IPv4_ADDRESS *GroupAddress OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_ROUTES) (
+    IN struct _EFI_IP4  *This,
+    IN BOOLEAN          DeleteRoute,
+    IN EFI_IPv4_ADDRESS *SubnetAddress,
+    IN EFI_IPv4_ADDRESS *SubnetMask,
+    IN EFI_IPv4_ADDRESS *GatewayAddress
+    );
+
+#pragma pack(1)
+typedef struct {
+    UINT8            HeaderLength:4;
+    UINT8            Version:4;
+    UINT8            TypeOfService;
+    UINT16           TotalLength;
+    UINT16           Identification;
+    UINT16           Fragmentation;
+    UINT8            TimeToLive;
+    UINT8            Protocol;
+    UINT16           Checksum;
+    EFI_IPv4_ADDRESS SourceAddress;
+    EFI_IPv4_ADDRESS DestinationAddress;
+} EFI_IP4_HEADER;
+#pragma pack()
+
+typedef struct {
+    UINT32 FragmentLength;
+    VOID   *FragmentBuffer;
+} EFI_IP4_FRAGMENT_DATA;
+
+typedef struct {
+    EFI_TIME              TimeStamp;
+    EFI_EVENT             RecycleSignal;
+    UINT32                HeaderLength;
+    EFI_IP4_HEADER        *Header;
+    UINT32                OptionsLength;
+    VOID                  *Options;
+    UINT32                DataLength;
+    UINT32                FragmentCount;
+    EFI_IP4_FRAGMENT_DATA FragmentTable[1];
+} EFI_IP4_RECEIVE_DATA;
+
+typedef struct {
+    EFI_IPv4_ADDRESS SourceAddress;
+    EFI_IPv4_ADDRESS GatewayAddress;
+    UINT8            Protocol;
+    UINT8            TypeOfService;
+    UINT8            TimeToLive;
+    BOOLEAN          DoNotFragment;
+} EFI_IP4_OVERRIDE_DATA;
+
+typedef struct {
+    EFI_IPv4_ADDRESS      DestinationAddress;
+    EFI_IP4_OVERRIDE_DATA *OverrideData;
+    UINT32                OptionsLength;
+    VOID                  *OptionsBuffer;
+    UINT32                TotalDataLength;
+    UINT32                FragmentCount;
+    EFI_IP4_FRAGMENT_DATA FragmentTable[1];
+} EFI_IP4_TRANSMIT_DATA;
+
+typedef struct {
+    EFI_EVENT                 Event;
+    EFI_STATUS                Status;
+    union {
+        EFI_IP4_RECEIVE_DATA  *RxData;
+        EFI_IP4_TRANSMIT_DATA *TxData;
+    } Packet;
+} EFI_IP4_COMPLETION_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_TRANSMIT) (
+    IN struct _EFI_IP4          *This,
+    IN EFI_IP4_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_RECEIVE) (
+    IN struct _EFI_IP4          *This,
+    IN EFI_IP4_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_CANCEL)(
+    IN struct _EFI_IP4          *This,
+    IN EFI_IP4_COMPLETION_TOKEN *Token OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP4_POLL) (
+    IN struct _EFI_IP4 *This
+    );
+
+typedef struct _EFI_IP4 {
+    EFI_IP4_GET_MODE_DATA GetModeData;
+    EFI_IP4_CONFIGURE     Configure;
+    EFI_IP4_GROUPS        Groups;
+    EFI_IP4_ROUTES        Routes;
+    EFI_IP4_TRANSMIT      Transmit;
+    EFI_IP4_RECEIVE       Receive;
+    EFI_IP4_CANCEL        Cancel;
+    EFI_IP4_POLL          Poll;
+} EFI_IP4;
+
+typedef struct {
+    UINT8            DefaultProtocol;
+    BOOLEAN          AcceptAnyProtocol;
+    BOOLEAN          AcceptIcmpErrors;
+    BOOLEAN          AcceptPromiscuous;
+    EFI_IPv6_ADDRESS DestinationAddress;
+    EFI_IPv6_ADDRESS StationAddress;
+    UINT8            TrafficClass;
+    UINT8            HopLimit;
+    UINT32           FlowLabel;
+    UINT32           ReceiveTimeout;
+    UINT32           TransmitTimeout;
+} EFI_IP6_CONFIG_DATA;
+
+typedef struct {
+    EFI_IPv6_ADDRESS Address;
+    UINT8            PrefixLength;
+} EFI_IP6_ADDRESS_INFO;
+
+typedef struct {
+    EFI_IPv6_ADDRESS Gateway;
+    EFI_IPv6_ADDRESS Destination;
+    UINT8            PrefixLength;
+} EFI_IP6_ROUTE_TABLE;
+
+typedef enum {
+    EfiNeighborInComplete,
+    EfiNeighborReachable,
+    EfiNeighborStale,
+    EfiNeighborDelay,
+    EfiNeighborProbe
+} EFI_IP6_NEIGHBOR_STATE;
+
+typedef struct {
+    EFI_IPv6_ADDRESS       Neighbor;
+    EFI_MAC_ADDRESS        LinkAddress;
+    EFI_IP6_NEIGHBOR_STATE State;
+} EFI_IP6_NEIGHBOR_CACHE;
+
+typedef struct {
+    UINT8 Type;
+    UINT8 Code;
+} EFI_IP6_ICMP_TYPE;
+
+//***********************************************************
+// ICMPv6 type definitions for error messages
+//***********************************************************
+#define ICMP_V6_DEST_UNREACHABLE     0x1
+#define ICMP_V6_PACKET_TOO_BIG       0x2
+#define ICMP_V6_TIME_EXCEEDED        0x3
+#define ICMP_V6_PARAMETER_PROBLEM    0x4
+
+//***********************************************************
+// ICMPv6 type definition for informational messages
+//***********************************************************
+#define ICMP_V6_ECHO_REQUEST         0x80
+#define ICMP_V6_ECHO_REPLY           0x81
+#define ICMP_V6_LISTENER_QUERY       0x82
+#define ICMP_V6_LISTENER_REPORT      0x83
+#define ICMP_V6_LISTENER_DONE        0x84
+#define ICMP_V6_ROUTER_SOLICIT       0x85
+#define ICMP_V6_ROUTER_ADVERTISE     0x86
+#define ICMP_V6_NEIGHBOR_SOLICIT     0x87
+#define ICMP_V6_NEIGHBOR_ADVERTISE   0x88
+#define ICMP_V6_REDIRECT             0x89
+#define ICMP_V6_LISTENER_REPORT_2    0x8F
+
+//***********************************************************
+// ICMPv6 code definitions for ICMP_V6_DEST_UNREACHABLE
+//***********************************************************
+#define ICMP_V6_NO_ROUTE_TO_DEST     0x0
+#define ICMP_V6_COMM_PROHIBITED      0x1
+#define ICMP_V6_BEYOND_SCOPE         0x2
+#define ICMP_V6_ADDR_UNREACHABLE     0x3
+#define ICMP_V6_PORT_UNREACHABLE     0x4
+#define ICMP_V6_SOURCE_ADDR_FAILED   0x5
+#define ICMP_V6_ROUTE_REJECTED       0x6
+
+//***********************************************************
+// ICMPv6 code definitions for ICMP_V6_TIME_EXCEEDED
+//***********************************************************
+#define ICMP_V6_TIMEOUT_HOP_LIMIT    0x0
+#define ICMP_V6_TIMEOUT_REASSEMBLE   0x1
+
+//***********************************************************
+// ICMPv6 code definitions for ICMP_V6_PARAMETER_PROBLEM
+//***********************************************************
+#define ICMP_V6_ERRONEOUS_HEADER     0x0
+#define ICMP_V6_UNRECOGNIZE_NEXT_HDR 0x1
+#define ICMP_V6_UNRECOGNIZE_OPTION   0x2
+
+typedef struct {
+    BOOLEAN                IsStarted;
+    UINT32                 MaxPacketSize;
+    EFI_IP6_CONFIG_DATA    ConfigData;
+    BOOLEAN                IsConfigured;
+    UINT32                 AddressCount;
+    EFI_IP6_ADDRESS_INFO   *AddressList;
+    UINT32                 GroupCount;
+    EFI_IPv6_ADDRESS       *GroupTable;
+    UINT32                 RouteCount;
+    EFI_IP6_ROUTE_TABLE    *RouteTable;
+    UINT32                 NeighborCount;
+    EFI_IP6_NEIGHBOR_CACHE *NeighborCache;
+    UINT32                 PrefixCount;
+    EFI_IP6_ADDRESS_INFO   *PrefixTable;
+    UINT32                 IcmpTypeCount;
+    EFI_IP6_ICMP_TYPE      *IcmpTypeList;
+} EFI_IP6_MODE_DATA;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_GET_MODE_DATA) (
+    IN struct _EFI_IP6                  *This,
+    OUT EFI_IP6_MODE_DATA               *Ip6ModeData   OPTIONAL,
+    OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData OPTIONAL,
+    OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData   OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CONFIGURE) (
+    IN struct _EFI_IP6     *This,
+    IN EFI_IP6_CONFIG_DATA *Ip6ConfigData OPTIONAL
+    );
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_GROUPS) (
+    IN struct _EFI_IP6  *This,
+    IN BOOLEAN          JoinFlag,
+    IN EFI_IPv6_ADDRESS *GroupAddress OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_ROUTES) (
+    IN struct _EFI_IP6  *This,
+    IN BOOLEAN          DeleteRoute,
+    IN EFI_IPv6_ADDRESS *Destination    OPTIONAL,
+    IN UINT8            PrefixLength,
+    IN EFI_IPv6_ADDRESS *GatewayAddress OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_NEIGHBORS) (
+    IN struct _EFI_IP6  *This,
+    IN BOOLEAN          DeleteFlag,
+    IN EFI_IPv6_ADDRESS *TargetIp6Address,
+    IN EFI_MAC_ADDRESS  *TargetLinkAddress OPTIONAL,
+    IN UINT32           Timeout,
+    IN BOOLEAN          Override
+    );
+
+typedef struct _EFI_IP6_FRAGMENT_DATA {
+    UINT32 FragmentLength;
+    VOID   *FragmentBuffer;
+} EFI_IP6_FRAGMENT_DATA;
+
+typedef struct _EFI_IP6_OVERRIDE_DATA {
+    UINT8  Protocol;
+    UINT8  HopLimit;
+    UINT32 FlowLabel;
+} EFI_IP6_OVERRIDE_DATA;
+
+typedef struct _EFI_IP6_TRANSMIT_DATA {
+    EFI_IPv6_ADDRESS      DestinationAddress;
+    EFI_IP6_OVERRIDE_DATA *OverrideData;
+    UINT32                ExtHdrsLength;
+    VOID                  *ExtHdrs;
+    UINT8                 NextHeader;
+    UINT32                DataLength;
+    UINT32                FragmentCount;
+    EFI_IP6_FRAGMENT_DATA FragmentTable[1];
+} EFI_IP6_TRANSMIT_DATA;
+
+#pragma pack(1)
+typedef struct _EFI_IP6_HEADER {
+    UINT8            TrafficClassH:4;
+    UINT8            Version:4;
+    UINT8            FlowLabelH:4;
+    UINT8            TrafficClassL:4;
+    UINT16           FlowLabelL;
+    UINT16           PayloadLength;
+    UINT8            NextHeader;
+    UINT8            HopLimit;
+    EFI_IPv6_ADDRESS SourceAddress;
+    EFI_IPv6_ADDRESS DestinationAddress;
+} EFI_IP6_HEADER;
+#pragma pack()
+
+typedef struct _EFI_IP6_RECEIVE_DATA {
+    EFI_TIME              TimeStamp;
+    EFI_EVENT             RecycleSignal;
+    UINT32                HeaderLength;
+    EFI_IP6_HEADER        *Header;
+    UINT32                DataLength;
+    UINT32                FragmentCount;
+    EFI_IP6_FRAGMENT_DATA FragmentTable[1];
+} EFI_IP6_RECEIVE_DATA;
+
+typedef struct {
+    EFI_EVENT                 Event;
+    EFI_STATUS                Status;
+    union {
+	EFI_IP6_RECEIVE_DATA  *RxData;
+	EFI_IP6_TRANSMIT_DATA *TxData;
+    }                         Packet;
+} EFI_IP6_COMPLETION_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_TRANSMIT) (
+    IN struct _EFI_IP6          *This,
+    IN EFI_IP6_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_RECEIVE) (
+    IN struct _EFI_IP6          *This,
+    IN EFI_IP6_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_CANCEL)(
+    IN struct _EFI_IP6          *This,
+    IN EFI_IP6_COMPLETION_TOKEN *Token OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP6_POLL) (
+    IN struct _EFI_IP6 *This
+    );
+
+typedef struct _EFI_IP6 {
+    EFI_IP6_GET_MODE_DATA GetModeData;
+    EFI_IP6_CONFIGURE     Configure;
+    EFI_IP6_GROUPS        Groups;
+    EFI_IP6_ROUTES        Routes;
+    EFI_IP6_NEIGHBORS     Neighbors;
+    EFI_IP6_TRANSMIT      Transmit;
+    EFI_IP6_RECEIVE       Receive;
+    EFI_IP6_CANCEL        Cancel;
+    EFI_IP6_POLL          Poll;
+} EFI_IP6;
+
+#endif /* _EFI_IP_H */

src/include/efi/efilink.h

@@ -0,0 +1,177 @@
+#ifndef _EFI_LINK_H
+#define _EFI_LINK_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    link.h (renamed efilink.h to avoid conflicts)
+
+Abstract:
+
+    EFI link list macro's
+
+
+
+Revision History
+
+--*/
+
+#ifndef EFI_NT_EMUL
+
+//
+// List entry - doubly linked list
+//
+
+typedef struct _LIST_ENTRY {
+    struct _LIST_ENTRY  *Flink;
+    struct _LIST_ENTRY  *Blink;
+} LIST_ENTRY;
+
+#endif 
+
+
+//
+//  VOID
+//  InitializeListHead(
+//      LIST_ENTRY *ListHead
+//      );
+//
+
+#define InitializeListHead(ListHead) \
+    (ListHead)->Flink = ListHead;    \
+    (ListHead)->Blink = ListHead;
+
+//
+//  BOOLEAN
+//  IsListEmpty(
+//      PLIST_ENTRY ListHead
+//      );
+//
+
+#define IsListEmpty(ListHead) \
+    ((ListHead)->Flink == (ListHead))
+
+//
+//  VOID
+//  RemoveEntryList(
+//      PLIST_ENTRY Entry
+//      );
+//
+
+#define _RemoveEntryList(Entry) {       \
+        LIST_ENTRY *_Blink, *_Flink;    \
+        _Flink = (Entry)->Flink;        \
+        _Blink = (Entry)->Blink;        \
+        _Blink->Flink = _Flink;         \
+        _Flink->Blink = _Blink;         \
+        }
+
+#if EFI_DEBUG
+    #define RemoveEntryList(Entry)                      \
+        _RemoveEntryList(Entry);                        \
+        (Entry)->Flink = (LIST_ENTRY *) BAD_POINTER;    \
+        (Entry)->Blink = (LIST_ENTRY *) BAD_POINTER; 
+#else
+    #define RemoveEntryList(Entry)      \
+        _RemoveEntryList(Entry);
+#endif
+
+//
+//  VOID
+//  InsertTailList(
+//      PLIST_ENTRY ListHead,
+//      PLIST_ENTRY Entry
+//      );
+//
+
+#define InsertTailList(ListHead,Entry) {\
+    LIST_ENTRY *_ListHead, *_Blink;     \
+    _ListHead = (ListHead);             \
+    _Blink = _ListHead->Blink;          \
+    (Entry)->Flink = _ListHead;         \
+    (Entry)->Blink = _Blink;            \
+    _Blink->Flink = (Entry);            \
+    _ListHead->Blink = (Entry);         \
+    }
+
+//
+//  VOID
+//  InsertHeadList(
+//      PLIST_ENTRY ListHead,
+//      PLIST_ENTRY Entry
+//      );
+//
+
+#define InsertHeadList(ListHead,Entry) {\
+    LIST_ENTRY *_ListHead, *_Flink;     \
+    _ListHead = (ListHead);             \
+    _Flink = _ListHead->Flink;          \
+    (Entry)->Flink = _Flink;            \
+    (Entry)->Blink = _ListHead;         \
+    _Flink->Blink = (Entry);            \
+    _ListHead->Flink = (Entry);         \
+    }
+
+//  VOID
+//  SwapListEntries(
+//      PLIST_ENTRY Entry1,
+//      PLIST_ENTRY Entry2
+//      );
+//
+// Put Entry2 before Entry1
+//
+#define SwapListEntries(Entry1,Entry2) {\
+    LIST_ENTRY *Entry1Flink, *Entry1Blink;     \
+    LIST_ENTRY *Entry2Flink, *Entry2Blink;     \
+    Entry2Flink = (Entry2)->Flink;             \
+    Entry2Blink = (Entry2)->Blink;             \
+    Entry1Flink = (Entry1)->Flink;             \
+    Entry1Blink = (Entry1)->Blink;             \
+    Entry2Blink->Flink = Entry2Flink;       \
+    Entry2Flink->Blink = Entry2Blink;        \
+    (Entry2)->Flink = Entry1;               \
+    (Entry2)->Blink = Entry1Blink;          \
+    Entry1Blink->Flink = (Entry2);            \
+    (Entry1)->Blink = (Entry2);             \
+    }
+
+//
+//  EFI_FIELD_OFFSET - returns the byte offset to a field within a structure
+//
+
+#define EFI_FIELD_OFFSET(TYPE,Field) ((UINTN)(intptr_t)(&(((TYPE *) 0)->Field)))
+
+//
+//  CONTAINING_RECORD - returns a pointer to the structure
+//      from one of it's elements.
+//
+
+#define _CR(Record, TYPE, Field)  \
+    ((TYPE *) ( (CHAR8 *)(Record) - (CHAR8 *) &(((TYPE *) 0)->Field)))
+
+#if EFI_DEBUG
+    #define CR(Record, TYPE, Field, Sig)     \
+        _CR(Record, TYPE, Field)->Signature != Sig ?        \
+            (TYPE *) ASSERT_STRUCT(_CR(Record, TYPE, Field), Record) : \
+            _CR(Record, TYPE, Field)
+#else
+    #define CR(Record, TYPE, Field, Signature)   \
+        _CR(Record, TYPE, Field)                           
+#endif
+
+
+//
+// A lock structure
+//
+
+typedef struct _FLOCK {
+    EFI_TPL     Tpl;
+    EFI_TPL     OwnerTpl;
+    UINTN       Lock;
+} FLOCK;
+
+#endif
+

src/include/efi/efinet.h

@@ -0,0 +1,348 @@
+#ifndef _EFINET_H
+#define _EFINET_H
+
+
+/*++
+Copyright (c) 1999  Intel Corporation
+
+Module Name:
+    efinet.h
+
+Abstract:
+    EFI Simple Network protocol
+
+Revision History
+--*/
+
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//      Simple Network Protocol
+//
+
+#define EFI_SIMPLE_NETWORK_PROTOCOL_GUID \
+    { 0xA19832B9, 0xAC25, 0x11D3, {0x9A, 0x2D, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0x4D} }
+
+INTERFACE_DECL(_EFI_SIMPLE_NETWORK_PROTOCOL);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef struct {
+    //
+    // Total number of frames received.  Includes frames with errors and
+    // dropped frames.
+    //
+    UINT64  RxTotalFrames;
+
+    //
+    // Number of valid frames received and copied into receive buffers.
+    //
+    UINT64  RxGoodFrames;
+
+    //
+    // Number of frames below the minimum length for the media.
+    // This would be <64 for ethernet.
+    //
+    UINT64  RxUndersizeFrames;
+
+    //
+    // Number of frames longer than the maxminum length for the
+    // media.  This would be >1500 for ethernet.
+    //
+    UINT64  RxOversizeFrames;
+
+    //
+    // Valid frames that were dropped because receive buffers were full.
+    //
+    UINT64  RxDroppedFrames;
+
+    //
+    // Number of valid unicast frames received and not dropped.
+    //
+    UINT64  RxUnicastFrames;
+
+    //
+    // Number of valid broadcast frames received and not dropped.
+    //
+    UINT64  RxBroadcastFrames;
+
+    //
+    // Number of valid mutlicast frames received and not dropped.
+    //
+    UINT64  RxMulticastFrames;
+
+    //
+    // Number of frames w/ CRC or alignment errors.
+    //
+    UINT64  RxCrcErrorFrames;
+
+    //
+    // Total number of bytes received.  Includes frames with errors
+    // and dropped frames.
+    //
+    UINT64  RxTotalBytes;
+
+    //
+    // Transmit statistics.
+    //
+    UINT64  TxTotalFrames;
+    UINT64  TxGoodFrames;
+    UINT64  TxUndersizeFrames;
+    UINT64  TxOversizeFrames;
+    UINT64  TxDroppedFrames;
+    UINT64  TxUnicastFrames;
+    UINT64  TxBroadcastFrames;
+    UINT64  TxMulticastFrames;
+    UINT64  TxCrcErrorFrames;
+    UINT64  TxTotalBytes;
+
+    //
+    // Number of collisions detection on this subnet.
+    //
+    UINT64  Collisions;
+
+    //
+    // Number of frames destined for unsupported protocol.
+    //
+    UINT64  UnsupportedProtocol;
+
+} EFI_NETWORK_STATISTICS;
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef enum {
+    EfiSimpleNetworkStopped,
+    EfiSimpleNetworkStarted,
+    EfiSimpleNetworkInitialized,
+    EfiSimpleNetworkMaxState
+} EFI_SIMPLE_NETWORK_STATE;
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+#define EFI_SIMPLE_NETWORK_RECEIVE_UNICAST               0x01
+#define EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST             0x02
+#define EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST             0x04
+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS           0x08
+#define EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST 0x10
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+#define EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT        0x01
+#define EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT       0x02
+#define EFI_SIMPLE_NETWORK_COMMAND_INTERRUPT        0x04
+#define EFI_SIMPLE_NETWORK_SOFTWARE_INTERRUPT       0x08
+
+///////////////////////////////////////////////////////////////////////////////
+//
+#define MAX_MCAST_FILTER_CNT    16
+typedef struct {
+    UINT32                      State;
+    UINT32                      HwAddressSize;
+    UINT32                      MediaHeaderSize;
+    UINT32                      MaxPacketSize;
+    UINT32                      NvRamSize;
+    UINT32                      NvRamAccessSize;
+    UINT32                      ReceiveFilterMask;
+    UINT32                      ReceiveFilterSetting;
+    UINT32                      MaxMCastFilterCount;
+    UINT32                      MCastFilterCount;
+    EFI_MAC_ADDRESS             MCastFilter[MAX_MCAST_FILTER_CNT];
+    EFI_MAC_ADDRESS             CurrentAddress;
+    EFI_MAC_ADDRESS             BroadcastAddress;
+    EFI_MAC_ADDRESS             PermanentAddress;
+    UINT8                       IfType;
+    BOOLEAN                     MacAddressChangeable;
+    BOOLEAN                     MultipleTxSupported;
+    BOOLEAN                     MediaPresentSupported;
+    BOOLEAN                     MediaPresent;
+} EFI_SIMPLE_NETWORK_MODE;
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_START) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_STOP) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_INITIALIZE) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN UINTN                                ExtraRxBufferSize  OPTIONAL,
+    IN UINTN                                ExtraTxBufferSize  OPTIONAL
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_RESET) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN BOOLEAN                              ExtendedVerification
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_SHUTDOWN) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE_FILTERS) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN UINT32                               Enable,
+    IN UINT32                               Disable,
+    IN BOOLEAN                              ResetMCastFilter,
+    IN UINTN                                MCastFilterCnt     OPTIONAL,
+    IN EFI_MAC_ADDRESS                      *MCastFilter       OPTIONAL
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_STATION_ADDRESS) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN BOOLEAN                              Reset,
+    IN EFI_MAC_ADDRESS                      *New      OPTIONAL
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_STATISTICS) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN BOOLEAN                              Reset,
+    IN OUT UINTN                            *StatisticsSize   OPTIONAL,
+    OUT EFI_NETWORK_STATISTICS              *StatisticsTable  OPTIONAL
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN BOOLEAN                              IPv6,
+    IN EFI_IP_ADDRESS                       *IP,
+    OUT EFI_MAC_ADDRESS                     *MAC
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_NVDATA) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN BOOLEAN                              ReadWrite,
+    IN UINTN                                Offset,
+    IN UINTN                                BufferSize,
+    IN OUT VOID                             *Buffer
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_GET_STATUS) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    OUT UINT32                              *InterruptStatus  OPTIONAL,
+    OUT VOID                                **TxBuf           OPTIONAL
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_TRANSMIT) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    IN UINTN                                HeaderSize,
+    IN UINTN                                BufferSize,
+    IN VOID                                 *Buffer,
+    IN EFI_MAC_ADDRESS                      *SrcAddr     OPTIONAL,
+    IN EFI_MAC_ADDRESS                      *DestAddr    OPTIONAL,
+    IN UINT16                               *Protocol    OPTIONAL
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_NETWORK_RECEIVE) (
+    IN struct _EFI_SIMPLE_NETWORK_PROTOCOL  *This,
+    OUT UINTN                               *HeaderSize  OPTIONAL,
+    IN OUT UINTN                            *BufferSize,
+    OUT VOID                                *Buffer,
+    OUT EFI_MAC_ADDRESS                     *SrcAddr     OPTIONAL,
+    OUT EFI_MAC_ADDRESS                     *DestAddr    OPTIONAL,
+    OUT UINT16                              *Protocol    OPTIONAL
+);
+
+///////////////////////////////////////////////////////////////////////////////
+//
+
+#define EFI_SIMPLE_NETWORK_PROTOCOL_REVISION  0x00010000
+#define EFI_SIMPLE_NETWORK_INTERFACE_REVISION EFI_SIMPLE_NETWORK_PROTOCOL_REVISION
+
+typedef struct _EFI_SIMPLE_NETWORK_PROTOCOL {
+    UINT64                              Revision;
+    EFI_SIMPLE_NETWORK_START            Start;
+    EFI_SIMPLE_NETWORK_STOP             Stop;
+    EFI_SIMPLE_NETWORK_INITIALIZE       Initialize;
+    EFI_SIMPLE_NETWORK_RESET            Reset;
+    EFI_SIMPLE_NETWORK_SHUTDOWN         Shutdown;
+    EFI_SIMPLE_NETWORK_RECEIVE_FILTERS  ReceiveFilters;
+    EFI_SIMPLE_NETWORK_STATION_ADDRESS  StationAddress;
+    EFI_SIMPLE_NETWORK_STATISTICS       Statistics;
+    EFI_SIMPLE_NETWORK_MCAST_IP_TO_MAC  MCastIpToMac;
+    EFI_SIMPLE_NETWORK_NVDATA           NvData;
+    EFI_SIMPLE_NETWORK_GET_STATUS       GetStatus;
+    EFI_SIMPLE_NETWORK_TRANSMIT         Transmit;
+    EFI_SIMPLE_NETWORK_RECEIVE          Receive;
+    EFI_EVENT                           WaitForPacket;
+    EFI_SIMPLE_NETWORK_MODE             *Mode;
+} EFI_SIMPLE_NETWORK_PROTOCOL;
+
+// Note: Because it conflicted with the EDK2 struct name, the
+// 'EFI_SIMPLE_NETWORK_PROTOCOL' GUID definition, from older
+// versions of gnu-efi, is now obsoleted.
+// Use 'EFI_SIMPLE_NETWORK_PROTOCOL_GUID' instead.
+
+typedef struct _EFI_SIMPLE_NETWORK_PROTOCOL _EFI_SIMPLE_NETWORK;
+typedef EFI_SIMPLE_NETWORK_PROTOCOL EFI_SIMPLE_NETWORK;
+
+#endif /* _EFINET_H */

src/include/efi/efipart.h

@@ -0,0 +1,61 @@
+#ifndef _EFI_PART_H
+#define _EFI_PART_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efipart.h
+    
+Abstract:   
+    Info about disk partitions and Master Boot Records
+
+
+
+
+Revision History
+
+--*/
+
+//
+//
+//
+
+#define EFI_PARTITION   0xef
+#define MBR_SIZE        512
+
+#pragma pack(1)
+
+typedef struct {
+    UINT8       BootIndicator;
+    UINT8       StartHead;
+    UINT8       StartSector;
+    UINT8       StartTrack;
+    UINT8       OSIndicator;
+    UINT8       EndHead;
+    UINT8       EndSector;
+    UINT8       EndTrack;
+    UINT8       StartingLBA[4];
+    UINT8       SizeInLBA[4];
+} MBR_PARTITION_RECORD;
+
+#define EXTRACT_UINT32(D) (UINT32)(D[0] | (D[1] << 8) | (D[2] << 16) | (D[3] << 24))
+
+#define MBR_SIGNATURE           0xaa55
+#define MIN_MBR_DEVICE_SIZE     0x80000
+#define MBR_ERRATA_PAD          0x40000 // 128 MB
+
+#define MAX_MBR_PARTITIONS  4   
+typedef struct {
+    UINT8                   BootStrapCode[440];
+    UINT8                   UniqueMbrSignature[4];
+    UINT8                   Unknown[2];
+    MBR_PARTITION_RECORD    Partition[MAX_MBR_PARTITIONS];
+    UINT16                  Signature;
+} MASTER_BOOT_RECORD;
+#pragma pack()
+
+
+#endif

src/include/efi/efipciio.h

@@ -0,0 +1,399 @@
+#ifndef _EFI_PCI_IO_H
+#define _EFI_PCI_IO_H
+
+#define EFI_PCI_IO_PROTOCOL_GUID \
+    { 0x4cf5b200, 0x68b8, 0x4ca5, {0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a} }
+
+#define EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID \
+    { 0x2f707ebb, 0x4a1a, 0x11d4, {0x9a, 0x38, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+
+INTERFACE_DECL(_EFI_PCI_IO_PROTOCOL);
+INTERFACE_DECL(_EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL);
+
+typedef enum {
+    EfiPciIoWidthUint8,
+    EfiPciIoWidthUint16,
+    EfiPciIoWidthUint32,
+    EfiPciIoWidthUint64,
+    EfiPciIoWidthFifoUint8,
+    EfiPciIoWidthFifoUint16,
+    EfiPciIoWidthFifoUint32,
+    EfiPciIoWidthFifoUint64,
+    EfiPciIoWidthFillUint8,
+    EfiPciIoWidthFillUint16,
+    EfiPciIoWidthFillUint32,
+    EfiPciIoWidthFillUint64,
+    EfiPciIoWidthMaximum
+} EFI_PCI_IO_PROTOCOL_WIDTH, EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH;
+
+#define EFI_PCI_IO_PASS_THROUGH_BAR 0xff
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_POLL_IO_MEM) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN UINT8                        BarIndex,
+  IN UINT64                       Offset,
+  IN UINT64                       Mask,
+  IN UINT64                       Value,
+  IN UINT64                       Delay,
+  OUT UINT64                      *Result
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL  *This,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
+  IN UINT64                                   Address,
+  IN UINT64                                   Mask,
+  IN UINT64                                   Value,
+  IN UINT64                                   Delay,
+  OUT UINT64                                  *Result
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_IO_MEM) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN UINT8                        BarIndex,
+  IN UINT64                       Offset,
+  IN UINTN                        Count,
+  IN OUT VOID                     *Buffer
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL  *This,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
+  IN UINT64                                   Address,
+  IN UINTN                                    Count,
+  IN OUT VOID                                 *Buffer
+);
+
+typedef struct {
+  EFI_PCI_IO_PROTOCOL_IO_MEM    Read;
+  EFI_PCI_IO_PROTOCOL_IO_MEM    Write;
+} EFI_PCI_IO_PROTOCOL_ACCESS;
+
+typedef struct {
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM  Read;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_IO_MEM  Write;
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_CONFIG) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN UINT32                       Offset,
+  IN UINTN                        Count,
+  IN OUT VOID                     *Buffer
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This,
+  OUT VOID                                      **Resources
+);
+
+typedef struct {
+  EFI_PCI_IO_PROTOCOL_CONFIG Read;
+  EFI_PCI_IO_PROTOCOL_CONFIG Write;
+} EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_COPY_MEM) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN EFI_PCI_IO_PROTOCOL_WIDTH    Width,
+  IN UINT8                        DestBarIndex,
+  IN UINT64                       DestOffset,
+  IN UINT8                        SrcBarIndex,
+  IN UINT64                       SrcOffset,
+  IN UINTN                        Count
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL  *This,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_WIDTH    Width,
+  IN UINT64                                   DestAddress,
+  IN UINT64                                   SrcAddress,
+  IN UINTN                                    Count
+);
+
+typedef enum {
+    EfiPciIoOperationBusMasterRead,
+    EfiPciIoOperationBusMasterWrite,
+    EfiPciIoOperationBusMasterCommonBuffer,
+    EfiPciIoOperationMaximum
+} EFI_PCI_IO_PROTOCOL_OPERATION;
+
+typedef enum {
+  EfiPciOperationBusMasterRead,
+  EfiPciOperationBusMasterWrite,
+  EfiPciOperationBusMasterCommonBuffer,
+  EfiPciOperationBusMasterRead64,
+  EfiPciOperationBusMasterWrite64,
+  EfiPciOperationBusMasterCommonBuffer64,
+  EfiPciOperationMaximum
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_MAP) (
+  IN struct _EFI_PCI_IO_PROTOCOL   *This,
+  IN EFI_PCI_IO_PROTOCOL_OPERATION Operation,
+  IN VOID                          *HostAddress,
+  IN OUT UINTN                     *NumberOfBytes,
+  OUT EFI_PHYSICAL_ADDRESS         *DeviceAddress,
+  OUT VOID                         **Mapping
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_OPERATION  Operation,
+  IN VOID                                       *HostAddress,
+  IN OUT UINTN                                  *NumberOfBytes,
+  OUT EFI_PHYSICAL_ADDRESS                      *DeviceAddress,
+  OUT VOID                                      **Mapping
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_UNMAP) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN VOID                         *Mapping
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This,
+  IN VOID                                       *Mapping
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN EFI_ALLOCATE_TYPE            Type,
+  IN EFI_MEMORY_TYPE              MemoryType,
+  IN UINTN                        Pages,
+  OUT VOID                        **HostAddress,
+  IN UINT64                       Attributes
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This,
+  IN EFI_ALLOCATE_TYPE                          Type,
+  IN EFI_MEMORY_TYPE                            MemoryType,
+  IN UINTN                                      Pages,
+  IN OUT VOID                                   **HostAddress,
+  IN UINT64                                     Attributes
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_FREE_BUFFER) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN UINTN                        Pages,
+  IN VOID                         *HostAddress
+  );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This,
+  IN UINTN                                      Pages,
+  IN VOID                                       *HostAddress
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_FLUSH) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_GET_LOCATION) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  OUT UINTN                       *SegmentNumber,
+  OUT UINTN                       *BusNumber,
+  OUT UINTN                       *DeviceNumber,
+  OUT UINTN                       *FunctionNumber
+);
+
+#define EFI_PCI_ATTRIBUTE_ISA_MOTHERBOARD_IO      0x0001
+#define EFI_PCI_ATTRIBUTE_ISA_IO                  0x0002
+#define EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO          0x0004
+#define EFI_PCI_ATTRIBUTE_VGA_MEMORY              0x0008
+#define EFI_PCI_ATTRIBUTE_VGA_IO                  0x0010
+#define EFI_PCI_ATTRIBUTE_IDE_PRIMARY_IO          0x0020
+#define EFI_PCI_ATTRIBUTE_IDE_SECONDARY_IO        0x0040
+#define EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE    0x0080
+#define EFI_PCI_ATTRIBUTE_IO                      0x0100
+#define EFI_PCI_ATTRIBUTE_MEMORY                  0x0200
+#define EFI_PCI_ATTRIBUTE_BUS_MASTER              0x0400
+#define EFI_PCI_ATTRIBUTE_MEMORY_CACHED           0x0800
+#define EFI_PCI_ATTRIBUTE_MEMORY_DISABLE          0x1000
+#define EFI_PCI_ATTRIBUTE_EMBEDDED_DEVICE         0x2000
+#define EFI_PCI_ATTRIBUTE_EMBEDDED_ROM            0x4000
+#define EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE      0x8000
+#define EFI_PCI_ATTRIBUTE_ISA_IO_16               0x10000
+#define EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO_16       0x20000
+#define EFI_PCI_ATTRIBUTE_VGA_IO_16               0x40000
+
+#define EFI_PCI_IO_ATTRIBUTE_ISA_MOTHERBOARD_IO   EFI_PCI_ATTRIBUTE_ISA_MOTHERBOARD_IO
+#define EFI_PCI_IO_ATTRIBUTE_ISA_IO               EFI_PCI_ATTRIBUTE_ISA_IO
+#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO       EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO
+#define EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY           EFI_PCI_ATTRIBUTE_VGA_MEMORY
+#define EFI_PCI_IO_ATTRIBUTE_VGA_IO               EFI_PCI_ATTRIBUTE_VGA_IO
+#define EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO       EFI_PCI_ATTRIBUTE_IDE_PRIMARY_IO
+#define EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO     EFI_PCI_ATTRIBUTE_IDE_SECONDARY_IO
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE
+#define EFI_PCI_IO_ATTRIBUTE_IO                   EFI_PCI_ATTRIBUTE_IO
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY               EFI_PCI_ATTRIBUTE_MEMORY
+#define EFI_PCI_IO_ATTRIBUTE_BUS_MASTER           EFI_PCI_ATTRIBUTE_BUS_MASTER
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY_CACHED        EFI_PCI_ATTRIBUTE_MEMORY_CACHED
+#define EFI_PCI_IO_ATTRIBUTE_MEMORY_DISABLE       EFI_PCI_ATTRIBUTE_MEMORY_DISABLE
+#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_DEVICE      EFI_PCI_ATTRIBUTE_EMBEDDED_DEVICE
+#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_ROM         EFI_PCI_ATTRIBUTE_EMBEDDED_ROM
+#define EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE   EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE
+#define EFI_PCI_IO_ATTRIBUTE_ISA_IO_16            EFI_PCI_ATTRIBUTE_ISA_IO_16
+#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO_16    EFI_PCI_ATTRIBUTE_VGA_PALETTE_IO_16
+#define EFI_PCI_IO_ATTRIBUTE_VGA_IO_16            EFI_PCI_ATTRIBUTE_VGA_IO_16
+
+#define EFI_PCI_ATTRIBUTE_VALID_FOR_ALLOCATE_BUFFER \
+    (EFI_PCI_ATTRIBUTE_MEMORY_WRITE_COMBINE | EFI_PCI_ATTRIBUTE_MEMORY_CACHED | EFI_PCI_ATTRIBUTE_DUAL_ADDRESS_CYCLE)
+
+#define EFI_PCI_ATTRIBUTE_INVALID_FOR_ALLOCATE_BUFFER \
+    (~EFI_PCI_ATTRIBUTE_VALID_FOR_ALLOCATE_BUFFER)
+
+typedef struct {
+    UINT8 Register;
+    UINT8 Function;
+    UINT8 Device;
+    UINT8 Bus;
+    UINT32 ExtendedRegister;
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS;
+
+typedef enum {
+    EfiPciIoAttributeOperationGet,
+    EfiPciIoAttributeOperationSet,
+    EfiPciIoAttributeOperationEnable,
+    EfiPciIoAttributeOperationDisable,
+    EfiPciIoAttributeOperationSupported,
+    EfiPciIoAttributeOperationMaximum
+} EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_ATTRIBUTES) (
+  IN struct _EFI_PCI_IO_PROTOCOL             *This,
+  IN EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION Operation,
+  IN UINT64                                  Attributes,
+  OUT UINT64                                 *Result OPTIONAL
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN UINT8                        BarIndex,
+  OUT UINT64                      *Supports   OPTIONAL,
+  OUT VOID                        **Resources OPTIONAL
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This,
+  OUT UINT64                                    *Supports,
+  OUT UINT64                                    *Attributes
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES) (
+  IN struct _EFI_PCI_IO_PROTOCOL  *This,
+  IN UINT64                       Attributes,
+  IN UINT8                        BarIndex,
+  IN OUT UINT64                   *Offset,
+  IN OUT UINT64                   *Length
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES) (
+  IN struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL    *This,
+  IN UINT64                                     Attributes,
+  IN OUT UINT64                                 *ResourceBase,
+  IN OUT UINT64                                 *ResourceLength
+);
+
+typedef struct _EFI_PCI_IO_PROTOCOL {
+  EFI_PCI_IO_PROTOCOL_POLL_IO_MEM        PollMem;
+  EFI_PCI_IO_PROTOCOL_POLL_IO_MEM        PollIo;
+  EFI_PCI_IO_PROTOCOL_ACCESS             Mem;
+  EFI_PCI_IO_PROTOCOL_ACCESS             Io;
+  EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS      Pci;
+  EFI_PCI_IO_PROTOCOL_COPY_MEM           CopyMem;
+  EFI_PCI_IO_PROTOCOL_MAP                Map;
+  EFI_PCI_IO_PROTOCOL_UNMAP              Unmap;
+  EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER    AllocateBuffer;
+  EFI_PCI_IO_PROTOCOL_FREE_BUFFER        FreeBuffer;
+  EFI_PCI_IO_PROTOCOL_FLUSH              Flush;
+  EFI_PCI_IO_PROTOCOL_GET_LOCATION       GetLocation;
+  EFI_PCI_IO_PROTOCOL_ATTRIBUTES         Attributes;
+  EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES GetBarAttributes;
+  EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES SetBarAttributes;
+  UINT64                                 RomSize;
+  VOID                                   *RomImage;
+} EFI_PCI_IO_PROTOCOL;
+
+// Note: Because it conflicted with the EDK2 struct name, the
+// 'EFI_PCI_IO_PROTOCOL' GUID definition, from older versions
+// of gnu-efi, is now obsoleted.
+// Use 'EFI_PCI_IO_PROTOCOL_GUID' instead.
+
+typedef struct _EFI_PCI_IO_PROTOCOL _EFI_PCI_IO;
+typedef EFI_PCI_IO_PROTOCOL EFI_PCI_IO;
+
+typedef struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL {
+  EFI_HANDLE                                      ParentHandle;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM     PollMem;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM     PollIo;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS          Mem;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS          Io;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS          Pci;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM        CopyMem;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP             Map;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP           Unmap;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER     FreeBuffer;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH           Flush;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES  GetAttributes;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES  SetAttributes;
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION   Configuration;
+  UINT32                                          SegmentNumber;
+} EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL;
+
+#endif /* _EFI_PCI_IO_H */

src/include/efi/efipoint.h

@@ -0,0 +1,115 @@
+/* Copyright (C) 2014 by John Cronin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef _EFI_POINT_H
+#define _EFI_POINT_H
+
+#define EFI_SIMPLE_POINTER_PROTOCOL_GUID \
+	{ 0x31878c87, 0xb75, 0x11d5, { 0x9a, 0x4f, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d } }
+
+INTERFACE_DECL(_EFI_SIMPLE_POINTER);
+
+typedef struct {
+	INT32 RelativeMovementX;
+	INT32 RelativeMovementY;
+	INT32 RelativeMovementZ;
+	BOOLEAN LeftButton;
+	BOOLEAN RightButton;
+} EFI_SIMPLE_POINTER_STATE;
+
+typedef struct {
+	UINT64 ResolutionX;
+	UINT64 ResolutionY;
+	UINT64 ResolutionZ;
+	BOOLEAN LeftButton;
+	BOOLEAN RightButton;
+} EFI_SIMPLE_POINTER_MODE;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_POINTER_RESET) (
+	IN struct _EFI_SIMPLE_POINTER *This,
+	IN BOOLEAN ExtendedVerification
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SIMPLE_POINTER_GET_STATE) (
+	IN struct _EFI_SIMPLE_POINTER *This,
+	IN OUT EFI_SIMPLE_POINTER_STATE *State
+);
+
+typedef struct _EFI_SIMPLE_POINTER {
+	EFI_SIMPLE_POINTER_RESET Reset;
+	EFI_SIMPLE_POINTER_GET_STATE GetState;
+	EFI_EVENT WaitForInput;
+	EFI_SIMPLE_POINTER_MODE *Mode;
+} EFI_SIMPLE_POINTER_PROTOCOL;
+
+#define EFI_ABSOLUTE_POINTER_PROTOCOL_GUID \
+	{ 0x8D59D32B, 0xC655, 0x4AE9, { 0x9B, 0x15, 0xF2, 0x59, 0x04, 0x99, 0x2A, 0x43 } }
+
+INTERFACE_DECL(_EFI_ABSOLUTE_POINTER_PROTOCOL);
+
+typedef struct {
+	UINT64 AbsoluteMinX;
+	UINT64 AbsoluteMinY;
+	UINT64 AbsoluteMinZ;
+	UINT64 AbsoluteMaxX;
+	UINT64 AbsoluteMaxY;
+	UINT64 AbsoluteMaxZ;
+	UINT32 Attributes;
+} EFI_ABSOLUTE_POINTER_MODE;
+
+typedef struct {
+	UINT64 CurrentX;
+	UINT64 CurrentY;
+	UINT64 CurrentZ;
+	UINT32 ActiveButtons;
+} EFI_ABSOLUTE_POINTER_STATE;
+
+#define EFI_ABSP_SupportsAltActive 0x00000001
+#define EFI_ABSP_SupportsPressureAsZ 0x00000002
+#define EFI_ABSP_TouchActive 0x00000001
+#define EFI_ABS_AltActive 0x00000002
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ABSOLUTE_POINTER_RESET) (
+	IN struct _EFI_ABSOLUTE_POINTER_PROTOCOL *This,
+	IN BOOLEAN ExtendedVerification
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_ABSOLUTE_POINTER_GET_STATE) (
+	IN struct _EFI_ABSOLUTE_POINTER_PROTOCOL *This,
+	IN OUT EFI_ABSOLUTE_POINTER_STATE *State
+);
+
+typedef struct _EFI_ABSOLUTE_POINTER_PROTOCOL {
+	EFI_ABSOLUTE_POINTER_RESET Reset;
+	EFI_ABSOLUTE_POINTER_GET_STATE GetState;
+	EFI_EVENT WaitForInput;
+	EFI_ABSOLUTE_POINTER_MODE *Mode;
+} EFI_ABSOLUTE_POINTER_PROTOCOL;
+
+#endif

src/include/efi/efipxebc.h

@@ -0,0 +1,482 @@
+#ifndef _EFIPXEBC_H
+#define _EFIPXEBC_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efipxebc.h
+
+Abstract:
+
+    EFI PXE Base Code Protocol
+
+
+
+Revision History
+
+--*/
+
+//
+// PXE Base Code protocol
+//
+
+#define EFI_PXE_BASE_CODE_PROTOCOL_GUID \
+    { 0x03c4e603, 0xac28, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} }
+
+INTERFACE_DECL(_EFI_PXE_BASE_CODE_PROTOCOL);
+
+#define DEFAULT_TTL 4
+#define DEFAULT_ToS 0
+//
+// Address definitions
+//
+
+typedef union {
+    UINT32      Addr[4];
+    EFI_IPv4_ADDRESS    v4;
+    EFI_IPv6_ADDRESS    v6;
+} EFI_IP_ADDRESS;
+
+typedef UINT16 EFI_PXE_BASE_CODE_UDP_PORT;
+
+//
+// Packet definitions
+//
+
+typedef struct {
+    UINT8                           BootpOpcode;
+    UINT8                           BootpHwType;
+    UINT8                           BootpHwAddrLen;
+    UINT8                           BootpGateHops;
+    UINT32                          BootpIdent;
+    UINT16                          BootpSeconds;
+    UINT16                          BootpFlags;
+    UINT8                           BootpCiAddr[4];
+    UINT8                           BootpYiAddr[4];
+    UINT8                           BootpSiAddr[4];
+    UINT8                           BootpGiAddr[4];
+    UINT8                           BootpHwAddr[16];
+    UINT8                           BootpSrvName[64];
+    UINT8                           BootpBootFile[128];
+    UINT32                          DhcpMagik;
+    UINT8                           DhcpOptions[56];
+} EFI_PXE_BASE_CODE_DHCPV4_PACKET;
+
+typedef struct {
+    UINT32                          MessageType:8;
+    UINT32                          TransactionId:24;
+    UINT8                           DhcpOptions[1024];
+} EFI_PXE_BASE_CODE_DHCPV6_PACKET;
+
+typedef union {
+    UINT8                               Raw[1472];
+    EFI_PXE_BASE_CODE_DHCPV4_PACKET     Dhcpv4;
+    EFI_PXE_BASE_CODE_DHCPV6_PACKET     Dhcpv6;
+} EFI_PXE_BASE_CODE_PACKET;
+
+typedef struct {
+    UINT8                   Type;
+    UINT8                   Code;
+    UINT16                  Checksum;
+    union {
+        UINT32              reserved;
+        UINT32              Mtu;
+        UINT32              Pointer;
+        struct {
+            UINT16          Identifier;
+            UINT16          Sequence;
+        } Echo;
+    } u;
+    UINT8                   Data[494];
+} EFI_PXE_BASE_CODE_ICMP_ERROR;
+
+typedef struct {
+    UINT8                   ErrorCode;
+    CHAR8                   ErrorString[127];
+} EFI_PXE_BASE_CODE_TFTP_ERROR;
+
+//
+// IP Receive Filter definitions
+//
+#define EFI_PXE_BASE_CODE_MAX_IPCNT             8
+typedef struct {
+    UINT8                       Filters;
+    UINT8                       IpCnt;
+    UINT16                      reserved;
+    EFI_IP_ADDRESS              IpList[EFI_PXE_BASE_CODE_MAX_IPCNT];
+} EFI_PXE_BASE_CODE_IP_FILTER;
+
+#define EFI_PXE_BASE_CODE_IP_FILTER_STATION_IP             0x0001
+#define EFI_PXE_BASE_CODE_IP_FILTER_BROADCAST              0x0002
+#define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS            0x0004
+#define EFI_PXE_BASE_CODE_IP_FILTER_PROMISCUOUS_MULTICAST  0x0008
+
+//
+// ARP Cache definitions
+//
+
+typedef struct {
+    EFI_IP_ADDRESS       IpAddr;
+    EFI_MAC_ADDRESS      MacAddr;
+} EFI_PXE_BASE_CODE_ARP_ENTRY;
+
+typedef struct {
+    EFI_IP_ADDRESS       IpAddr;
+    EFI_IP_ADDRESS       SubnetMask;
+    EFI_IP_ADDRESS       GwAddr;
+} EFI_PXE_BASE_CODE_ROUTE_ENTRY;
+
+//
+// UDP definitions
+//
+
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_IP    0x0001
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_SRC_PORT  0x0002
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_IP   0x0004
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_ANY_DEST_PORT 0x0008
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_USE_FILTER    0x0010
+#define EFI_PXE_BASE_CODE_UDP_OPFLAGS_MAY_FRAGMENT  0x0020
+
+//
+// Discover() definitions
+//
+
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_BOOTSTRAP           0
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_MS_WINNT_RIS        1
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_INTEL_LCM           2
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_DOSUNDI             3
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_NEC_ESMPRO          4
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_WSoD            5
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_IBM_LCCM            6
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_CA_UNICENTER_TNG    7
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_HP_OPENVIEW         8
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_9           9
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_10          10
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_ALTIRIS_11          11
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_NOT_USED_12         12
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_INSTALL      13
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_REDHAT_BOOT         14
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_REMBO               15
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_BEOBOOT             16
+//
+// 17 through 32767 are reserved
+// 32768 through 65279 are for vendor use
+// 65280 through 65534 are reserved
+//
+#define EFI_PXE_BASE_CODE_BOOT_TYPE_PXETEST             65535
+
+#define EFI_PXE_BASE_CODE_BOOT_LAYER_MASK               0x7FFF
+#define EFI_PXE_BASE_CODE_BOOT_LAYER_INITIAL            0x0000
+
+
+typedef struct {
+    UINT16                      Type;
+    BOOLEAN                     AcceptAnyResponse;
+    UINT8                       Reserved;
+    EFI_IP_ADDRESS              IpAddr;
+} EFI_PXE_BASE_CODE_SRVLIST;
+
+typedef struct {
+    BOOLEAN                     UseMCast;
+    BOOLEAN                     UseBCast;
+    BOOLEAN                     UseUCast;
+    BOOLEAN                     MustUseList;
+    EFI_IP_ADDRESS              ServerMCastIp;
+    UINT16                      IpCnt;
+    EFI_PXE_BASE_CODE_SRVLIST   SrvList[1];
+} EFI_PXE_BASE_CODE_DISCOVER_INFO;
+
+//
+// Mtftp() definitions
+//
+
+typedef enum {
+    EFI_PXE_BASE_CODE_TFTP_FIRST,
+    EFI_PXE_BASE_CODE_TFTP_GET_FILE_SIZE,
+    EFI_PXE_BASE_CODE_TFTP_READ_FILE,
+    EFI_PXE_BASE_CODE_TFTP_WRITE_FILE,
+    EFI_PXE_BASE_CODE_TFTP_READ_DIRECTORY,
+    EFI_PXE_BASE_CODE_MTFTP_GET_FILE_SIZE,
+    EFI_PXE_BASE_CODE_MTFTP_READ_FILE,
+    EFI_PXE_BASE_CODE_MTFTP_READ_DIRECTORY,
+    EFI_PXE_BASE_CODE_MTFTP_LAST
+} EFI_PXE_BASE_CODE_TFTP_OPCODE;
+
+typedef struct {
+    EFI_IP_ADDRESS   MCastIp;
+    EFI_PXE_BASE_CODE_UDP_PORT  CPort;
+    EFI_PXE_BASE_CODE_UDP_PORT  SPort;
+    UINT16                      ListenTimeout;
+    UINT16                      TransmitTimeout;
+} EFI_PXE_BASE_CODE_MTFTP_INFO;
+
+//
+// PXE Base Code Mode structure
+//
+
+#define EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES       8
+#define EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES     8
+
+typedef struct {
+    BOOLEAN                         Started;
+    BOOLEAN                         Ipv6Available;
+    BOOLEAN                         Ipv6Supported;
+    BOOLEAN                         UsingIpv6;
+    BOOLEAN                         BisSupported;
+    BOOLEAN                         BisDetected;
+    BOOLEAN                         AutoArp;
+    BOOLEAN                         SendGUID;
+    BOOLEAN                         DhcpDiscoverValid;
+    BOOLEAN                         DhcpAckReceived;
+    BOOLEAN                         ProxyOfferReceived;
+    BOOLEAN                         PxeDiscoverValid;
+    BOOLEAN                         PxeReplyReceived;
+    BOOLEAN                         PxeBisReplyReceived;
+    BOOLEAN                         IcmpErrorReceived;
+    BOOLEAN                         TftpErrorReceived;
+    BOOLEAN                         MakeCallbacks;
+    UINT8                           TTL;
+    UINT8                           ToS;
+    EFI_IP_ADDRESS                  StationIp;
+    EFI_IP_ADDRESS                  SubnetMask;
+    EFI_PXE_BASE_CODE_PACKET        DhcpDiscover;
+    EFI_PXE_BASE_CODE_PACKET        DhcpAck;
+    EFI_PXE_BASE_CODE_PACKET        ProxyOffer;
+    EFI_PXE_BASE_CODE_PACKET        PxeDiscover;
+    EFI_PXE_BASE_CODE_PACKET        PxeReply;
+    EFI_PXE_BASE_CODE_PACKET        PxeBisReply;
+    EFI_PXE_BASE_CODE_IP_FILTER     IpFilter;
+    UINT32                          ArpCacheEntries;
+    EFI_PXE_BASE_CODE_ARP_ENTRY     ArpCache[EFI_PXE_BASE_CODE_MAX_ARP_ENTRIES];
+    UINT32                          RouteTableEntries;
+    EFI_PXE_BASE_CODE_ROUTE_ENTRY   RouteTable[EFI_PXE_BASE_CODE_MAX_ROUTE_ENTRIES];
+    EFI_PXE_BASE_CODE_ICMP_ERROR    IcmpError;
+    EFI_PXE_BASE_CODE_TFTP_ERROR    TftpError;
+} EFI_PXE_BASE_CODE_MODE;
+
+//
+// PXE Base Code Interface Function definitions
+//
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_START) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN BOOLEAN                             UseIpv6
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_STOP) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_DHCP) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN BOOLEAN                             SortOffers
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_DISCOVER) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL   *This,
+    IN UINT16                               Type,
+    IN UINT16                               *Layer,
+    IN BOOLEAN                              UseBis,
+    IN OUT EFI_PXE_BASE_CODE_DISCOVER_INFO  *Info   OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_MTFTP) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN EFI_PXE_BASE_CODE_TFTP_OPCODE       Operation,
+    IN OUT VOID                            *BufferPtr  OPTIONAL,
+    IN BOOLEAN                             Overwrite,
+    IN OUT UINT64                          *BufferSize,
+    IN UINTN                               *BlockSize  OPTIONAL,
+    IN EFI_IP_ADDRESS                      *ServerIp,
+    IN UINT8                               *Filename,
+    IN EFI_PXE_BASE_CODE_MTFTP_INFO        *Info       OPTIONAL,
+    IN BOOLEAN                             DontUseBuffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_UDP_WRITE) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN UINT16                              OpFlags,
+    IN EFI_IP_ADDRESS                      *DestIp,
+    IN EFI_PXE_BASE_CODE_UDP_PORT          *DestPort,
+    IN EFI_IP_ADDRESS                      *GatewayIp,  OPTIONAL
+    IN EFI_IP_ADDRESS                      *SrcIp,      OPTIONAL
+    IN OUT EFI_PXE_BASE_CODE_UDP_PORT      *SrcPort,    OPTIONAL
+    IN UINTN                               *HeaderSize, OPTIONAL
+    IN VOID                                *HeaderPtr,  OPTIONAL
+    IN UINTN                               *BufferSize,
+    IN VOID                                *BufferPtr
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_UDP_READ) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN UINT16                              OpFlags,
+    IN OUT EFI_IP_ADDRESS                  *DestIp,      OPTIONAL
+    IN OUT EFI_PXE_BASE_CODE_UDP_PORT      *DestPort,    OPTIONAL
+    IN OUT EFI_IP_ADDRESS                  *SrcIp,       OPTIONAL
+    IN OUT EFI_PXE_BASE_CODE_UDP_PORT      *SrcPort,     OPTIONAL
+    IN UINTN                               *HeaderSize,  OPTIONAL
+    IN VOID                                *HeaderPtr,   OPTIONAL
+    IN OUT UINTN                           *BufferSize,
+    IN VOID                                *BufferPtr
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_IP_FILTER) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN EFI_PXE_BASE_CODE_IP_FILTER         *NewFilter
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_ARP) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN EFI_IP_ADDRESS                      *IpAddr,
+    IN EFI_MAC_ADDRESS                     *MacAddr      OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_PARAMETERS) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN BOOLEAN                             *NewAutoArp,    OPTIONAL
+    IN BOOLEAN                             *NewSendGUID,   OPTIONAL
+    IN UINT8                               *NewTTL,        OPTIONAL
+    IN UINT8                               *NewToS,        OPTIONAL
+    IN BOOLEAN                             *NewMakeCallback    OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_STATION_IP) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    IN EFI_IP_ADDRESS                      *NewStationIp,  OPTIONAL
+    IN EFI_IP_ADDRESS                      *NewSubnetMask  OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_PXE_BASE_CODE_SET_PACKETS) (
+    IN struct _EFI_PXE_BASE_CODE_PROTOCOL  *This,
+    BOOLEAN                                *NewDhcpDiscoverValid,  OPTIONAL
+    BOOLEAN                                *NewDhcpAckReceived,    OPTIONAL
+    BOOLEAN                                *NewProxyOfferReceived, OPTIONAL
+    BOOLEAN                                *NewPxeDiscoverValid,   OPTIONAL
+    BOOLEAN                                *NewPxeReplyReceived,   OPTIONAL
+    BOOLEAN                                *NewPxeBisReplyReceived,OPTIONAL
+    IN EFI_PXE_BASE_CODE_PACKET            *NewDhcpDiscover, OPTIONAL
+    IN EFI_PXE_BASE_CODE_PACKET            *NewDhcpAck,      OPTIONAL
+    IN EFI_PXE_BASE_CODE_PACKET            *NewProxyOffer,   OPTIONAL
+    IN EFI_PXE_BASE_CODE_PACKET            *NewPxeDiscover,  OPTIONAL
+    IN EFI_PXE_BASE_CODE_PACKET            *NewPxeReply,     OPTIONAL
+    IN EFI_PXE_BASE_CODE_PACKET            *NewPxeBisReply   OPTIONAL
+    );
+
+//
+// PXE Base Code Protocol structure
+//
+
+#define EFI_PXE_BASE_CODE_PROTOCOL_REVISION  0x00010000
+#define EFI_PXE_BASE_CODE_INTERFACE_REVISION EFI_PXE_BASE_CODE_PROTOCOL_REVISION
+
+typedef struct _EFI_PXE_BASE_CODE_PROTOCOL {
+    UINT64                              Revision;
+    EFI_PXE_BASE_CODE_START             Start;
+    EFI_PXE_BASE_CODE_STOP              Stop;
+    EFI_PXE_BASE_CODE_DHCP              Dhcp;
+    EFI_PXE_BASE_CODE_DISCOVER          Discover;
+    EFI_PXE_BASE_CODE_MTFTP             Mtftp;
+    EFI_PXE_BASE_CODE_UDP_WRITE         UdpWrite;
+    EFI_PXE_BASE_CODE_UDP_READ          UdpRead;
+    EFI_PXE_BASE_CODE_SET_IP_FILTER     SetIpFilter;
+    EFI_PXE_BASE_CODE_ARP               Arp;
+    EFI_PXE_BASE_CODE_SET_PARAMETERS    SetParameters;
+    EFI_PXE_BASE_CODE_SET_STATION_IP    SetStationIp;
+    EFI_PXE_BASE_CODE_SET_PACKETS       SetPackets;
+    EFI_PXE_BASE_CODE_MODE              *Mode;
+} EFI_PXE_BASE_CODE_PROTOCOL;
+
+// Note: Because it conflicted with the EDK2 struct name, the
+// 'EFI_PXE_BASE_CODE_PROTOCOL' GUID definition, from older
+// versions of gnu-efi, is now obsoleted.
+// Use 'EFI_PXE_BASE_CODE_PROTOCOL_GUID' instead.
+
+typedef struct _EFI_PXE_BASE_CODE_PROTOCOL _EFI_PXE_BASE_CODE;
+typedef struct _EFI_PXE_BASE_CODE_PROTOCOL EFI_PXE_BASE_CODE;
+
+//
+// Call Back Definitions
+//
+
+#define EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_GUID \
+    { 0x245dca21, 0xfb7b, 0x11d3, {0x8f, 0x01, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
+
+//
+// Revision Number
+//
+
+#define EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_REVISION  0x00010000
+#define EFI_PXE_BASE_CODE_CALLBACK_INTERFACE_REVISION EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_REVISION
+
+INTERFACE_DECL(_EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL);
+
+typedef enum {
+    EFI_PXE_BASE_CODE_FUNCTION_FIRST,
+    EFI_PXE_BASE_CODE_FUNCTION_DHCP,
+    EFI_PXE_BASE_CODE_FUNCTION_DISCOVER,
+    EFI_PXE_BASE_CODE_FUNCTION_MTFTP,
+    EFI_PXE_BASE_CODE_FUNCTION_UDP_WRITE,
+    EFI_PXE_BASE_CODE_FUNCTION_UDP_READ,
+    EFI_PXE_BASE_CODE_FUNCTION_ARP,
+    EFI_PXE_BASE_CODE_FUNCTION_IGMP,
+    EFI_PXE_BASE_CODE_PXE_FUNCTION_LAST
+} EFI_PXE_BASE_CODE_FUNCTION;
+
+typedef enum {
+    EFI_PXE_BASE_CODE_CALLBACK_STATUS_FIRST,
+    EFI_PXE_BASE_CODE_CALLBACK_STATUS_CONTINUE,
+    EFI_PXE_BASE_CODE_CALLBACK_STATUS_ABORT,
+    EFI_PXE_BASE_CODE_CALLBACK_STATUS_LAST
+} EFI_PXE_BASE_CODE_CALLBACK_STATUS;
+
+typedef
+EFI_PXE_BASE_CODE_CALLBACK_STATUS
+(EFIAPI *EFI_PXE_CALLBACK) (
+    IN struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL  *This,
+    IN EFI_PXE_BASE_CODE_FUNCTION                   Function,
+    IN BOOLEAN                                      Received,
+    IN UINT32                                       PacketLen,
+    IN EFI_PXE_BASE_CODE_PACKET                     *Packet     OPTIONAL
+    );
+
+typedef struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL {
+    UINT64                      Revision;
+    EFI_PXE_CALLBACK            Callback;
+} EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL;
+
+// Note: Because it conflicted with the EDK2 struct name, the
+// 'EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL' GUID definition, from
+// older versions of gnu-efi, is now obsoleted.
+// Use 'EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL_GUID' instead.
+
+typedef struct _EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL _EFI_PXE_BASE_CODE_CALLBACK;
+typedef EFI_PXE_BASE_CODE_CALLBACK_PROTOCOL EFI_PXE_BASE_CODE_CALLBACK;
+
+#endif /* _EFIPXEBC_H */

src/include/efi/efirtlib.h

@@ -0,0 +1,179 @@
+#ifndef _EFI_RT_LIB_INCLUDE_
+#define _EFI_RT_LIB_INCLUDE_
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efilib.h
+
+Abstract:
+
+    EFI Runtime library functions
+
+
+
+Revision History
+
+--*/
+
+#include <efi/efidebug.h>
+#include <efi/efipart.h>
+#include <efi/efilibplat.h>
+
+
+VOID
+RUNTIMEFUNCTION
+RtZeroMem (
+    IN VOID     *Buffer,
+    IN UINTN     Size
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtSetMem (
+    IN VOID     *Buffer,
+    IN UINTN    Size,
+    IN UINT8    Value    
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtCopyMem (
+    IN VOID     *Dest,
+    IN CONST VOID     *Src,
+    IN UINTN    len
+    );
+
+INTN
+RUNTIMEFUNCTION
+RtCompareMem (
+    IN CONST VOID     *Dest,
+    IN CONST VOID     *Src,
+    IN UINTN    len
+    );
+
+INTN
+RUNTIMEFUNCTION
+RtStrCmp (
+    IN CONST CHAR16   *s1,
+    IN CONST CHAR16   *s2
+    );
+
+
+VOID
+RUNTIMEFUNCTION
+RtStrCpy (
+    IN CHAR16   *Dest,
+    IN CONST CHAR16    *Src
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtStrnCpy (
+    IN CHAR16   *Dest,
+    IN CONST CHAR16    *Src,
+    IN UINTN     Len
+    );
+
+CHAR16 *
+RUNTIMEFUNCTION
+RtStpCpy (
+    IN CHAR16   *Dest,
+    IN CONST CHAR16    *Src
+    );
+
+CHAR16 *
+RUNTIMEFUNCTION
+RtStpnCpy (
+    IN CHAR16   *Dest,
+    IN CONST CHAR16    *Src,
+    IN UINTN     Len
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtStrCat (
+    IN CHAR16   *Dest,
+    IN CONST CHAR16   *Src
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtStrnCat (
+    IN CHAR16   *Dest,
+    IN CONST CHAR16   *Src,
+    IN UINTN     Len
+    );
+
+UINTN
+RUNTIMEFUNCTION
+RtStrLen (
+    IN CONST CHAR16   *s1
+    );
+
+UINTN
+RUNTIMEFUNCTION
+RtStrnLen (
+    IN CONST CHAR16   *s1,
+    IN UINTN           Len
+    );
+
+UINTN
+RUNTIMEFUNCTION
+RtStrSize (
+    IN CONST CHAR16   *s1
+    );
+
+INTN
+RUNTIMEFUNCTION
+RtCompareGuid (
+    IN EFI_GUID     *Guid1,
+    IN EFI_GUID     *Guid2
+    );
+
+UINT8
+RUNTIMEFUNCTION
+RtDecimaltoBCD(
+    IN  UINT8 BcdValue
+    );
+
+UINT8
+RUNTIMEFUNCTION
+RtBCDtoDecimal(
+    IN  UINT8 BcdValue
+    );
+
+//
+// Virtual mapping transition support.  (Only used during
+// the virtual address change transisition)
+//
+
+VOID
+RUNTIMEFUNCTION
+RtLibEnableVirtualMappings (
+    VOID
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtConvertList (
+    IN UINTN            DebugDisposition,
+    IN OUT LIST_ENTRY   *ListHead
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtAcquireLock (
+    IN FLOCK    *Lock
+    );
+
+VOID
+RUNTIMEFUNCTION
+RtReleaseLock (
+    IN FLOCK    *Lock
+    );
+
+
+#endif

src/include/efi/efiser.h

@@ -0,0 +1,136 @@
+#ifndef _EFI_SER_H
+#define _EFI_SER_H
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efiser.h
+
+Abstract:
+
+    EFI serial protocol
+
+Revision History
+
+--*/
+
+//
+// Serial protocol
+//
+
+#define EFI_SERIAL_IO_PROTOCOL_GUID \
+    { 0xBB25CF6F, 0xF1D4, 0x11D2, {0x9A, 0x0C, 0x00, 0x90, 0x27, 0x3F, 0xC1, 0xFD} }
+#define SERIAL_IO_PROTOCOL EFI_SERIAL_IO_PROTOCOL_GUID
+
+INTERFACE_DECL(_EFI_SERIAL_IO_PROTOCOL);
+
+typedef enum {
+    DefaultParity,
+    NoParity,
+    EvenParity,
+    OddParity,
+    MarkParity,
+    SpaceParity
+} EFI_PARITY_TYPE;
+
+typedef enum {
+    DefaultStopBits,
+    OneStopBit,         // 1 stop bit
+    OneFiveStopBits,    // 1.5 stop bits
+    TwoStopBits         // 2 stop bits
+} EFI_STOP_BITS_TYPE;
+
+#define EFI_SERIAL_CLEAR_TO_SEND                   0x0010  // RO
+#define EFI_SERIAL_DATA_SET_READY                  0x0020  // RO
+#define EFI_SERIAL_RING_INDICATE                   0x0040  // RO
+#define EFI_SERIAL_CARRIER_DETECT                  0x0080  // RO
+#define EFI_SERIAL_REQUEST_TO_SEND                 0x0002  // WO
+#define EFI_SERIAL_DATA_TERMINAL_READY             0x0001  // WO
+#define EFI_SERIAL_INPUT_BUFFER_EMPTY              0x0100  // RO
+#define EFI_SERIAL_OUTPUT_BUFFER_EMPTY             0x0200  // RO
+#define EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE        0x1000  // RW
+#define EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE        0x2000  // RW
+#define EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE    0x4000  // RW
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_RESET) (
+    IN struct _EFI_SERIAL_IO_PROTOCOL  *This
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_SET_ATTRIBUTES) (
+    IN struct _EFI_SERIAL_IO_PROTOCOL  *This,
+    IN UINT64                          BaudRate,
+    IN UINT32                          ReceiveFifoDepth,
+    IN UINT32                          Timeout,
+    IN EFI_PARITY_TYPE                 Parity,
+    IN UINT8                           DataBits,
+    IN EFI_STOP_BITS_TYPE              StopBits
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_SET_CONTROL_BITS) (
+    IN struct _EFI_SERIAL_IO_PROTOCOL  *This,
+    IN UINT32                          Control
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_GET_CONTROL_BITS) (
+    IN struct _EFI_SERIAL_IO_PROTOCOL  *This,
+    OUT UINT32                         *Control
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_WRITE) (
+    IN struct _EFI_SERIAL_IO_PROTOCOL  *This,
+    IN OUT UINTN                       *BufferSize,
+    IN VOID                            *Buffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SERIAL_READ) (
+    IN struct _EFI_SERIAL_IO_PROTOCOL  *This,
+    IN OUT UINTN                       *BufferSize,
+    OUT VOID                           *Buffer
+    );
+
+typedef struct {
+    UINT32                  ControlMask;
+
+    // current Attributes
+    UINT32                  Timeout;
+    UINT64                  BaudRate;
+    UINT32                  ReceiveFifoDepth;
+    UINT32                  DataBits;
+    UINT32                  Parity;
+    UINT32                  StopBits;
+} SERIAL_IO_MODE;
+
+#define SERIAL_IO_INTERFACE_REVISION    0x00010000
+
+typedef struct _EFI_SERIAL_IO_PROTOCOL {
+    UINT32                       Revision;
+    EFI_SERIAL_RESET             Reset;
+    EFI_SERIAL_SET_ATTRIBUTES    SetAttributes;
+    EFI_SERIAL_SET_CONTROL_BITS  SetControl;
+    EFI_SERIAL_GET_CONTROL_BITS  GetControl;
+    EFI_SERIAL_WRITE             Write;
+    EFI_SERIAL_READ              Read;
+
+    SERIAL_IO_MODE               *Mode;
+} EFI_SERIAL_IO_PROTOCOL;
+
+typedef struct _EFI_SERIAL_IO_PROTOCOL _SERIAL_IO_INTERFACE;
+typedef EFI_SERIAL_IO_PROTOCOL SERIAL_IO_INTERFACE;
+
+#endif
+

src/include/efi/efisetjmp.h

@@ -0,0 +1,19 @@
+#ifndef GNU_EFI_SETJMP_H
+#define GNU_EFI_SETJMP_H
+
+#include <efi/eficompiler.h>
+#include <efi/efisetjmp_arch.h>
+
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#if ! __has_builtin(setjmp)
+extern UINTN setjmp(jmp_buf *env) __attribute__((returns_twice));
+#endif
+
+#if ! __has_builtin(longjmp)
+extern VOID longjmp(jmp_buf *env, UINTN value) __attribute__((noreturn));
+#endif
+
+#endif /* GNU_EFI_SETJMP_H */

src/include/efi/efishellintf.h

@@ -0,0 +1,94 @@
+/** @file
+  SHELL_INTERFACE_PROTOCOL from EDK shell (no spec).
+
+  Shell Interface - additional information (over image_info) provided
+  to an application started by the shell.
+
+  ConIo provides a file-style interface to the console.
+
+  The shell interface's and data (including ConIo) are only valid during
+  the applications Entry Point.  Once the application returns from it's
+  entry point the data is freed by the invoking shell.
+
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*
+ * This is based on ShellPkg/Include/Protocol/EfiShellInterface.h from EDK II.
+ */
+
+#ifndef _SHELLINTERFACE_H_
+#define _SHELLINTERFACE_H_
+
+
+#define SHELL_INTERFACE_PROTOCOL_GUID \
+  { \
+    0x47c7b223, 0xc42a, 0x11d2, {0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} \
+  }
+
+///
+/// Bit definitions for EFI_SHELL_ARG_INFO
+///
+typedef enum {
+  ARG_NO_ATTRIB         = 0x0,
+  ARG_IS_QUOTED         = 1<<0,
+  ARG_PARTIALLY_QUOTED  = 1<<1,
+  ARG_FIRST_HALF_QUOTED = 1<<2,
+  ARG_FIRST_CHAR_IS_ESC = 1<<3
+} EFI_SHELL_ARG_INFO_TYPES;
+
+///
+/// Attributes for an argument.
+///
+typedef struct _EFI_SHELL_ARG_INFO {
+  UINT32  Attributes;
+} EFI_SHELL_ARG_INFO;
+
+///
+/// This protocol provides access to additional information about a shell application.
+///
+typedef struct {
+  ///
+  /// Handle back to original image handle & image information.
+  ///
+  EFI_HANDLE                ImageHandle;
+  EFI_LOADED_IMAGE *Info;
+
+  ///
+  /// Parsed arg list converted more C-like format.
+  ///
+  CHAR16                    **Argv;
+  UINTN                     Argc;
+
+  ///
+  /// Storage for file redirection args after parsing.
+  ///
+  CHAR16                    **RedirArgv;
+  UINTN                     RedirArgc;
+
+  ///
+  /// A file style handle for console io.
+  ///
+  EFI_FILE         *StdIn;
+  EFI_FILE         *StdOut;
+  EFI_FILE         *StdErr;
+
+  ///
+  /// List of attributes for each argument.
+  ///
+  EFI_SHELL_ARG_INFO        *ArgInfo;
+
+  ///
+  /// Whether we are echoing.
+  ///
+  BOOLEAN                   EchoOn;
+} EFI_SHELL_INTERFACE;
+
+#endif

src/include/efi/efishellparm.h

@@ -0,0 +1,63 @@
+/** @file
+  EFI_SHELL_PARAMETERS_PROTOCOL as defined in the UEFI Shell 2.0 specification.
+
+  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
+  are licensed and made available under the terms and conditions of the BSD License
+  which accompanies this distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*
+ * This is based on ShellPkg/Include/Protocol/EfiShellParameters.h from EDK II.
+ */
+
+#ifndef __EFI_SHELL_PARAMETERS_PROTOCOL__
+#define __EFI_SHELL_PARAMETERS_PROTOCOL__
+
+
+// EDK2's ShellBase.h
+typedef VOID *SHELL_FILE_HANDLE;
+
+#define EFI_SHELL_PARAMETERS_PROTOCOL_GUID \
+  { \
+  0x752f3136, 0x4e16, 0x4fdc, { 0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca } \
+  }
+
+typedef struct _EFI_SHELL_PARAMETERS_PROTOCOL {
+  ///
+  /// Points to an Argc-element array of points to NULL-terminated strings containing
+  /// the command-line parameters. The first entry in the array is always the full file
+  /// path of the executable. Any quotation marks that were used to preserve
+  /// whitespace have been removed.
+  ///
+  CHAR16 **Argv;
+
+  ///
+  /// The number of elements in the Argv array.
+  ///
+  UINTN Argc;
+
+  ///
+  /// The file handle for the standard input for this executable. This may be different
+  /// from the ConInHandle in EFI_SYSTEM_TABLE.
+  ///
+  SHELL_FILE_HANDLE StdIn;
+
+  ///
+  /// The file handle for the standard output for this executable. This may be different
+  /// from the ConOutHandle in EFI_SYSTEM_TABLE.
+  ///
+  SHELL_FILE_HANDLE StdOut;
+
+  ///
+  /// The file handle for the standard error output for this executable. This may be
+  /// different from the StdErrHandle in EFI_SYSTEM_TABLE.
+  ///
+  SHELL_FILE_HANDLE StdErr;
+} EFI_SHELL_PARAMETERS_PROTOCOL;
+
+#endif

src/include/efi/efistdarg.h

@@ -0,0 +1,33 @@
+#ifndef _EFISTDARG_H_
+#define _EFISTDARG_H_
+
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    devpath.h
+
+Abstract:
+
+    Defines for parsing the EFI Device Path structures
+
+
+
+Revision History
+
+--*/
+
+#ifndef GNU_EFI_USE_EXTERNAL_STDARG
+typedef __builtin_va_list va_list;
+
+# define va_start(v,l)	__builtin_va_start(v,l)
+# define va_end(v)	__builtin_va_end(v)
+# define va_arg(v,l)	__builtin_va_arg(v,l)
+# define va_copy(d,s)	__builtin_va_copy(d,s)
+#else
+# include <stdarg.h>
+#endif
+
+#endif

src/include/efi/efitcp.h

@@ -0,0 +1,391 @@
+#ifndef _EFI_TCP_H
+#define _EFI_TCP_H
+
+/*++
+Copyright (c) 2013  Intel Corporation
+
+--*/
+
+#define EFI_TCP4_SERVICE_BINDING_PROTOCOL \
+    { 0x00720665, 0x67eb, 0x4a99, {0xba, 0xf7, 0xd3, 0xc3, 0x3a, 0x1c,0x7c, 0xc9}}
+
+#define EFI_TCP4_PROTOCOL \
+    { 0x65530bc7, 0xa359, 0x410f, {0xb0, 0x10, 0x5a, 0xad, 0xc7, 0xec, 0x2b, 0x62}}
+
+#define EFI_TCP6_SERVICE_BINDING_PROTOCOL \
+    { 0xec20eb79, 0x6c1a, 0x4664, {0x9a, 0xd, 0xd2, 0xe4, 0xcc, 0x16, 0xd6, 0x64}}
+
+#define EFI_TCP6_PROTOCOL \
+    { 0x46e44855, 0xbd60, 0x4ab7, {0xab, 0xd, 0xa6, 0x79, 0xb9, 0x44, 0x7d, 0x77}}
+
+INTERFACE_DECL(_EFI_TCP4);
+INTERFACE_DECL(_EFI_TCP6);
+
+typedef struct {
+    BOOLEAN            UseDefaultAddress;
+    EFI_IPv4_ADDRESS   StationAddress;
+    EFI_IPv4_ADDRESS   SubnetMask;
+    UINT16             StationPort;
+    EFI_IPv4_ADDRESS   RemoteAddress;
+    UINT16             RemotePort;
+    BOOLEAN            ActiveFlag;
+} EFI_TCP4_ACCESS_POINT;
+
+typedef struct {
+    UINT32             ReceiveBufferSize;
+    UINT32             SendBufferSize;
+    UINT32             MaxSynBackLog;
+    UINT32             ConnectionTimeout;
+    UINT32             DataRetries;
+    UINT32             FinTimeout;
+    UINT32             TimeWaitTimeout;
+    UINT32             KeepAliveProbes;
+    UINT32             KeepAliveTime;
+    UINT32             KeepAliveInterval;
+    BOOLEAN            EnableNagle;
+    BOOLEAN            EnableTimeStamp;
+    BOOLEAN            EnableWindowScaling;
+    BOOLEAN            EnableSelectiveAck;
+    BOOLEAN            EnablePAthMtuDiscovery;
+} EFI_TCP4_OPTION;
+
+typedef struct {
+    // Receiving Filters
+    // I/O parameters
+    UINT8                 TypeOfService;
+    UINT8                 TimeToLive;
+
+    // Access Point
+    EFI_TCP4_ACCESS_POINT AccessPoint;
+
+    // TCP Control Options
+    EFI_TCP4_OPTION       *ControlOption;
+} EFI_TCP4_CONFIG_DATA;
+
+typedef enum {
+    Tcp4StateClosed      = 0,
+    Tcp4StateListen      = 1,
+    Tcp4StateSynSent     = 2,
+    Tcp4StateSynReceived = 3,
+    Tcp4StateEstablished = 4,
+    Tcp4StateFinWait1    = 5,
+    Tcp4StateFinWait2    = 6,
+    Tcp4StateClosing     = 7,
+    Tcp4StateTimeWait    = 8,
+    Tcp4StateCloseWait   = 9,
+    Tcp4StateLastAck     = 10
+} EFI_TCP4_CONNECTION_STATE;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_GET_MODE_DATA) (
+    IN struct _EFI_TCP4                 *This,
+    OUT EFI_TCP4_CONNECTION_STATE       *Tcp4State      OPTIONAL,
+    OUT EFI_TCP4_CONFIG_DATA            *Tcp4ConfigData OPTIONAL,
+    OUT EFI_IP4_MODE_DATA               *Ip4ModeData    OPTIONAL,
+    OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData  OPTIONAL,
+    OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData    OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CONFIGURE) (
+    IN struct _EFI_TCP4     *This,
+    IN EFI_TCP4_CONFIG_DATA *TcpConfigData OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_ROUTES) (
+    IN struct _EFI_TCP4 *This,
+    IN BOOLEAN          DeleteRoute,
+    IN EFI_IPv4_ADDRESS *SubnetAddress,
+    IN EFI_IPv4_ADDRESS *SubnetMask,
+    IN EFI_IPv4_ADDRESS *GatewayAddress
+);
+
+typedef struct {
+    EFI_EVENT  Event;
+    EFI_STATUS Status;
+} EFI_TCP4_COMPLETION_TOKEN;
+
+typedef struct {
+    EFI_TCP4_COMPLETION_TOKEN CompletionToken;
+} EFI_TCP4_CONNECTION_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CONNECT) (
+    IN struct _EFI_TCP4          *This,
+    IN EFI_TCP4_CONNECTION_TOKEN *ConnectionToken
+    );
+
+typedef struct {
+    EFI_TCP4_COMPLETION_TOKEN CompletionToken;
+    EFI_HANDLE                NewChildHandle;
+} EFI_TCP4_LISTEN_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_ACCEPT) (
+    IN struct _EFI_TCP4      *This,
+    IN EFI_TCP4_LISTEN_TOKEN *ListenToken
+    );
+
+#define EFI_CONNECTION_FIN     EFIERR(104)
+#define EFI_CONNECTION_RESET   EFIERR(105)
+#define EFI_CONNECTION_REFUSED EFIERR(106)
+
+typedef struct {
+    UINT32 FragmentLength;
+    VOID   *FragmentBuffer;
+} EFI_TCP4_FRAGMENT_DATA;
+
+typedef struct {
+    BOOLEAN                UrgentFlag;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_TCP4_FRAGMENT_DATA FragmentTable[1];
+} EFI_TCP4_RECEIVE_DATA;
+
+typedef struct {
+    BOOLEAN                Push;
+    BOOLEAN                Urgent;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_TCP4_FRAGMENT_DATA FragmentTable[1];
+} EFI_TCP4_TRANSMIT_DATA;
+
+typedef struct {
+    EFI_TCP4_COMPLETION_TOKEN  CompletionToken;
+    union {
+	EFI_TCP4_RECEIVE_DATA  *RxData;
+	EFI_TCP4_TRANSMIT_DATA *TxData;
+    }                          Packet;
+} EFI_TCP4_IO_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_TRANSMIT) (
+    IN struct _EFI_TCP4  *This,
+    IN EFI_TCP4_IO_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_RECEIVE) (
+    IN struct _EFI_TCP4  *This,
+    IN EFI_TCP4_IO_TOKEN *Token
+    );
+
+typedef struct {
+    EFI_TCP4_COMPLETION_TOKEN CompletionToken;
+    BOOLEAN                   AbortOnClose;
+} EFI_TCP4_CLOSE_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CLOSE)(
+    IN struct _EFI_TCP4     *This,
+    IN EFI_TCP4_CLOSE_TOKEN *CloseToken
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_CANCEL)(
+    IN struct _EFI_TCP4 *This,
+    IN EFI_TCP4_COMPLETION_TOKEN *Token OPTIONAL
+);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP4_POLL) (
+    IN struct _EFI_TCP4 *This
+    );
+
+typedef struct _EFI_TCP4 {
+    EFI_TCP4_GET_MODE_DATA GetModeData;
+    EFI_TCP4_CONFIGURE     Configure;
+    EFI_TCP4_ROUTES        Routes;
+    EFI_TCP4_CONNECT       Connect;
+    EFI_TCP4_ACCEPT        Accept;
+    EFI_TCP4_TRANSMIT      Transmit;
+    EFI_TCP4_RECEIVE       Receive;
+    EFI_TCP4_CLOSE         Close;
+    EFI_TCP4_CANCEL        Cancel;
+    EFI_TCP4_POLL          Poll;
+} EFI_TCP4;
+
+typedef enum {
+    Tcp6StateClosed      = 0,
+    Tcp6StateListen      = 1,
+    Tcp6StateSynSent     = 2,
+    Tcp6StateSynReceived = 3,
+    Tcp6StateEstablished = 4,
+    Tcp6StateFinWait1    = 5,
+    Tcp6StateFinWait2    = 6,
+    Tcp6StateClosing     = 7,
+    Tcp6StateTimeWait    = 8,
+    Tcp6StateCloseWait   = 9,
+    Tcp6StateLastAck     = 10
+} EFI_TCP6_CONNECTION_STATE;
+
+typedef struct {
+    EFI_IPv6_ADDRESS StationAddress;
+    UINT16           StationPort;
+    EFI_IPv6_ADDRESS RemoteAddress;
+    UINT16           RemotePort;
+    BOOLEAN          ActiveFlag;
+} EFI_TCP6_ACCESS_POINT;
+
+typedef struct {
+    UINT32             ReceiveBufferSize;
+    UINT32             SendBufferSize;
+    UINT32             MaxSynBackLog;
+    UINT32             ConnectionTimeout;
+    UINT32             DataRetries;
+    UINT32             FinTimeout;
+    UINT32             TimeWaitTimeout;
+    UINT32             KeepAliveProbes;
+    UINT32             KeepAliveTime;
+    UINT32             KeepAliveInterval;
+    BOOLEAN            EnableNagle;
+    BOOLEAN            EnableTimeStamp;
+    BOOLEAN            EnableWindbowScaling;
+    BOOLEAN            EnableSelectiveAck;
+    BOOLEAN            EnablePathMtuDiscovery;
+} EFI_TCP6_OPTION;
+
+typedef struct {
+    UINT8                 TrafficClass;
+    UINT8                 HopLimit;
+    EFI_TCP6_ACCESS_POINT AccessPoint;
+    EFI_TCP6_OPTION       *ControlOption;
+} EFI_TCP6_CONFIG_DATA;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_GET_MODE_DATA) (
+    IN struct _EFI_TCP6                 *This,
+    OUT EFI_TCP6_CONNECTION_STATE       *Tcp6State      OPTIONAL,
+    OUT EFI_TCP6_CONFIG_DATA            *Tcp6ConfigData OPTIONAL,
+    OUT EFI_IP6_MODE_DATA               *Ip6ModeData    OPTIONAL,
+    OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData  OPTIONAL,
+    OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData    OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CONFIGURE) (
+    IN struct _EFI_TCP6     *This,
+    IN EFI_TCP6_CONFIG_DATA *Tcp6ConfigData OPTIONAL
+    );
+
+typedef struct {
+    EFI_EVENT  Event;
+    EFI_STATUS Status;
+} EFI_TCP6_COMPLETION_TOKEN;
+
+typedef struct {
+    EFI_TCP6_COMPLETION_TOKEN CompletionToken;
+} EFI_TCP6_CONNECTION_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CONNECT) (
+    IN struct _EFI_TCP6          *This,
+    IN EFI_TCP6_CONNECTION_TOKEN *ConnectionToken
+    );
+
+typedef struct {
+    EFI_TCP6_COMPLETION_TOKEN CompletionToken;
+    EFI_HANDLE                NewChildHandle;
+} EFI_TCP6_LISTEN_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_ACCEPT) (
+    IN struct _EFI_TCP6      *This,
+    IN EFI_TCP6_LISTEN_TOKEN *ListenToken
+    );
+
+typedef struct {
+    UINT32 FragmentLength;
+    VOID   *FragmentBuffer;
+} EFI_TCP6_FRAGMENT_DATA;
+
+typedef struct {
+    BOOLEAN                UrgentFlag;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_TCP6_FRAGMENT_DATA FragmentTable[1];
+} EFI_TCP6_RECEIVE_DATA;
+
+typedef struct {
+    BOOLEAN                Push;
+    BOOLEAN                Urgent;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_TCP6_FRAGMENT_DATA FragmentTable[1];
+} EFI_TCP6_TRANSMIT_DATA;
+
+typedef struct {
+    EFI_TCP6_COMPLETION_TOKEN  CompletionToken;
+    union {
+	EFI_TCP6_RECEIVE_DATA  *RxData;
+	EFI_TCP6_TRANSMIT_DATA *TxData;
+    }                          Packet;
+} EFI_TCP6_IO_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_TRANSMIT) (
+    IN struct _EFI_TCP6  *This,
+    IN EFI_TCP6_IO_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_RECEIVE) (
+    IN struct _EFI_TCP6  *This,
+    IN EFI_TCP6_IO_TOKEN *Token
+    );
+
+typedef struct {
+    EFI_TCP6_COMPLETION_TOKEN CompletionToken;
+    BOOLEAN                   AbortOnClose;
+} EFI_TCP6_CLOSE_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CLOSE)(
+    IN struct _EFI_TCP6     *This,
+    IN EFI_TCP6_CLOSE_TOKEN *CloseToken
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_CANCEL)(
+    IN struct _EFI_TCP6          *This,
+    IN EFI_TCP6_COMPLETION_TOKEN *Token OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TCP6_POLL) (
+    IN struct _EFI_TCP6 *This
+    );
+
+typedef struct _EFI_TCP6 {
+    EFI_TCP6_GET_MODE_DATA GetModeData;
+    EFI_TCP6_CONFIGURE     Configure;
+    EFI_TCP6_CONNECT       Connect;
+    EFI_TCP6_ACCEPT        Accept;
+    EFI_TCP6_TRANSMIT      Transmit;
+    EFI_TCP6_RECEIVE       Receive;
+    EFI_TCP6_CLOSE         Close;
+    EFI_TCP6_CANCEL        Cancel;
+    EFI_TCP6_POLL          Poll;
+} EFI_TCP6;
+
+#endif /* _EFI_TCP_H */

src/include/efi/efiudp.h

@@ -0,0 +1,272 @@
+#ifndef _EFI_UDP_H
+#define _EFI_UDP_H
+
+
+/*++
+Copyright (c) 2013  Intel Corporation
+
+--*/
+
+#define EFI_UDP4_SERVICE_BINDING_PROTOCOL \
+    { 0x83f01464, 0x99bd, 0x45e5, {0xb3, 0x83, 0xaf, 0x63, 0x05, 0xd8, 0xe9, 0xe6} }
+
+#define EFI_UDP4_PROTOCOL \
+    { 0x3ad9df29, 0x4501, 0x478d, {0xb1, 0xf8, 0x7f, 0x7f, 0xe7, 0x0e, 0x50, 0xf3} }
+
+#define EFI_UDP6_SERVICE_BINDING_PROTOCOL \
+    { 0x66ed4721, 0x3c98, 0x4d3e, {0x81, 0xe3, 0xd0, 0x3d, 0xd3, 0x9a, 0x72, 0x54} }
+
+#define EFI_UDP6_PROTOCOL \
+    { 0x4f948815, 0xb4b9, 0x43cb, {0x8a, 0x33, 0x90, 0xe0, 0x60, 0xb3,0x49, 0x55} }
+
+INTERFACE_DECL(_EFI_UDP4);
+INTERFACE_DECL(_EFI_UDP6);
+
+typedef struct {
+    BOOLEAN          AcceptBroadcast;
+    BOOLEAN          AcceptPromiscuous;
+    BOOLEAN          AcceptAnyPort;
+    BOOLEAN          AllowDuplicatePort;
+    UINT8            TypeOfService;
+    UINT8            TimeToLive;
+    BOOLEAN          DoNotFragment;
+    UINT32           ReceiveTimeout;
+    UINT32           TransmitTimeout;
+    BOOLEAN          UseDefaultAddress;
+    EFI_IPv4_ADDRESS StationAddress;
+    EFI_IPv4_ADDRESS SubnetMask;
+    UINT16           StationPort;
+    EFI_IPv4_ADDRESS RemoteAddress;
+    UINT16           RemotePort;
+} EFI_UDP4_CONFIG_DATA;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_GET_MODE_DATA) (
+    IN struct _EFI_UDP4                 *This,
+    OUT EFI_UDP4_CONFIG_DATA            *Udp4ConfigData OPTIONAL,
+    OUT EFI_IP4_MODE_DATA               *Ip4ModeData    OPTIONAL,
+    OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData  OPTIONAL,
+    OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData    OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_CONFIGURE) (
+    IN struct _EFI_UDP4     *This,
+    IN EFI_UDP4_CONFIG_DATA *UdpConfigData OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_GROUPS) (
+    IN struct _EFI_UDP4 *This,
+    IN BOOLEAN          JoinFlag,
+    IN EFI_IPv4_ADDRESS *MulticastAddress OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_ROUTES) (
+    IN struct _EFI_UDP4 *This,
+    IN BOOLEAN          DeleteRoute,
+    IN EFI_IPv4_ADDRESS *SubnetAddress,
+    IN EFI_IPv4_ADDRESS *SubnetMask,
+    IN EFI_IPv4_ADDRESS *GatewayAddress
+    );
+
+#define EFI_NETWORK_UNREACHABLE  EFIERR(100)
+#define EFI_HOST_UNREACHABLE     EFIERR(101)
+#define EFI_PROTOCOL_UNREACHABLE EFIERR(102)
+#define EFI_PORT_UNREACHABLE     EFIERR(103)
+
+typedef struct {
+    EFI_IPv4_ADDRESS SourceAddress;
+    UINT16           SourcePort;
+    EFI_IPv4_ADDRESS DestinationAddress;
+    UINT16           DestinationPort;
+} EFI_UDP4_SESSION_DATA;
+
+typedef struct {
+    UINT32 FragmentLength;
+    VOID   *FragmentBuffer;
+} EFI_UDP4_FRAGMENT_DATA;
+
+typedef struct {
+    EFI_TIME               TimeStamp;
+    EFI_EVENT              RecycleSignal;
+    EFI_UDP4_SESSION_DATA  UdpSession;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_UDP4_FRAGMENT_DATA FragmentTable[1];
+} EFI_UDP4_RECEIVE_DATA;
+
+typedef struct {
+    EFI_UDP4_SESSION_DATA  *UdpSessionData;
+    EFI_IPv4_ADDRESS       *GatewayAddress;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_UDP4_FRAGMENT_DATA FragmentTable[1];
+} EFI_UDP4_TRANSMIT_DATA;
+
+typedef struct {
+    EFI_EVENT                  Event;
+    EFI_STATUS                 Status;
+    union {
+        EFI_UDP4_RECEIVE_DATA  *RxData;
+	EFI_UDP4_TRANSMIT_DATA *TxData;
+    }                          Packet;
+} EFI_UDP4_COMPLETION_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_TRANSMIT) (
+    IN struct _EFI_UDP4          *This,
+    IN EFI_UDP4_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_RECEIVE) (
+    IN struct _EFI_UDP4          *This,
+    IN EFI_UDP4_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_CANCEL)(
+    IN struct _EFI_UDP4          *This,
+    IN EFI_UDP4_COMPLETION_TOKEN *Token OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP4_POLL) (
+    IN struct _EFI_UDP4 *This
+    );
+
+typedef struct _EFI_UDP4 {
+    EFI_UDP4_GET_MODE_DATA GetModeData;
+    EFI_UDP4_CONFIGURE     Configure;
+    EFI_UDP4_GROUPS        Groups;
+    EFI_UDP4_ROUTES        Routes;
+    EFI_UDP4_TRANSMIT      Transmit;
+    EFI_UDP4_RECEIVE       Receive;
+    EFI_UDP4_CANCEL        Cancel;
+    EFI_UDP4_POLL          Poll;
+} EFI_UDP4;
+
+typedef struct {
+    BOOLEAN          AcceptPromiscuous;
+    BOOLEAN          AcceptAnyPort;
+    BOOLEAN          AllowDuplicatePort;
+    UINT8            TrafficClass;
+    UINT8            HopLimit;
+    UINT32           ReceiveTimeout;
+    UINT32           TransmitTimeout;
+    EFI_IPv6_ADDRESS StationAddress;
+    UINT16           StationPort;
+    EFI_IPv6_ADDRESS RemoteAddress;
+    UINT16           RemotePort;
+} EFI_UDP6_CONFIG_DATA;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_GET_MODE_DATA) (
+    IN struct _EFI_UDP6                 *This,
+    OUT EFI_UDP6_CONFIG_DATA            *Udp6ConfigData OPTIONAL,
+    OUT EFI_IP6_MODE_DATA               *Ip6ModeData    OPTIONAL,
+    OUT EFI_MANAGED_NETWORK_CONFIG_DATA *MnpConfigData  OPTIONAL,
+    OUT EFI_SIMPLE_NETWORK_MODE         *SnpModeData    OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_CONFIGURE) (
+    IN struct _EFI_UDP6     *This,
+    IN EFI_UDP6_CONFIG_DATA *UdpConfigData OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_GROUPS) (
+    IN struct _EFI_UDP6 *This,
+    IN BOOLEAN          JoinFlag,
+    IN EFI_IPv6_ADDRESS *MulticastAddress OPTIONAL
+    );
+
+typedef struct {
+    EFI_IPv6_ADDRESS SourceAddress;
+    UINT16           SourcePort;
+    EFI_IPv6_ADDRESS DestinationAddress;
+    UINT16           DestinationPort;
+} EFI_UDP6_SESSION_DATA;
+
+typedef struct {
+    UINT32 FragmentLength;
+    VOID   *FragmentBuffer;
+} EFI_UDP6_FRAGMENT_DATA;
+
+typedef struct {
+    EFI_TIME               TimeStamp;
+    EFI_EVENT              RecycleSignal;
+    EFI_UDP6_SESSION_DATA  UdpSession;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_UDP6_FRAGMENT_DATA FragmentTable[1];
+} EFI_UDP6_RECEIVE_DATA;
+
+typedef struct {
+    EFI_UDP6_SESSION_DATA  *UdpSessionData;
+    UINT32                 DataLength;
+    UINT32                 FragmentCount;
+    EFI_UDP6_FRAGMENT_DATA FragmentTable[1];
+} EFI_UDP6_TRANSMIT_DATA;
+
+typedef struct {
+    EFI_EVENT                  Event;
+    EFI_STATUS                 Status;
+    union {
+        EFI_UDP6_RECEIVE_DATA  *RxData;
+        EFI_UDP6_TRANSMIT_DATA *TxData;
+    }                          Packet;
+} EFI_UDP6_COMPLETION_TOKEN;
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_TRANSMIT) (
+    IN struct _EFI_UDP6          *This,
+    IN EFI_UDP6_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_RECEIVE) (
+    IN struct _EFI_UDP6          *This,
+    IN EFI_UDP6_COMPLETION_TOKEN *Token
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_CANCEL)(
+    IN struct _EFI_UDP6          *This,
+    IN EFI_UDP6_COMPLETION_TOKEN *Token OPTIONAL
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UDP6_POLL) (
+    IN struct _EFI_UDP6 *This
+    );
+
+typedef struct _EFI_UDP6 {
+    EFI_UDP6_GET_MODE_DATA GetModeData;
+    EFI_UDP6_CONFIGURE     Configure;
+    EFI_UDP6_GROUPS        Groups;
+    EFI_UDP6_TRANSMIT      Transmit;
+    EFI_UDP6_RECEIVE       Receive;
+    EFI_UDP6_CANCEL        Cancel;
+    EFI_UDP6_POLL          Poll;
+} EFI_UDP6;
+
+#endif /* _EFI_UDP_H */

src/include/efi/efiui.h

@@ -0,0 +1,58 @@
+#ifndef _EFI_UI_H
+#define _EFI_UI_H
+
+/*++
+
+Copyright (c) 200  Intel Corporation
+
+Module Name:
+
+    EfiUi.h
+
+Abstract:
+    Protocol used to build User Interface (UI) stuff.
+
+    This protocol is just data. It is a multi dimentional array.
+    For each string there is an array of UI_STRING_ENTRY. Each string
+    is for a different language translation of the same string. The list
+    is terminated by a NULL UiString. There can be any number of
+    UI_STRING_ENTRY arrays. A NULL array terminates the list. A NULL array
+    entry contains all zeros.
+
+    Thus the shortest possible EFI_UI_PROTOCOL has three UI_STRING_ENTRY.
+    The String, it's NULL terminator, and the NULL terminator for the entire
+    thing.
+
+
+Revision History
+
+--*/
+
+#define EFI_UI_INTERFACE_PROTOCOL_GUID \
+    { 0x32dd7981, 0x2d27, 0x11d4, {0xbc, 0x8b, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} }
+#define EFI_UI_PROTOCOL EFI_UI_INTERFACE_PROTOCOL_GUID
+
+
+typedef enum {
+    UiDeviceString,
+    UiVendorString,
+    UiMaxString
+} UI_STRING_TYPE;
+
+typedef struct {
+    ISO_639_2   *LangCode;
+    CHAR16      *UiString;
+} UI_STRING_ENTRY;
+
+#define EFI_UI_INTERFACE_PROTOCOL_VERSION 0x00010000
+#define EFI_UI_VERSION                    EFI_UI_INTERFACE_PROTOCOL_VERSION
+
+typedef struct _EFI_UI_INTERFACE_PROTOCOL {
+    UINT32          Version;
+    UI_STRING_ENTRY *Entry;
+} EFI_UI_INTERFACE_PROTOCOL;
+
+typedef struct _EFI_UI_INTERFACE_PROTOCOL _UI_INTERFACE;
+typedef EFI_UI_INTERFACE_PROTOCOL UI_INTERFACE;
+
+#endif

src/include/efi/libsmbios.h

@@ -0,0 +1,132 @@
+#ifndef _LIB_SMBIOS_H
+#define _LIB_SMBIOS_H
+/*++
+
+Copyright (c) 2000  Intel Corporation
+
+Module Name:
+
+    LibSmbios.h
+    
+Abstract:
+
+    Lib include  for SMBIOS services. Used to get system serial number and GUID
+
+Revision History
+
+--*/
+
+//
+// Define SMBIOS tables.
+//
+#pragma pack(1)
+typedef struct {
+    UINT8   AnchorString[4];
+    UINT8   EntryPointStructureChecksum;
+    UINT8   EntryPointLength;
+    UINT8   MajorVersion;
+    UINT8   MinorVersion;
+    UINT16  MaxStructureSize;
+    UINT8   EntryPointRevision;
+    UINT8   FormattedArea[5];
+    UINT8   IntermediateAnchorString[5];
+    UINT8   IntermediateChecksum;
+    UINT16  TableLength;
+    UINT32  TableAddress;
+    UINT16  NumberOfSmbiosStructures;
+    UINT8   SmbiosBcdRevision;
+} SMBIOS_STRUCTURE_TABLE;
+
+//
+// Please note that SMBIOS structures can be odd byte aligned since the
+//  unformated section of each record is a set of arbitrary size strings.
+//
+
+typedef struct {
+    UINT8   Type;
+    UINT8   Length;
+    UINT8   Handle[2];
+} SMBIOS_HEADER;
+
+typedef UINT8   SMBIOS_STRING;
+
+typedef struct {
+    SMBIOS_HEADER   Hdr;
+    SMBIOS_STRING   Vendor;
+    SMBIOS_STRING   BiosVersion;
+    UINT8           BiosSegment[2];
+    SMBIOS_STRING   BiosReleaseDate;
+    UINT8           BiosSize;
+    UINT8           BiosCharacteristics[8];
+} SMBIOS_TYPE0;
+
+typedef struct {
+    SMBIOS_HEADER   Hdr;
+    SMBIOS_STRING   Manufacturer;
+    SMBIOS_STRING   ProductName;
+    SMBIOS_STRING   Version;
+    SMBIOS_STRING   SerialNumber;
+
+    //
+    // always byte copy this data to prevent alignment faults!
+    //
+    EFI_GUID        Uuid;
+    
+    UINT8           WakeUpType;
+} SMBIOS_TYPE1;
+
+typedef struct {
+    SMBIOS_HEADER   Hdr;
+    SMBIOS_STRING   Manufacturer;
+    SMBIOS_STRING   ProductName;
+    SMBIOS_STRING   Version;
+    SMBIOS_STRING   SerialNumber;
+} SMBIOS_TYPE2;
+
+typedef struct {
+    SMBIOS_HEADER   Hdr;
+    SMBIOS_STRING   Manufacturer;
+    UINT8           Type;
+    SMBIOS_STRING   Version;
+    SMBIOS_STRING   SerialNumber;
+    SMBIOS_STRING   AssetTag;
+    UINT8           BootupState;
+    UINT8           PowerSupplyState;
+    UINT8           ThermalState;
+    UINT8           SecurityStatus;
+    UINT8           OemDefined[4];
+} SMBIOS_TYPE3;
+
+typedef struct {
+    SMBIOS_HEADER   Hdr;
+    UINT8           Socket;
+    UINT8           ProcessorType;
+    UINT8           ProcessorFamily;
+    SMBIOS_STRING   ProcessorManufacture;
+    UINT8           ProcessorId[8];
+    SMBIOS_STRING   ProcessorVersion;
+    UINT8           Voltage;
+    UINT8           ExternalClock[2];
+    UINT8           MaxSpeed[2];
+    UINT8           CurrentSpeed[2];
+    UINT8           Status;
+    UINT8           ProcessorUpgrade;
+    UINT8           L1CacheHandle[2];
+    UINT8           L2CacheHandle[2];
+    UINT8           L3CacheHandle[2];
+} SMBIOS_TYPE4;
+
+typedef union {
+    SMBIOS_HEADER   *Hdr;
+    SMBIOS_TYPE0    *Type0;
+    SMBIOS_TYPE1    *Type1;
+    SMBIOS_TYPE2    *Type2;
+    SMBIOS_TYPE3    *Type3;
+    SMBIOS_TYPE4    *Type4;
+    UINT8           *Raw;
+} SMBIOS_STRUCTURE_POINTER;
+#pragma pack()
+
+
+#endif
+

src/include/efi/pci22.h

@@ -0,0 +1,193 @@
+#ifndef _PCI22_H
+#define _PCI22_H
+
+/*++
+
+Copyright (c) 1999  Intel Corporation
+
+Module Name:
+
+    pci22.h
+    
+Abstract:      
+    Support for PCI 2.2 standard.
+
+
+
+
+Revision History
+
+--*/
+
+#ifdef SOFT_SDV
+#define PCI_MAX_BUS     1
+#else
+#define PCI_MAX_BUS     255
+#endif
+
+#define PCI_MAX_DEVICE  31
+#define PCI_MAX_FUNC    7
+
+//
+// Command
+//
+#define PCI_VGA_PALETTE_SNOOP_DISABLED   0x20
+
+#pragma pack(1)
+typedef struct {
+    UINT16      VendorId;
+    UINT16      DeviceId;
+    UINT16      Command;
+    UINT16      Status;
+    UINT8       RevisionID;
+    UINT8       ClassCode[3];
+    UINT8       CacheLineSize;
+    UINT8       LaytencyTimer;
+    UINT8       HeaderType;
+    UINT8       BIST;
+} PCI_DEVICE_INDEPENDENT_REGION;
+
+typedef struct {
+    UINT32      Bar[6];
+    UINT32      CISPtr;
+    UINT16      SubsystemVendorID;
+    UINT16      SubsystemID;
+    UINT32      ExpansionRomBar;
+    UINT32      Reserved[2];
+    UINT8       InterruptLine;
+    UINT8       InterruptPin;
+    UINT8       MinGnt;
+    UINT8       MaxLat;     
+} PCI_DEVICE_HEADER_TYPE_REGION;
+
+typedef struct {
+    PCI_DEVICE_INDEPENDENT_REGION   Hdr;
+    PCI_DEVICE_HEADER_TYPE_REGION   Device;
+} PCI_TYPE00;
+
+typedef struct {              
+    UINT32      Bar[2];
+    UINT8       PrimaryBus;
+    UINT8       SecondaryBus;
+    UINT8       SubordinateBus;
+    UINT8       SecondaryLatencyTimer;
+    UINT8       IoBase;
+    UINT8       IoLimit;
+    UINT16      SecondaryStatus;
+    UINT16      MemoryBase;
+    UINT16      MemoryLimit;
+    UINT16      PrefetchableMemoryBase;
+    UINT16      PrefetchableMemoryLimit;
+    UINT32      PrefetchableBaseUpper32;
+    UINT32      PrefetchableLimitUpper32;
+    UINT16      IoBaseUpper16;
+    UINT16      IoLimitUpper16;
+    UINT32      Reserved;
+    UINT32      ExpansionRomBAR;
+    UINT8       InterruptLine;
+    UINT8       InterruptPin;
+    UINT16      BridgeControl;
+} PCI_BRIDGE_CONTROL_REGISTER;
+
+#define PCI_CLASS_DISPLAY_CTRL          0x03
+#define PCI_CLASS_VGA                   0x00
+
+#define PCI_CLASS_BRIDGE                0x06
+#define PCI_CLASS_ISA                   0x01
+#define PCI_CLASS_ISA_POSITIVE_DECODE   0x80
+
+#define PCI_CLASS_NETWORK               0x02 
+#define PCI_CLASS_ETHERNET              0x00
+        
+#define HEADER_TYPE_DEVICE              0x00
+#define HEADER_TYPE_PCI_TO_PCI_BRIDGE   0x01
+#define HEADER_TYPE_MULTI_FUNCTION      0x80
+#define HEADER_LAYOUT_CODE              0x7f
+
+#define IS_PCI_BRIDGE(_p) ((((_p)->Hdr.HeaderType) & HEADER_LAYOUT_CODE) == HEADER_TYPE_PCI_TO_PCI_BRIDGE)        
+#define IS_PCI_MULTI_FUNC(_p)   (((_p)->Hdr.HeaderType) & HEADER_TYPE_MULTI_FUNCTION)         
+
+typedef struct {
+    PCI_DEVICE_INDEPENDENT_REGION   Hdr;
+    PCI_BRIDGE_CONTROL_REGISTER     Bridge;
+} PCI_TYPE01;
+
+typedef struct {
+    UINT8   Register;
+    UINT8   Function;
+    UINT8   Device;
+    UINT8   Bus;
+    UINT8   Reserved[4];
+} DEFIO_PCI_ADDR;
+
+typedef struct {
+    UINT32  Reg     : 8;
+    UINT32  Func    : 3;
+    UINT32  Dev     : 5;
+    UINT32  Bus     : 8;
+    UINT32  Reserved: 7;
+    UINT32  Enable  : 1;
+} PCI_CONFIG_ACCESS_CF8;
+
+#pragma pack()
+
+#define EFI_ROOT_BRIDGE_LIST    'eprb'
+typedef struct {
+    UINTN           Signature;
+
+    UINT16          BridgeNumber;
+    UINT16          PrimaryBus;
+    UINT16          SubordinateBus;
+
+    EFI_DEVICE_PATH *DevicePath;
+
+    LIST_ENTRY      Link;
+} PCI_ROOT_BRIDGE_ENTRY;
+
+
+#define PCI_EXPANSION_ROM_HEADER_SIGNATURE        0xaa55
+#define EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE 0x0EF1
+#define PCI_DATA_STRUCTURE_SIGNATURE              EFI_SIGNATURE_32('P','C','I','R')
+
+#pragma pack(1)
+typedef struct {
+    UINT16          Signature;              // 0xaa55
+    UINT8           Reserved[0x16];
+    UINT16          PcirOffset;
+} PCI_EXPANSION_ROM_HEADER;
+
+
+typedef struct {
+    UINT16          Signature;              // 0xaa55
+    UINT16          InitializationSize;
+    UINT16          EfiSignature;           // 0x0EF1
+    UINT16          EfiSubsystem;
+    UINT16          EfiMachineType;
+    UINT8           Reserved[0x0A];
+    UINT16          EfiImageHeaderOffset;
+    UINT16          PcirOffset;
+} EFI_PCI_EXPANSION_ROM_HEADER;
+
+typedef struct {
+    UINT32          Signature;              // "PCIR" 
+    UINT16          VendorId;
+    UINT16          DeviceId;
+    UINT16          Reserved0;
+    UINT16          Length;
+    UINT8           Revision;
+    UINT8           ClassCode[3];
+    UINT16          ImageLength;
+    UINT16          CodeRevision;
+    UINT8           CodeType;
+    UINT8           Indicator;
+    UINT16          Reserved1;
+} PCI_DATA_STRUCTURE;
+#pragma pack()
+
+#endif
+    
+
+
+
+
+    

src/include/efi/protocol/adapterdebug.h

@@ -0,0 +1,32 @@
+#ifndef _ADAPTER_DEBUG_H
+#define _ADAPTER_DEBUG_H
+
+/*++
+
+Copyright (c) 1999  Intel Corporation
+
+Module Name:
+
+    AdapterDebug.h
+    
+Abstract:
+
+    Protocol to debug the EDD 3.0 enablement of BIOS option ROMs
+
+
+
+Revision History
+
+--*/
+
+// {82F86881-282B-11d4-BC7D-0080C73C8881}
+#define ADAPTER_DEBUG_PROTOCOL \
+{ 0x82f86881, 0x282b, 0x11d4, {0xbc, 0x7d, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} }
+
+//
+// This protocol points to the BIOS_LEGACY_DRIVE data structure
+//  see edd.h for more details
+//
+
+#endif
+

src/include/efi/protocol/eficonsplit.h

@@ -0,0 +1,32 @@
+#ifndef _EFI_CONFORK_H
+#define _EFI_CONFORK_H
+/*++
+
+Copyright (c) 1999  Intel Corporation
+
+Module Name:
+
+Abstract:
+
+
+
+Revision History
+
+--*/
+
+
+
+//
+// ConOut Forker Protocol
+//
+
+#define TEXT_OUT_SPLITER_PROTOCOL    \
+    { 0x56d830a0, 0x7e7a, 0x11d3, {0xbb, 0xa0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
+
+#define ERROR_OUT_SPLITER_PROTOCOL    \
+    { 0xf0ba9039, 0x68f1, 0x425e, {0xaa, 0x7f, 0xd9, 0xaa, 0xf9, 0x1b, 0x82, 0xa1}}
+
+#define TEXT_IN_SPLITER_PROTOCOL    \
+    { 0xf9a3c550, 0x7fb5, 0x11d3, {0xbb, 0xa0, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
+
+#endif

src/include/efi/protocol/efidbg.h

@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 1999, 2000
+ * Intel Corporation.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ * 
+ *    This product includes software developed by Intel Corporation and
+ *    its contributors.
+ * 
+ * 4. Neither the name of Intel Corporation or its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL INTEL CORPORATION OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+
+#ifndef _EFIDBG_H_
+#define _EFIDBG_H_
+
+#include <efi/eficontext.h>
+#include <efi/efiser.h>
+
+typedef struct _DEBUGPORT_16550_CONFIG_DATA {
+        UINT32							PortAddress;
+        UINT64                          BaudRate;
+    	UINT32               			ReceiveFifoDepth;
+    	UINT32               			Timeout;
+        UINT8                           Parity;
+        UINT8                           DataBits;
+        UINT8                           StopBits;
+	    UINT32                       	ControlMask;
+        BOOLEAN							RtsCtsEnable;		// RTS, CTS control
+} DEBUGPORT_16550_CONFIG_DATA;
+
+typedef struct _DEBUGPORT_16550_DEVICE_PATH {
+        EFI_DEVICE_PATH                 Header;
+        DEBUGPORT_16550_CONFIG_DATA		ConfigData;
+} DEBUGPORT_16550_DEVICE_PATH;
+
+typedef union {
+    EFI_DEVICE_PATH                     DevPath;
+    DEBUGPORT_16550_DEVICE_PATH         Uart;
+    // add new types of debugport device paths to this union...
+} DEBUGPORT_DEV_PATH;
+
+
+//
+// Debug Support protocol {2755590C-6F3C-42FA-9EA4-A3BA543CDA25}
+//
+
+#define DEBUG_SUPPORT_PROTOCOL \
+{ 0x2755590C, 0x6F3C, 0x42fa, 0x9E, 0xA4, 0xA3, 0xBA, 0x54, 0x3C, 0xDA, 0x25 }
+
+
+typedef UINTN EXCEPTION_TYPE;
+
+typedef
+VOID
+(*EXCEPTION_HANDLER) (
+	IN EXCEPTION_TYPE ExceptionType,
+    IN SYSTEM_CONTEXT *SystemContext
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_TIMER_TICK_CALLBACK) (
+    IN struct _EFI_DEBUG_SUPPORT_INTERFACE  *This,
+    IN EXCEPTION_HANDLER	                TimerTickCallback
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_REGISTER_EXCEPTION_HANDLER) (
+    IN     struct _EFI_DEBUG_SUPPORT_INTERFACE  *This,
+    IN     EXCEPTION_HANDLER                    ExceptionHandler,
+    IN     EXCEPTION_TYPE                       ExceptionType
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_IP_CALL_TRACE) (
+    IN     struct _EFI_DEBUG_SUPPORT_INTERFACE  *This
+    );
+
+
+#define EFI_DEBUG_SUPPORT_INTERFACE_REVISION     0x00010000
+
+typedef struct _EFI_DEBUG_SUPPORT_INTERFACE {
+    UINT32                          	Revision;
+    EFI_REGISTER_TIMER_TICK_CALLBACK	RegisterTimerTickCallback;
+    EFI_REGISTER_EXCEPTION_HANDLER  	RegisterExceptionHandler;
+    EFI_IP_CALL_TRACE               	IpCallTrace;
+} EFI_DEBUG_SUPPORT_INTERFACE;
+
+
+//
+// Debugport io protocol {EBA4E8D2-3858-41EC-A281-2647BA9660D0}
+//
+
+#define DEBUGPORT_IO_PROTOCOL \
+{ 0XEBA4E8D2, 0X3858, 0X41EC, 0XA2, 0X81, 0X26, 0X47, 0XBA, 0X96, 0X60, 0XD0 }
+ 
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEBUGPORT_IO_RESET) (
+    IN struct _EFI_DEBUGPORT_IO_INTERFACE  	*This
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEBUGPORT_IO_READ) (
+    IN     struct _EFI_DEBUGPORT_IO_INTERFACE	*This,
+    IN OUT UINTN                    		*BufferSize,
+    OUT VOID                         		*Buffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_DEBUGPORT_IO_WRITE) (
+    IN     struct _EFI_DEBUGPORT_IO_INTERFACE *This,
+    IN OUT UINTN                    		*BufferSize,
+    IN VOID                         		*Buffer
+    );
+
+#define EFI_DEBUGPORT_IO_INTERFACE_REVISION   0x00010000
+
+typedef struct _EFI_DEBUGPORT_IO_INTERFACE {
+    UINT32                          		Revision;
+    EFI_DEBUGPORT_IO_READ					Read;
+    EFI_DEBUGPORT_IO_WRITE					Write;
+    EFI_DEBUGPORT_IO_RESET					Reset;
+} EFI_DEBUGPORT_IO_INTERFACE;
+
+
+//
+// Debugport UART16550 control protocol {628EA978-4C26-4605-BC02-A42A496917DD}
+//
+
+#define DEBUGPORT_UART16550_CONTROL_PROTOCOL \
+{ 0X628EA978, 0X4C26, 0X4605, 0XBC, 0X2, 0XA4, 0X2A, 0X49, 0X69, 0X17, 0XDD }
+ 
+// Note: The definitions for EFI_PARITY_TYPE, EFI_STOP_BITS_TYPE, and 
+// SERIAL_IO_MODE are included from efiser.h
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UART16550_SET_ATTRIBUTES) (
+    IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE  	*This,
+    IN UINT64                       	BaudRate,
+    IN UINT32                       	ReceiveFifoDepth,
+    IN UINT32                       	Timeout,
+    IN EFI_PARITY_TYPE       			Parity,
+    IN UINT8                        	DataBits,
+    IN EFI_STOP_BITS_TYPE    			StopBits
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UART16550_SET_CONTROL_BITS) (
+    IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE  	*This,
+    IN UINT32                       	Control
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_UART16550_GET_CONTROL_BITS) (
+    IN struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE	*This,
+    OUT UINT32                      	*Control
+    );
+
+#define EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE_REVISION   0x00010000
+
+typedef struct _EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE {
+    UINT32                          	Revision;
+	EFI_UART16550_SET_ATTRIBUTES		SetAttributes;
+	EFI_UART16550_SET_CONTROL_BITS		SetControl;
+	EFI_UART16550_GET_CONTROL_BITS 		GetControl;
+	DEBUGPORT_16550_CONFIG_DATA			*Mode;
+} EFI_DEBUGPORT_UART16550_CONTROL_INTERFACE;
+        
+
+#define DEVICE_PATH_DEBUGPORT DEBUGPORT_IO_PROTOCOL
+        
+#endif /* _EFIDBG_H_ */

src/include/efi/protocol/efivar.h

@@ -0,0 +1,133 @@
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+Abstract:
+
+
+
+Revision History
+
+--*/
+
+
+
+//
+// The variable store protocol interface is specific to the reference
+// implementation.  The initialization code adds variable store devices
+// to the system, and the FW connects to the devices to provide the
+// variable store interfaces through these devices.
+//
+
+//
+// Variable Store Device protocol
+//
+
+#define VARIABLE_STORE_PROTOCOL    \
+    { 0xf088cd91, 0xa046, 0x11d2, {0x8e, 0x42, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b} }
+
+INTERFACE_DECL(_EFI_VARIABLE_STORE);
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STORE_CLEAR) (
+    IN struct _EFI_VARIABLE_STORE   *This,
+    IN UINTN                        BankNo,
+    IN OUT VOID                     *Scratch
+    );
+
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STORE_READ) (
+    IN struct _EFI_VARIABLE_STORE   *This,
+    IN UINTN                        BankNo,
+    IN UINTN                        Offset,
+    IN UINTN                        BufferSize,
+    OUT VOID                        *Buffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STORE_UPDATE) (
+    IN struct _EFI_VARIABLE_STORE   *This,
+    IN UINTN                        BankNo,
+    IN UINTN                        Offset,
+    IN UINTN                        BufferSize,
+    IN VOID                         *Buffer
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_STORE_SIZE) (
+    IN struct _EFI_VARIABLE_STORE   *This,
+    IN UINTN                        NoBanks
+    );
+
+typedef
+EFI_STATUS
+(EFIAPI *EFI_TRANSACTION_UPDATE) (
+    IN struct _EFI_VARIABLE_STORE   *This,
+    IN UINTN                        BankNo,
+    IN VOID                         *NewContents
+    );
+
+typedef struct _EFI_VARIABLE_STORE {
+
+    //
+    // Number of banks and bank size
+    //
+
+    UINT32                      Attributes;
+    UINT32                      BankSize;
+    UINT32                      NoBanks;
+
+    //
+    // Functions to access the storage banks
+    //
+
+    EFI_STORE_CLEAR             ClearStore;
+    EFI_STORE_READ              ReadStore;
+    EFI_STORE_UPDATE            UpdateStore;
+    EFI_STORE_SIZE              SizeStore OPTIONAL;
+    EFI_TRANSACTION_UPDATE      TransactionUpdate OPTIONAL;
+
+} EFI_VARIABLE_STORE;
+
+
+//
+//
+// ClearStore()     - A function to clear the requested storage bank.  A cleared
+//      bank contains all "on" bits.
+//
+// ReadStore()      - Read data from the requested store.
+//
+// UpdateStore()    - Updates data on the requested store. The FW will only
+//      ever issue updates to clear bits in the store. Updates must be
+//      performed in LSb to MSb order of the update buffer.
+//
+// SizeStore()      - An optional function for non-runtime stores that can be
+//      dynamically sized.  The FW will only ever increase or decrease the store
+//      by 1 banksize at a time, and it is always adding or removing a bank from 
+//      the end of the store.
+//
+// By default the FW will update variables and storage banks in an
+// "atomic" manner by keeping 1 old copy of the data during an update,
+// and recovering appropiately if the power is lost during the middle
+// of an operation.  To do this the FW needs to have multiple banks
+// of storage dedicated to its use. If that's not possible, the driver 
+// can implement an atomic bank update function and the FW will allow 
+// 1 bank in this case.  (It will allow any number of banks,
+// but it won't require an "extra" bank to provide its bank transaction 
+// function).
+//
+// TransactionUpdate()  - An optional function that can clear & update an 
+//      entire bank in an "atomic" fashion.  If the operation fails in the 
+//      middle the driver is responsible for having either the previous copy 
+//      of the bank's data or the new copy.  A copy that's partially written
+//      is not valid as internal data settings may get lost.  Supply this
+//      function only when needed.
+//
+

src/include/efi/protocol/ia64/eficontext.h

@@ -0,0 +1,208 @@
+/*
+ * Copyright (c) 1999, 2000
+ * Intel Corporation.
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ * 
+ *    This product includes software developed by Intel Corporation and
+ *    its contributors.
+ * 
+ * 4. Neither the name of Intel Corporation or its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL INTEL CORPORATION OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ */
+
+
+#ifndef _EFICONTEXT_H_
+#define _EFICONTEXT_H_
+
+
+//
+//  IA-64 processor exception types
+//
+#define    EXCPT_ALT_DTLB            4
+#define    EXCPT_DNESTED_TLB         5
+#define    EXCPT_BREAKPOINT         11
+#define    EXCPT_EXTERNAL_INTERRUPT	12
+#define    EXCPT_GEN_EXCEPT         24
+#define    EXCPT_NAT_CONSUMPTION    26
+#define    EXCPT_DEBUG_EXCEPT       29
+#define    EXCPT_UNALIGNED_ACCESS   30
+#define    EXCPT_FP_FAULT           32
+#define    EXCPT_FP_TRAP            33
+#define    EXCPT_TAKEN_BRANCH       35
+#define    EXCPT_SINGLE_STEP        36
+
+//
+//  IA-64 processor context definition - must be 512 byte aligned!!!
+//
+typedef
+struct {
+	UINT64 reserved;	// necessary to preserve alignment for the correct bits in UNAT and to insure F2 is 16 byte aligned...
+    
+    UINT64 r1;
+    UINT64 r2;
+    UINT64 r3;
+    UINT64 r4;
+    UINT64 r5;
+    UINT64 r6;
+    UINT64 r7;
+    UINT64 r8;
+    UINT64 r9;
+    UINT64 r10;
+    UINT64 r11;
+    UINT64 r12;
+    UINT64 r13;
+    UINT64 r14;
+    UINT64 r15;
+    UINT64 r16;
+    UINT64 r17;
+    UINT64 r18;
+    UINT64 r19;
+    UINT64 r20;
+    UINT64 r21;
+    UINT64 r22;
+    UINT64 r23;
+    UINT64 r24;
+    UINT64 r25;
+    UINT64 r26;
+    UINT64 r27;
+    UINT64 r28;
+    UINT64 r29;
+    UINT64 r30;
+    UINT64 r31;
+    
+    UINT64 f2[2];
+    UINT64 f3[2];
+    UINT64 f4[2];
+    UINT64 f5[2];
+    UINT64 f6[2];
+    UINT64 f7[2];
+    UINT64 f8[2];
+    UINT64 f9[2];
+    UINT64 f10[2];
+    UINT64 f11[2];
+    UINT64 f12[2];
+    UINT64 f13[2];
+    UINT64 f14[2];
+    UINT64 f15[2];
+    UINT64 f16[2];
+    UINT64 f17[2];
+    UINT64 f18[2];
+    UINT64 f19[2];
+    UINT64 f20[2];
+    UINT64 f21[2];
+    UINT64 f22[2];
+    UINT64 f23[2];
+    UINT64 f24[2];
+    UINT64 f25[2];
+    UINT64 f26[2];
+    UINT64 f27[2];
+    UINT64 f28[2];
+    UINT64 f29[2];
+    UINT64 f30[2];
+    UINT64 f31[2];
+    
+    UINT64 pr;
+    
+    UINT64 b0;
+    UINT64 b1;
+    UINT64 b2;
+    UINT64 b3;
+    UINT64 b4;
+    UINT64 b5;
+    UINT64 b6;
+    UINT64 b7;
+    
+    // application registers
+    UINT64 ar_rsc;
+    UINT64 ar_bsp;
+    UINT64 ar_bspstore;
+    UINT64 ar_rnat;
+
+    UINT64 ar_fcr;
+
+    UINT64 ar_eflag;
+    UINT64 ar_csd;
+    UINT64 ar_ssd;
+    UINT64 ar_cflg;
+    UINT64 ar_fsr;
+    UINT64 ar_fir;
+    UINT64 ar_fdr;
+
+    UINT64 ar_ccv;
+
+    UINT64 ar_unat;
+
+    UINT64 ar_fpsr;
+    
+    UINT64 ar_pfs;
+    UINT64 ar_lc;
+    UINT64 ar_ec;
+    
+    // control registers
+    UINT64 cr_dcr;
+    UINT64 cr_itm;
+    UINT64 cr_iva;
+    UINT64 cr_pta;
+    UINT64 cr_ipsr;
+    UINT64 cr_isr;
+    UINT64 cr_iip;
+    UINT64 cr_ifa;
+    UINT64 cr_itir;
+    UINT64 cr_iipa;
+    UINT64 cr_ifs;
+    UINT64 cr_iim;
+    UINT64 cr_iha;
+    
+    // debug registers
+    UINT64 dbr0;
+    UINT64 dbr1;
+    UINT64 dbr2;
+    UINT64 dbr3;
+    UINT64 dbr4;
+    UINT64 dbr5;
+    UINT64 dbr6;
+    UINT64 dbr7;
+    
+    UINT64 ibr0;
+    UINT64 ibr1;
+    UINT64 ibr2;
+    UINT64 ibr3;
+    UINT64 ibr4;
+    UINT64 ibr5;
+    UINT64 ibr6;
+    UINT64 ibr7;
+    
+    // virtual registers
+    UINT64 int_nat;	// nat bits for R1-R31
+    
+} SYSTEM_CONTEXT;
+
+#endif /* _EFI_CONTEXT_H_ */

src/include/efi/protocol/intload.h

@@ -0,0 +1,27 @@
+/*++
+
+Copyright (c) 1999 Intel Corporation
+
+Module Name:
+
+    intload
+
+Abstract:
+
+    EFI support for loading internally linked in apps
+
+
+
+Revision History
+
+--*/
+
+#ifndef _INTERNAL_LOAD_INCLUDE_
+#define _INTERNAL_LOAD_INCLUDE_
+
+// {D65A6B8C-71E5-4df0-A909-F0D2992B5AA9}
+#define INTERNAL_SHELL_GUID \
+    { 0xd65a6b8c, 0x71e5, 0x4df0, {0xa9, 0x09, 0xf0, 0xd2, 0x99, 0x2b, 0x5a, 0xa9} }
+
+
+#endif

src/include/efi/protocol/legacyboot.h

@@ -0,0 +1,119 @@
+/*++
+
+Copyright (c) 1999 Intel Corporation
+
+Module Name:
+
+    legacyboot
+
+Abstract:
+
+    EFI support for legacy boot
+
+
+
+Revision History
+
+--*/
+
+#ifndef _LEGACY_BOOT_INCLUDE_
+#define _LEGACY_BOOT_INCLUDE_
+
+#define LEGACY_BOOT_PROTOCOL \
+    { 0x376e5eb2, 0x30e4, 0x11d3, { 0xba, 0xe5, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } }
+
+#pragma pack(1)
+
+//
+// BBS 1.01 (See Appendix A) IPL and BCV Table Entry Data structure.
+//  Seg:Off pointers have been converted to EFI pointers in this data structure
+//  This is the structure that also maps to the EFI device path for the boot selection
+//
+typedef struct {
+    UINT16  DeviceType;
+    UINT16  StatusFlag;
+    UINT32  Reserved;
+    VOID    *BootHandler;   // Not an EFI entry point
+    CHAR8   *DescString;
+} BBS_TABLE_ENTRY;
+#pragma pack()
+
+typedef
+EFI_STATUS
+(EFIAPI *LEGACY_BOOT_CALL) (
+    IN EFI_DEVICE_PATH      *DevicePath
+    );
+
+
+//
+// BBS support functions
+//  PnP Call numbers and BiosSelector hidden in implementation
+//
+
+typedef enum {
+    IplRelative,
+    BcvRelative
+} BBS_TYPE;
+
+INTERFACE_DECL(_LEGACY_BOOT_INTERFACE);
+
+//
+// == PnP Function 0x60 then BbsVersion == 0x0101 if this call fails then BbsVersion == 0x0000
+//
+
+//
+// == PnP Function 0x61
+//
+typedef
+EFI_STATUS
+(EFIAPI *GET_DEVICE_COUNT) (
+    IN  struct _LEGACY_BOOT_INTERFACE   *This,
+    IN  BBS_TYPE        *TableType,
+    OUT UINTN           *DeviceCount,
+    OUT UINTN           *MaxCount
+    );
+
+//
+// == PnP Function 0x62
+//
+typedef
+EFI_STATUS
+(EFIAPI *GET_PRIORITY_AND_TABLE) (
+    IN  struct _LEGACY_BOOT_INTERFACE   *This,
+    IN  BBS_TYPE        *TableType,
+    IN OUT  UINTN       *PrioritySize, // MaxCount * sizeof(UINT8)
+    OUT     UINTN       *Priority,
+    IN OUT  UINTN       *TableSize,    // MaxCount * sizeof(BBS_TABLE_ENTRY)
+    OUT BBS_TABLE_ENTRY *TableEntrySize
+    );
+
+//
+// == PnP Function 0x63
+//
+typedef
+EFI_STATUS
+(EFIAPI *SET_PRIORITY) (
+    IN  struct _LEGACY_BOOT_INTERFACE   *This,
+    IN  BBS_TYPE        *TableType,
+    IN OUT  UINTN       *PrioritySize,
+    OUT     UINTN       *Priority
+    );
+
+typedef struct _LEGACY_BOOT_INTERFACE {
+    LEGACY_BOOT_CALL    BootIt;
+
+    //
+    // New functions to allow BBS booting to be configured from EFI
+    //
+    UINTN                   BbsVersion;     // Currently 0x0101
+    GET_DEVICE_COUNT        GetDeviceCount;
+    GET_PRIORITY_AND_TABLE  GetPriorityAndTable;
+    SET_PRIORITY            SetPriority;   
+} LEGACY_BOOT_INTERFACE;
+
+EFI_STATUS
+PlInitializeLegacyBoot (
+    VOID
+    );
+
+#endif

src/include/efi/protocol/piflash64.h

@@ -0,0 +1,121 @@
+#ifndef _PIFLASH64_H
+#define _PIFLASH64_H
+
+/*++
+
+Copyright (c) 1999  Intel Corporation
+
+Module Name:
+
+    PIflash64.h
+    
+Abstract:
+
+    Iflash64.efi protocol to abstract iflash from
+    the system.
+
+Revision History
+
+--*/
+
+//
+// Guid that identifies the IFLASH protocol
+//
+#define IFLASH64_PROTOCOL_PROTOCOL \
+    { 0x65cba110, 0x74ab, 0x11d3, 0xbb, 0x89, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 };
+
+//
+// Unlock FLASH from StartAddress to EndAddress and return a LockKey
+//
+typedef
+EFI_STATUS
+(EFIAPI *UNLOCK_FLASH_API)(
+    IN struct _IFLASH64_PROTOCOL_INTERFACE  *This
+    );
+
+//
+// Lock the flash represented by the LockKey
+//
+typedef
+EFI_STATUS
+(EFIAPI *LOCK_FLASH_API)(
+    IN struct _IFLASH64_PROTOCOL_INTERFACE  *This
+    );
+
+//
+// Status callback for a utility like IFLASH64
+//
+//  Token would map to a list like Ted proposed. The utility has no idea what 
+//      happens on the other side.
+//  ErrorStatus - Level of Error or success. Independent of Token. If you 
+//      don't know the token you will at least know pass or fail.
+//  String - Optional extra information about the error. Could be used for 
+//      debug or future expansion
+//
+//  Attributes - Options screen attributes for String. Could allow the string to be different colors.
+//
+typedef
+EFI_STATUS
+(EFIAPI *UTILITY_PROGRESS_API)(
+    IN struct _IFLASH64_PROTOCOL_INTERFACE  *This,
+    IN  UINTN                               Token,
+    IN  EFI_STATUS                          ErrorStatus, 
+    IN  CHAR16                              *String,    OPTIONAL
+    IN  UINTN                               *Attributes OPTIONAL
+    );
+
+//
+// Token Values
+//
+// IFlash64 Token Codes
+#define IFLASH_TOKEN_IFLASHSTART    0xB0                // IFlash64 has started
+#define IFLASH_TOKEN_READINGFILE    0xB1                // Reading File
+#define IFLASH_TOKEN_INITVPP        0xB2                // Initializing Vpp
+#define IFLASH_TOKEN_DISABLEVPP     0x10                // Disable Vpp
+#define IFLASH_TOKEN_FLASHUNLOCK    0xB3                // Unlocking FLASH Devices
+#define IFLASH_TOKEN_FLASHERASE     0xB4                // Erasing FLASH Devices
+#define IFLASH_TOKEN_FLASHPROGRAM   0xB5                // Programming FLASH
+#define IFLASH_TOKEN_FLASHVERIFY    0xB6                // Verifying FLASH
+#define IFLASH_TOKEN_UPDATESUCCES   0xB7                // FLASH Updage Success!
+
+#define IFLASH_TOKEN_PROGRESS_READINGFILE   0x11        // % Reading File
+#define IFLASH_TOKEN_PROGRESS_FLASHUNLOCK   0x13        // % Unlocking FLASH Devices
+#define IFLASH_TOKEN_PROGRESS_FLASHERASE    0x14        // % Erasing FLASH Devices
+#define IFLASH_TOKEN_PROGRESS_FLASHPROGRAM  0x15        // % Programming FLASH
+#define IFLASH_TOKEN_PROGRESS_FLASHVERIFY   0x16        // % Verifying FLASH
+
+#define IFLASH_TOKEN_READINGFILE_ER 0xB8                // File Read Error
+#define IFLASH_TOKEN_INITVPP_ER     0xB9                // Initialization of IFB Error
+#define IFLASH_TOKEN_FLASHUNLOCK_ER 0xBA                // FLASH Unlock Error
+#define IFLASH_TOKEN_FLASHERASE_ER  0xBB                // FLASH Erase Error
+#define IFLASH_TOKEN_FLASHVERIFY_ER 0xBC                // FLASH Verify Error
+#define IFLASH_TOKEN_FLASHPROG_ER   0xBD                // FLASH Program Error
+
+#define IFLASH_TABLE_END            0x00
+
+//
+// If this number changes one of the existing API's has changes
+//
+#define IFLASH_PI_MAJOR_VERSION 0x01
+
+//
+// This number changes when new APIs or data variables get added to the end
+//  of the data structure
+//
+#define IFLASH_PI_MINOR_VERSION 0x01
+
+typedef struct _IFLASH64_PROTOCOL_INTERFACE {
+    UINT32                  MajorVersion;       
+    UINT32                  MinorVersion;   
+    UNLOCK_FLASH_API        UnlockFlash;
+    LOCK_FLASH_API          LockFlash;
+    UTILITY_PROGRESS_API    Progress;
+    
+    //
+    // Future expansion goes here
+    //
+
+} IFLASH64_PROTOCOL_INTERFACE;
+
+
+#endif

src/include/efi/protocol/readme.txt

@@ -0,0 +1,3 @@
+The protocol directory contains non Architectural 
+Protocols that span the FW, Platform, or application
+space.

src/include/efi/protocol/vgaclass.h

@@ -0,0 +1,95 @@
+#ifndef _VGA_CLASS_H
+#define _VGA_CLASS_H
+
+/*++
+
+Copyright (c) 1999  Intel Corporation
+
+Module Name:
+
+    VgaClass.h
+    
+Abstract:
+
+    Vga Mini port binding to Vga Class protocol
+
+
+
+Revision History
+
+--*/
+
+//
+// VGA Device Structure
+//
+
+// {0E3D6310-6FE4-11d3-BB81-0080C73C8881}
+#define VGA_CLASS_DRIVER_PROTOCOL \
+    { 0xe3d6310, 0x6fe4, 0x11d3, {0xbb, 0x81, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} }
+
+typedef 
+EFI_STATUS 
+(* INIT_VGA_CARD) (
+    IN  UINTN   VgaMode,
+    IN  VOID    *Context
+    );
+
+typedef struct {
+    UINTN   MaxColumns;
+    UINTN   MaxRows;
+} MAX_CONSOLE_GEOMETRY;
+
+#define VGA_CON_OUT_DEV_SIGNATURE   EFI_SIGNATURE_32('c','v','g','a')
+typedef struct {
+    UINTN                           Signature;
+
+    EFI_HANDLE                      Handle;
+    SIMPLE_TEXT_OUTPUT_INTERFACE    ConOut;
+    SIMPLE_TEXT_OUTPUT_MODE         ConOutMode;
+    EFI_DEVICE_PATH                 *DevicePath;
+
+    UINT8                           *Buffer;
+    EFI_DEVICE_IO_INTERFACE         *DeviceIo;
+
+    //
+    // Video Card Context
+    //
+    INIT_VGA_CARD                   InitVgaCard;
+    VOID                            *VgaCardContext;
+    MAX_CONSOLE_GEOMETRY            *Geometry;
+    //
+    // Video buffer normally 0xb8000
+    //
+    UINT64                          VideoBuffer;
+
+    //
+    // Clear Screen & Default Attribute
+    //
+    UINT32                          Attribute;
+
+    //
+    // -1 means search for active VGA device
+    //
+    EFI_PCI_ADDRESS_UNION           Pci;
+} VGA_CON_OUT_DEV;
+
+#define VGA_CON_OUT_DEV_FROM_THIS(a) CR(a, VGA_CON_OUT_DEV, ConOut, VGA_CON_OUT_DEV_SIGNATURE)
+
+//
+// Vga Class Driver Protocol. 
+// GUID defined in EFI Lib
+//
+
+typedef 
+EFI_STATUS
+(EFIAPI *INSTALL_VGA_DRIVER) (
+    IN  VGA_CON_OUT_DEV    *ConOutDev 
+    );
+
+typedef struct {
+    UINT32               Version;
+    INSTALL_VGA_DRIVER   InstallGenericVgaDriver;
+} INSTALL_VGA_DRIVER_INTERFACE;
+
+#endif
+

src/include/efi/romload.h

@@ -0,0 +1,41 @@
+#ifndef _EFI_ROMLOAD_H
+#define _EFI_ROMLOAD_H
+
+#define ROM_SIGNATURE 0xaa55
+#define PCIDS_SIGNATURE "PCIR"
+#pragma pack(push)
+#pragma pack(1)
+typedef struct 
+{
+    UINT8    Pcids_Sig[4];
+    UINT16  VendId;
+    UINT16  DevId;
+    UINT16  Vpd_Off;
+    UINT16  Size;
+    UINT8 Rev;
+    UINT8 Class_Code[3];
+    UINT16  Image_Len;
+    UINT16  Rev_Lvl;
+    UINT8 Code_Type;
+    UINT8 Indi;
+    UINT16  Rsvd;
+}PciDataStructure;
+typedef struct
+{
+    UINT16 Size;
+    UINT32 Header_Sig;
+    UINT16 SubSystem;
+    UINT16 MachineType;
+    UINT8  Resvd[10];
+    UINT16 EfiOffset;
+}ArchData;
+typedef struct 
+{
+    UINT16 Rom_Sig;
+    ArchData Arch_Data;
+    UINT16 Pcids_Off;
+    UINT8 resvd[38];
+}RomHeader;
+#pragma pack(pop)
+
+#endif

src/include/kernel_args.h

@@ -4,93 +4,44 @@
 #include <stddef.h>
 #include <stdint.h>
 
-namespace kernel {
-namespace args {
+#define DATA_HEADER_MAGIC     0x600dda7a
+#define DATA_HEADER_VERSION   1
 
-constexpr uint32_t magic = 0x600dda7a;
-constexpr uint16_t version = 1;
+#define JSIX_FLAG_DEBUG    0x00000001
 
-enum class mod_flags : uint32_t
-{
-	debug = 0x00000001
-};
-
-enum class mod_type : uint32_t {
-	unknown,
-
-	kernel,
-	initrd,
-
-	memory_map,
-	page_tables,
-	framebuffer,
-
-	max
-};
-
-enum class mode : uint8_t {
-	normal,
-	debug
-};
-
-struct module {
-	void *location;
-	size_t size;
-	mod_type type;
-	mod_flags flags;
-}
-__attribute__((packed));
-
-
-enum class mem_type : uint32_t {
-	free,
-	args,
-	kernel,
-	module,
-	table,
-	acpi,
-	uefi_runtime,
-	mmio,
-	persistent
-};
-
-/// Structure to hold an entry in the memory map.
-struct mem_entry
-{
-	uintptr_t start;
-	size_t pages;
-	mem_type type;
-	uint32_t attr;
-}
-__attribute__((packed));
-
-
-struct header {
+#pragma pack(push, 1)
+struct kernel_args {
 	uint32_t magic;
 	uint16_t version;
+	uint16_t length;
 
-	mode mode;
+	uint16_t _reserved0;
+	uint16_t scratch_pages;
+	uint32_t flags;
 
-	uint8_t _reserved0;
+	void *initrd;
+	size_t initrd_length;
 
-	void *pml4;
-	void *page_table_cache;
-	uint32_t num_free_tables;
+	void *data;
+	size_t data_length;
 
-	uint32_t num_modules;
-	module *modules;
+	void *memory_map;
+	size_t memory_map_length;
+	size_t memory_map_desc_size;
 
-	mem_entry *mem_map;
-	size_t num_map_entries;
+	void *runtime;
 
-	void *runtime_services;
 	void *acpi_table;
+
+	void *frame_buffer;
+	size_t frame_buffer_length;
+	uint32_t hres;
+	uint32_t vres;
+	uint32_t rmask;
+	uint32_t gmask;
+	uint32_t bmask;
+	uint32_t _reserved1;
 }
 __attribute__((aligned(alignof(max_align_t))));
 #pragma pack(pop)
 
-} // namespace args
-
-using entrypoint = __attribute__((sysv_abi)) void (*)(args::header *);
-
-} // namespace kernel

src/include/kernel_memory.h

@@ -8,34 +8,25 @@
 namespace memory {
 
 	/// Size of a single page frame.
-	constexpr size_t frame_size = 0x1000;
+	static const size_t frame_size = 0x1000;
 
 	/// Start of kernel memory.
-	constexpr uintptr_t kernel_offset = 0xffff800000000000;
+	static const uintptr_t kernel_offset = 0xffffff0000000000;
 
 	/// Offset from physical where page tables are mapped.
-	constexpr uintptr_t page_offset = 0xffffc00000000000;
+	static const uintptr_t page_offset = 0xffffff8000000000;
 
 	/// Initial process thread's stack address
-	constexpr uintptr_t initial_stack = 0x0000800000000000;
+	static const uintptr_t initial_stack = 0x0000800000000000;
 
 	/// Initial process thread's stack size, in pages
-	constexpr unsigned initial_stack_pages = 1;
+	static const unsigned initial_stack_pages = 1;
 
 	/// Max size of the kernel heap
-	constexpr size_t kernel_max_heap = 0x8000000000; // 512GiB
+	static const size_t kernel_max_heap = 0x800000000; // 32GiB
 
 	/// Start of the kernel heap
-	constexpr uintptr_t heap_start = page_offset - kernel_max_heap;
-
-	/// First kernel space PML4 entry
-	constexpr unsigned pml4e_kernel = 256;
-
-	/// First offset-mapped space PML4 entry
-	constexpr unsigned pml4e_offset = 384;
-
-	/// Number of page_table entries
-	constexpr unsigned table_entries = 512;
+	static const uintptr_t heap_start = page_offset - kernel_max_heap;
 
 	/// Helper to determine if a physical address can be accessed
 	/// through the page_offset area.

src/include/syscalls.inc

@@ -2,8 +2,8 @@ SYSCALL(0x00, object_noop,      void)
 SYSCALL(0x01, object_wait,      j6_handle_t, j6_signal_t, j6_signal_t *)
 
 SYSCALL(0x11, process_exit,     int64_t)
-SYSCALL(0x12, process_fork,     pid_t*)
-SYSCALL(0x13, process_getpid,   pid_t*)
+//SYSCALL(0x12, process_fork,     j6_koid_t*)
+//SYSCALL(0x13, process_getpid,   j6_koid_t*)
 SYSCALL(0x14, process_log,      const char *)
 SYSCALL(0x15, process_pause,    void)
 SYSCALL(0x16, process_sleep,    uint64_t)

src/include/x86_64/efi/efibind.h

@@ -0,0 +1,390 @@
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efefind.h
+
+Abstract:
+
+    EFI to compile bindings
+
+
+
+
+Revision History
+
+--*/
+#ifndef X86_64_EFI_BIND
+#define X86_64_EFI_BIND
+#ifndef __GNUC__
+#pragma pack()
+#endif
+
+#if defined(GNU_EFI_USE_MS_ABI)
+    #if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))||(defined(__clang__) && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 2)))
+        #define HAVE_USE_MS_ABI 1
+    #else
+        #error Compiler is too old for GNU_EFI_USE_MS_ABI
+    #endif
+#endif
+
+//
+// Basic int types of various widths
+//
+
+#if !defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L )
+
+    // No ANSI C 1999/2000 stdint.h integer width declarations 
+
+    #if defined(_MSC_EXTENSIONS)
+
+        // Use Microsoft C compiler integer width declarations 
+
+        typedef unsigned __int64    uint64_t;
+        typedef __int64             int64_t;
+        typedef unsigned __int32    uint32_t;
+        typedef __int32             int32_t;
+        typedef unsigned short      uint16_t;
+        typedef short               int16_t;
+        typedef unsigned char       uint8_t;
+        typedef char                int8_t;
+    #elif defined(__GNUC__)
+        typedef int __attribute__((__mode__(__DI__)))           int64_t;
+        typedef unsigned int __attribute__((__mode__(__DI__)))  uint64_t;
+        typedef unsigned int        uint32_t;
+        typedef int                 int32_t;
+        typedef unsigned short      uint16_t;
+        typedef short               int16_t;
+        typedef unsigned char       uint8_t;
+        typedef signed char         int8_t;
+    #elif defined(UNIX_LP64)
+
+        /*  Use LP64 programming model from C_FLAGS for integer width declarations */
+
+       typedef unsigned long       uint64_t;
+       typedef long                int64_t;
+       typedef unsigned int        uint32_t;
+       typedef int                 int32_t;
+       typedef unsigned short      uint16_t;
+       typedef short               int16_t;
+       typedef unsigned char       uint8_t;
+       typedef char                int8_t;
+    #else
+
+       /*  Assume P64 programming model from C_FLAGS for integer width declarations */
+
+       typedef unsigned long long  uint64_t __attribute__((aligned (8)));
+       typedef long long           int64_t __attribute__((aligned (8)));
+       typedef unsigned int        uint32_t;
+       typedef int                 int32_t;
+       typedef unsigned short      uint16_t;
+       typedef short               int16_t;
+       typedef unsigned char       uint8_t;
+       typedef char                int8_t;
+    #endif
+#elif defined(__GNUC__)
+    #include <stdint.h>
+#endif
+
+//
+// Basic EFI types of various widths
+//
+
+#ifndef __WCHAR_TYPE__
+# define __WCHAR_TYPE__ short
+#endif
+
+typedef uint64_t   UINT64;
+typedef int64_t    INT64;
+
+#ifndef _BASETSD_H_
+    typedef uint32_t   UINT32;
+    typedef int32_t    INT32;
+#endif
+
+typedef uint16_t   UINT16;
+typedef int16_t    INT16;
+typedef uint8_t    UINT8;
+typedef int8_t     INT8;
+typedef __WCHAR_TYPE__ WCHAR;
+
+#undef VOID
+#define VOID    void
+
+
+typedef int64_t    INTN;
+typedef uint64_t   UINTN;
+
+#ifdef EFI_NT_EMULATOR
+    #define POST_CODE(_Data)
+#else    
+    #ifdef EFI_DEBUG
+#define POST_CODE(_Data)    __asm mov eax,(_Data) __asm out 0x80,al
+    #else
+        #define POST_CODE(_Data)
+    #endif  
+#endif
+
+#define EFIERR(a)           (0x8000000000000000 | a)
+#define EFI_ERROR_MASK      0x8000000000000000
+#define EFIERR_OEM(a)       (0xc000000000000000 | a)      
+
+
+#define BAD_POINTER         0xFBFBFBFBFBFBFBFB
+#define MAX_ADDRESS         0xFFFFFFFFFFFFFFFF
+
+#ifdef EFI_NT_EMULATOR
+    #define BREAKPOINT()        __asm { int 3 }
+#else
+    #define BREAKPOINT()        while (TRUE);    // Make it hang on Bios[Dbg]32
+#endif
+
+//
+// Pointers must be aligned to these address to function
+//
+
+#define MIN_ALIGNMENT_SIZE  4
+
+#define ALIGN_VARIABLE(Value ,Adjustment) \
+            (UINTN)Adjustment = 0; \
+            if((UINTN)Value % MIN_ALIGNMENT_SIZE) \
+                (UINTN)Adjustment = MIN_ALIGNMENT_SIZE - ((UINTN)Value % MIN_ALIGNMENT_SIZE); \
+            Value = (UINTN)Value + (UINTN)Adjustment
+
+
+//
+// Define macros to build data structure signatures from characters.
+//
+
+#define EFI_SIGNATURE_16(A,B)             ((A) | (B<<8))
+#define EFI_SIGNATURE_32(A,B,C,D)         (EFI_SIGNATURE_16(A,B)     | (EFI_SIGNATURE_16(C,D)     << 16))
+#define EFI_SIGNATURE_64(A,B,C,D,E,F,G,H) (EFI_SIGNATURE_32(A,B,C,D) | ((UINT64)(EFI_SIGNATURE_32(E,F,G,H)) << 32))
+//
+// To export & import functions in the EFI emulator environment
+//
+
+#ifdef EFI_NT_EMULATOR
+    #define EXPORTAPI           __declspec( dllexport )
+#else
+    #define EXPORTAPI
+#endif
+
+
+//
+// EFIAPI - prototype calling convention for EFI function pointers
+// BOOTSERVICE - prototype for implementation of a boot service interface
+// RUNTIMESERVICE - prototype for implementation of a runtime service interface
+// RUNTIMEFUNCTION - prototype for implementation of a runtime function that is not a service
+// RUNTIME_CODE - pragma macro for declaring runtime code    
+//
+
+#ifndef EFIAPI                  // Forces EFI calling conventions reguardless of compiler options 
+    #ifdef _MSC_EXTENSIONS
+        #define EFIAPI __cdecl  // Force C calling convention for Microsoft C compiler 
+    #elif defined(HAVE_USE_MS_ABI)
+        // Force amd64/ms calling conventions.
+        #define EFIAPI __attribute__((ms_abi))
+    #else
+        #define EFIAPI          // Substitute expresion to force C calling convention 
+    #endif
+#endif
+
+#define BOOTSERVICE
+//#define RUNTIMESERVICE(proto,a)    alloc_text("rtcode",a); proto a
+//#define RUNTIMEFUNCTION(proto,a)   alloc_text("rtcode",a); proto a
+#define RUNTIMESERVICE
+#define RUNTIMEFUNCTION
+
+
+#define RUNTIME_CODE(a)         alloc_text("rtcode", a)
+#define BEGIN_RUNTIME_DATA()    data_seg("rtdata")
+#define END_RUNTIME_DATA()      data_seg("")
+
+#define VOLATILE    volatile
+
+#define MEMORY_FENCE()    
+
+#ifdef EFI_NT_EMULATOR
+
+//
+// To help ensure proper coding of integrated drivers, they are
+// compiled as DLLs.  In NT they require a dll init entry pointer.
+// The macro puts a stub entry point into the DLL so it will load.
+//
+
+#define EFI_DRIVER_ENTRY_POINT(InitFunction)    \
+    UINTN                                       \
+    __stdcall                                   \
+    _DllMainCRTStartup (                        \
+        UINTN    Inst,                          \
+        UINTN    reason_for_call,               \
+        VOID    *rserved                        \
+        )                                       \
+    {                                           \
+        return 1;                               \
+    }                                           \
+                                                \
+    int                                         \
+    EXPORTAPI                                   \
+    __cdecl                                     \
+    InitializeDriver (                          \
+        void *ImageHandle,                      \
+        void *SystemTable                       \
+        )                                       \
+    {                                           \
+        return InitFunction(ImageHandle, SystemTable);       \
+    }
+
+
+    #define LOAD_INTERNAL_DRIVER(_if, type, name, entry)      \
+        (_if)->LoadInternal(type, name, NULL)             
+
+#else // EFI_NT_EMULATOR 
+
+//
+// When build similiar to FW, then link everything together as
+// one big module. For the MSVC toolchain, we simply tell the
+// linker what our driver init function is using /ENTRY.
+//
+#if defined(_MSC_EXTENSIONS)
+    #define EFI_DRIVER_ENTRY_POINT(InitFunction) \
+        __pragma(comment(linker, "/ENTRY:" # InitFunction))
+#else
+    #define EFI_DRIVER_ENTRY_POINT(InitFunction)    \
+        UINTN                                       \
+        InitializeDriver (                          \
+            VOID    *ImageHandle,                   \
+            VOID    *SystemTable                    \
+            )                                       \
+        {                                           \
+            return InitFunction(ImageHandle,        \
+                    SystemTable);                   \
+        }                                           \
+                                                    \
+        EFI_STATUS efi_main(                        \
+            EFI_HANDLE image,                       \
+            EFI_SYSTEM_TABLE *systab                \
+            ) __attribute__((weak,                  \
+                    alias ("InitializeDriver")));
+#endif
+
+    #define LOAD_INTERNAL_DRIVER(_if, type, name, entry)    \
+            (_if)->LoadInternal(type, name, entry)
+
+#endif // EFI_NT_EMULATOR
+
+//
+// Some compilers don't support the forward reference construct:
+//  typedef struct XXXXX
+//
+// The following macro provide a workaround for such cases.
+//
+#ifdef NO_INTERFACE_DECL
+#define INTERFACE_DECL(x)
+#else
+#if defined(__GNUC__) || defined(_MSC_EXTENSIONS)
+#define INTERFACE_DECL(x) struct x
+#else
+#define INTERFACE_DECL(x) typedef struct x
+#endif
+#endif
+
+/* for x86_64, EFI_FUNCTION_WRAPPER must be defined */
+#if defined(HAVE_USE_MS_ABI)
+#define uefi_call_wrapper(func, va_num, ...) func(__VA_ARGS__)
+#else
+/*
+  Credits for macro-magic:
+    https://groups.google.com/forum/?fromgroups#!topic/comp.std.c/d-6Mj5Lko_s
+    http://efesx.com/2010/08/31/overloading-macros/
+*/
+#define __VA_NARG__(...)                        \
+  __VA_NARG_(_0, ## __VA_ARGS__, __RSEQ_N())
+#define __VA_NARG_(...)                         \
+  __VA_ARG_N(__VA_ARGS__)
+#define __VA_ARG_N(                             \
+  _0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,N,...) N
+#define __RSEQ_N()                              \
+  10, 9,  8,  7,  6,  5,  4,  3,  2,  1,  0
+
+#define __VA_ARG_NSUFFIX__(prefix,...)                  \
+  __VA_ARG_NSUFFIX_N(prefix, __VA_NARG__(__VA_ARGS__))
+#define __VA_ARG_NSUFFIX_N(prefix,nargs)        \
+  __VA_ARG_NSUFFIX_N_(prefix, nargs)
+#define __VA_ARG_NSUFFIX_N_(prefix,nargs)       \
+  prefix ## nargs
+
+/* Prototypes of EFI cdecl -> stdcall trampolines */
+UINT64 efi_call0(void *func);
+UINT64 efi_call1(void *func, UINT64 arg1);
+UINT64 efi_call2(void *func, UINT64 arg1, UINT64 arg2);
+UINT64 efi_call3(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3);
+UINT64 efi_call4(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
+                 UINT64 arg4);
+UINT64 efi_call5(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
+                 UINT64 arg4, UINT64 arg5);
+UINT64 efi_call6(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
+                 UINT64 arg4, UINT64 arg5, UINT64 arg6);
+UINT64 efi_call7(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
+                 UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7);
+UINT64 efi_call8(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
+                 UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7,
+                 UINT64 arg8);
+UINT64 efi_call9(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
+                 UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7,
+                 UINT64 arg8, UINT64 arg9);
+UINT64 efi_call10(void *func, UINT64 arg1, UINT64 arg2, UINT64 arg3,
+                  UINT64 arg4, UINT64 arg5, UINT64 arg6, UINT64 arg7,
+                  UINT64 arg8, UINT64 arg9, UINT64 arg10);
+
+/* Front-ends to efi_callX to avoid compiler warnings */
+#define _cast64_efi_call0(f) \
+  efi_call0(f)
+#define _cast64_efi_call1(f,a1) \
+  efi_call1(f, (UINT64)(a1))
+#define _cast64_efi_call2(f,a1,a2) \
+  efi_call2(f, (UINT64)(a1), (UINT64)(a2))
+#define _cast64_efi_call3(f,a1,a2,a3) \
+  efi_call3(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3))
+#define _cast64_efi_call4(f,a1,a2,a3,a4) \
+  efi_call4(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4))
+#define _cast64_efi_call5(f,a1,a2,a3,a4,a5) \
+  efi_call5(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \
+            (UINT64)(a5))
+#define _cast64_efi_call6(f,a1,a2,a3,a4,a5,a6) \
+  efi_call6(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \
+            (UINT64)(a5), (UINT64)(a6))
+#define _cast64_efi_call7(f,a1,a2,a3,a4,a5,a6,a7) \
+  efi_call7(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \
+            (UINT64)(a5), (UINT64)(a6), (UINT64)(a7))
+#define _cast64_efi_call8(f,a1,a2,a3,a4,a5,a6,a7,a8) \
+  efi_call8(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \
+            (UINT64)(a5), (UINT64)(a6), (UINT64)(a7), (UINT64)(a8))
+#define _cast64_efi_call9(f,a1,a2,a3,a4,a5,a6,a7,a8,a9) \
+  efi_call9(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \
+            (UINT64)(a5), (UINT64)(a6), (UINT64)(a7), (UINT64)(a8), \
+            (UINT64)(a9))
+#define _cast64_efi_call10(f,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) \
+  efi_call10(f, (UINT64)(a1), (UINT64)(a2), (UINT64)(a3), (UINT64)(a4), \
+             (UINT64)(a5), (UINT64)(a6), (UINT64)(a7), (UINT64)(a8), \
+             (UINT64)(a9), (UINT64)(a10))
+
+/* main wrapper (va_num ignored) */
+#define uefi_call_wrapper(func,va_num,...)                        \
+  __VA_ARG_NSUFFIX__(_cast64_efi_call, __VA_ARGS__) (func , ##__VA_ARGS__)
+
+#endif
+
+#if defined(HAVE_USE_MS_ABI) && !defined(_MSC_EXTENSIONS)
+    #define EFI_FUNCTION __attribute__((ms_abi))
+#else
+    #define EFI_FUNCTION
+#endif
+
+#ifdef _MSC_EXTENSIONS
+#pragma warning ( disable : 4731 )  // Suppress warnings about modification of EBP
+#endif
+
+#endif

src/include/x86_64/efi/efilibplat.h

@@ -0,0 +1,26 @@
+/*++
+
+Copyright (c) 1998  Intel Corporation
+
+Module Name:
+
+    efilibplat.h
+
+Abstract:
+
+    EFI to compile bindings
+
+
+
+
+Revision History
+
+--*/
+
+VOID
+InitializeLibPlatform (
+    IN EFI_HANDLE           ImageHandle,
+    IN EFI_SYSTEM_TABLE     *SystemTable
+    );
+
+   

src/include/x86_64/efi/efisetjmp_arch.h

@@ -0,0 +1,22 @@
+#ifndef GNU_EFI_X86_64_SETJMP_H
+#define GNU_EFI_X86_64_SETJMP_H
+
+#define JMPBUF_ALIGN 8
+
+typedef struct {
+	UINT64	Rbx;
+	UINT64	Rsp;
+	UINT64	Rbp;
+
+	UINT64	Rdi;
+	UINT64	Rsi;
+	UINT64	R12;
+	UINT64	R13;
+	UINT64	R14;
+	UINT64	R15;
+	UINT64	Rip;
+	UINT64	MxCsr;
+	UINT8	XmmBuffer[160]; // XMM6 - XMM15
+} ALIGN(JMPBUF_ALIGN) jmp_buf;
+
+#endif /* GNU_EFI_X86_64_SETJMP_H */

src/include/x86_64/efi/pe.h

@@ -0,0 +1,595 @@
+/* 
+    PE32+ header file
+ */
+#ifndef _PE_H
+#define _PE_H
+
+#define IMAGE_DOS_SIGNATURE                 0x5A4D      // MZ
+#define IMAGE_OS2_SIGNATURE                 0x454E      // NE
+#define IMAGE_OS2_SIGNATURE_LE              0x454C      // LE
+#define IMAGE_NT_SIGNATURE                  0x00004550  // PE00  
+#define IMAGE_EDOS_SIGNATURE                0x44454550  // PEED
+
+
+typedef struct _IMAGE_DOS_HEADER {      // DOS .EXE header
+    UINT16   e_magic;                     // Magic number
+    UINT16   e_cblp;                      // Bytes on last page of file
+    UINT16   e_cp;                        // Pages in file
+    UINT16   e_crlc;                      // Relocations
+    UINT16   e_cparhdr;                   // Size of header in paragraphs
+    UINT16   e_minalloc;                  // Minimum extra paragraphs needed
+    UINT16   e_maxalloc;                  // Maximum extra paragraphs needed
+    UINT16   e_ss;                        // Initial (relative) SS value
+    UINT16   e_sp;                        // Initial SP value
+    UINT16   e_csum;                      // Checksum
+    UINT16   e_ip;                        // Initial IP value
+    UINT16   e_cs;                        // Initial (relative) CS value
+    UINT16   e_lfarlc;                    // File address of relocation table
+    UINT16   e_ovno;                      // Overlay number
+    UINT16   e_res[4];                    // Reserved words
+    UINT16   e_oemid;                     // OEM identifier (for e_oeminfo)
+    UINT16   e_oeminfo;                   // OEM information; e_oemid specific
+    UINT16   e_res2[10];                  // Reserved words
+    UINT32   e_lfanew;                    // File address of new exe header
+  } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
+
+typedef struct _IMAGE_OS2_HEADER {      // OS/2 .EXE header
+    UINT16   ne_magic;                    // Magic number
+    UINT8    ne_ver;                      // Version number
+    UINT8    ne_rev;                      // Revision number
+    UINT16   ne_enttab;                   // Offset of Entry Table
+    UINT16   ne_cbenttab;                 // Number of bytes in Entry Table
+    UINT32   ne_crc;                      // Checksum of whole file
+    UINT16   ne_flags;                    // Flag UINT16
+    UINT16   ne_autodata;                 // Automatic data segment number
+    UINT16   ne_heap;                     // Initial heap allocation
+    UINT16   ne_stack;                    // Initial stack allocation
+    UINT32   ne_csip;                     // Initial CS:IP setting
+    UINT32   ne_sssp;                     // Initial SS:SP setting
+    UINT16   ne_cseg;                     // Count of file segments
+    UINT16   ne_cmod;                     // Entries in Module Reference Table
+    UINT16   ne_cbnrestab;                // Size of non-resident name table
+    UINT16   ne_segtab;                   // Offset of Segment Table
+    UINT16   ne_rsrctab;                  // Offset of Resource Table
+    UINT16   ne_restab;                   // Offset of resident name table
+    UINT16   ne_modtab;                   // Offset of Module Reference Table
+    UINT16   ne_imptab;                   // Offset of Imported Names Table
+    UINT32   ne_nrestab;                  // Offset of Non-resident Names Table
+    UINT16   ne_cmovent;                  // Count of movable entries
+    UINT16   ne_align;                    // Segment alignment shift count
+    UINT16   ne_cres;                     // Count of resource segments
+    UINT8    ne_exetyp;                   // Target Operating system
+    UINT8    ne_flagsothers;              // Other .EXE flags
+    UINT16   ne_pretthunks;               // offset to return thunks
+    UINT16   ne_psegrefbytes;             // offset to segment ref. bytes
+    UINT16   ne_swaparea;                 // Minimum code swap area size
+    UINT16   ne_expver;                   // Expected Windows version number
+  } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER;
+
+//
+// File header format.
+//
+
+typedef struct _IMAGE_FILE_HEADER {
+    UINT16   Machine;
+    UINT16   NumberOfSections;
+    UINT32   TimeDateStamp;
+    UINT32   PointerToSymbolTable;
+    UINT32   NumberOfSymbols;
+    UINT16   SizeOfOptionalHeader;
+    UINT16   Characteristics;
+} IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
+
+#define IMAGE_SIZEOF_FILE_HEADER             20
+
+#define IMAGE_FILE_RELOCS_STRIPPED           0x0001  // Relocation info stripped from file.
+#define IMAGE_FILE_EXECUTABLE_IMAGE          0x0002  // File is executable  (i.e. no unresolved externel references).
+#define IMAGE_FILE_LINE_NUMS_STRIPPED        0x0004  // Line nunbers stripped from file.
+#define IMAGE_FILE_LOCAL_SYMS_STRIPPED       0x0008  // Local symbols stripped from file.
+#define IMAGE_FILE_BYTES_REVERSED_LO         0x0080  // Bytes of machine word are reversed.
+#define IMAGE_FILE_32BIT_MACHINE             0x0100  // 32 bit word machine.
+#define IMAGE_FILE_DEBUG_STRIPPED            0x0200  // Debugging info stripped from file in .DBG file
+#define IMAGE_FILE_SYSTEM                    0x1000  // System File.
+#define IMAGE_FILE_DLL                       0x2000  // File is a DLL.
+#define IMAGE_FILE_BYTES_REVERSED_HI         0x8000  // Bytes of machine word are reversed.
+
+#define IMAGE_FILE_MACHINE_UNKNOWN           0
+#define IMAGE_FILE_MACHINE_I386              0x14c   // Intel 386.
+#define IMAGE_FILE_MACHINE_R3000             0x162   // MIPS little-endian, 0540 big-endian
+#define IMAGE_FILE_MACHINE_R4000             0x166   // MIPS little-endian
+#define IMAGE_FILE_MACHINE_ALPHA             0x184   // Alpha_AXP
+#define IMAGE_FILE_MACHINE_ARMTHUMB_MIXED    0x1c2   // Arm/Thumb
+#define IMAGE_FILE_MACHINE_POWERPC           0x1F0   // IBM PowerPC Little-Endian
+#define IMAGE_FILE_MACHINE_IA64              0x200   // IA-64
+#define IMAGE_FILE_MACHINE_TAHOE             0x7cc   // Intel EM machine
+#define IMAGE_FILE_MACHINE_EBC               0xebc   // EFI Byte Code
+#define IMAGE_FILE_MACHINE_X64               0x8664  // x86_64
+//
+// Directory format.
+//
+
+typedef struct _IMAGE_DATA_DIRECTORY {
+    UINT32   VirtualAddress;
+    UINT32   Size;
+} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
+
+#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
+
+//
+// Optional header format.
+//
+
+typedef struct _IMAGE_OPTIONAL_HEADER {
+    //
+    // Standard fields.
+    //
+
+    UINT16    Magic;
+    UINT8     MajorLinkerVersion;
+    UINT8     MinorLinkerVersion;
+    UINT32    SizeOfCode;
+    UINT32    SizeOfInitializedData;
+    UINT32    SizeOfUninitializedData;
+    UINT32    AddressOfEntryPoint;
+    UINT32    BaseOfCode;
+    UINT32    BaseOfData;
+                
+    //
+    // NT additional fields.
+    //
+
+    UINT32   ImageBase;
+    UINT32   SectionAlignment;
+    UINT32   FileAlignment;
+    UINT16   MajorOperatingSystemVersion;
+    UINT16   MinorOperatingSystemVersion;
+    UINT16   MajorImageVersion;
+    UINT16   MinorImageVersion;
+    UINT16   MajorSubsystemVersion;
+    UINT16   MinorSubsystemVersion;
+    UINT32   Reserved1;
+    UINT32   SizeOfImage;
+    UINT32   SizeOfHeaders;
+    UINT32   CheckSum;
+    UINT16   Subsystem;
+    UINT16   DllCharacteristics;
+    UINT32   SizeOfStackReserve;
+    UINT32   SizeOfStackCommit;
+    UINT32   SizeOfHeapReserve;
+    UINT32   SizeOfHeapCommit;
+    UINT32   LoaderFlags;
+    UINT32   NumberOfRvaAndSizes;
+    IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
+} IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;
+
+typedef struct _IMAGE_ROM_OPTIONAL_HEADER {
+    UINT16  Magic;
+    UINT8   MajorLinkerVersion;
+    UINT8   MinorLinkerVersion;
+    UINT32  SizeOfCode;
+    UINT32  SizeOfInitializedData;
+    UINT32  SizeOfUninitializedData;
+    UINT32  AddressOfEntryPoint;
+    UINT32  BaseOfCode;
+    UINT32  BaseOfData;
+    UINT32  BaseOfBss;
+    UINT32  GprMask;
+    UINT32  CprMask[4];
+    UINT32  GpValue;
+} IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER;
+
+#define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER      56
+#define IMAGE_SIZEOF_STD_OPTIONAL_HEADER      28
+#define IMAGE_SIZEOF_NT_OPTIONAL_HEADER      224
+
+#define IMAGE_NT_OPTIONAL_HDR_MAGIC        0x10b
+#define IMAGE_ROM_OPTIONAL_HDR_MAGIC       0x107
+
+typedef struct _IMAGE_NT_HEADERS {
+    UINT32 Signature;
+    IMAGE_FILE_HEADER FileHeader;
+    IMAGE_OPTIONAL_HEADER OptionalHeader;
+} IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS;
+
+typedef struct _IMAGE_ROM_HEADERS {
+    IMAGE_FILE_HEADER FileHeader;
+    IMAGE_ROM_OPTIONAL_HEADER OptionalHeader;
+} IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS;
+
+#define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER)        \
+    ((UINT32)ntheader +                                                  \
+     FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) +                 \
+     ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader   \
+    ))
+
+
+// Subsystem Values
+
+#define IMAGE_SUBSYSTEM_UNKNOWN              0   // Unknown subsystem.
+#define IMAGE_SUBSYSTEM_NATIVE               1   // Image doesn't require a subsystem.
+#define IMAGE_SUBSYSTEM_WINDOWS_GUI          2   // Image runs in the Windows GUI subsystem.
+#define IMAGE_SUBSYSTEM_WINDOWS_CUI          3   // Image runs in the Windows character subsystem.
+#define IMAGE_SUBSYSTEM_OS2_CUI              5   // image runs in the OS/2 character subsystem.
+#define IMAGE_SUBSYSTEM_POSIX_CUI            7   // image run  in the Posix character subsystem.
+
+
+// Directory Entries
+
+#define IMAGE_DIRECTORY_ENTRY_EXPORT         0   // Export Directory
+#define IMAGE_DIRECTORY_ENTRY_IMPORT         1   // Import Directory
+#define IMAGE_DIRECTORY_ENTRY_RESOURCE       2   // Resource Directory
+#define IMAGE_DIRECTORY_ENTRY_EXCEPTION      3   // Exception Directory
+#define IMAGE_DIRECTORY_ENTRY_SECURITY       4   // Security Directory
+#define IMAGE_DIRECTORY_ENTRY_BASERELOC      5   // Base Relocation Table
+#define IMAGE_DIRECTORY_ENTRY_DEBUG          6   // Debug Directory
+#define IMAGE_DIRECTORY_ENTRY_COPYRIGHT      7   // Description String
+#define IMAGE_DIRECTORY_ENTRY_GLOBALPTR      8   // Machine Value (MIPS GP)
+#define IMAGE_DIRECTORY_ENTRY_TLS            9   // TLS Directory
+#define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG   10   // Load Configuration Directory
+
+//
+// Section header format.
+//
+
+#define IMAGE_SIZEOF_SHORT_NAME              8
+
+typedef struct _IMAGE_SECTION_HEADER {
+    UINT8   Name[IMAGE_SIZEOF_SHORT_NAME];
+    union {
+            UINT32   PhysicalAddress;
+            UINT32   VirtualSize;
+    } Misc;
+    UINT32   VirtualAddress;
+    UINT32   SizeOfRawData;
+    UINT32   PointerToRawData;
+    UINT32   PointerToRelocations;
+    UINT32   PointerToLinenumbers;
+    UINT16   NumberOfRelocations;
+    UINT16   NumberOfLinenumbers;
+    UINT32   Characteristics;
+} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
+
+#define IMAGE_SIZEOF_SECTION_HEADER          40
+
+#define IMAGE_SCN_TYPE_NO_PAD                0x00000008  // Reserved.
+
+#define IMAGE_SCN_CNT_CODE                   0x00000020  // Section contains code.
+#define IMAGE_SCN_CNT_INITIALIZED_DATA       0x00000040  // Section contains initialized data.
+#define IMAGE_SCN_CNT_UNINITIALIZED_DATA     0x00000080  // Section contains uninitialized data.
+
+#define IMAGE_SCN_LNK_OTHER                  0x00000100  // Reserved.
+#define IMAGE_SCN_LNK_INFO                   0x00000200  // Section contains comments or some other type of information.
+#define IMAGE_SCN_LNK_REMOVE                 0x00000800  // Section contents will not become part of image.
+#define IMAGE_SCN_LNK_COMDAT                 0x00001000  // Section contents comdat.
+
+#define IMAGE_SCN_ALIGN_1BYTES               0x00100000  //
+#define IMAGE_SCN_ALIGN_2BYTES               0x00200000  //
+#define IMAGE_SCN_ALIGN_4BYTES               0x00300000  //
+#define IMAGE_SCN_ALIGN_8BYTES               0x00400000  //
+#define IMAGE_SCN_ALIGN_16BYTES              0x00500000  // Default alignment if no others are specified.
+#define IMAGE_SCN_ALIGN_32BYTES              0x00600000  //
+#define IMAGE_SCN_ALIGN_64BYTES              0x00700000  //
+
+#define IMAGE_SCN_MEM_DISCARDABLE            0x02000000  // Section can be discarded.
+#define IMAGE_SCN_MEM_NOT_CACHED             0x04000000  // Section is not cachable.
+#define IMAGE_SCN_MEM_NOT_PAGED              0x08000000  // Section is not pageable.
+#define IMAGE_SCN_MEM_SHARED                 0x10000000  // Section is shareable.
+#define IMAGE_SCN_MEM_EXECUTE                0x20000000  // Section is executable.
+#define IMAGE_SCN_MEM_READ                   0x40000000  // Section is readable.
+#define IMAGE_SCN_MEM_WRITE                  0x80000000  // Section is writeable.
+
+//
+// Symbol format.
+//
+
+
+#define IMAGE_SIZEOF_SYMBOL                  18
+
+//
+// Section values.
+//
+// Symbols have a section number of the section in which they are
+// defined. Otherwise, section numbers have the following meanings:
+//
+
+#define IMAGE_SYM_UNDEFINED           (UINT16)0           // Symbol is undefined or is common.
+#define IMAGE_SYM_ABSOLUTE            (UINT16)-1          // Symbol is an absolute value.
+#define IMAGE_SYM_DEBUG               (UINT16)-2          // Symbol is a special debug item.
+
+//
+// Type (fundamental) values.
+//
+
+#define IMAGE_SYM_TYPE_NULL                  0           // no type.
+#define IMAGE_SYM_TYPE_VOID                  1           //
+#define IMAGE_SYM_TYPE_CHAR                  2           // type character.
+#define IMAGE_SYM_TYPE_SHORT                 3           // type short integer.
+#define IMAGE_SYM_TYPE_INT                   4           //
+#define IMAGE_SYM_TYPE_LONG                  5           //
+#define IMAGE_SYM_TYPE_FLOAT                 6           //
+#define IMAGE_SYM_TYPE_DOUBLE                7           //
+#define IMAGE_SYM_TYPE_STRUCT                8           //
+#define IMAGE_SYM_TYPE_UNION                 9           //
+#define IMAGE_SYM_TYPE_ENUM                  10          // enumeration.
+#define IMAGE_SYM_TYPE_MOE                   11          // member of enumeration.
+#define IMAGE_SYM_TYPE_BYTE                  12          //
+#define IMAGE_SYM_TYPE_WORD                  13          //
+#define IMAGE_SYM_TYPE_UINT                  14          //
+#define IMAGE_SYM_TYPE_DWORD                 15          //
+
+//
+// Type (derived) values.
+//
+
+#define IMAGE_SYM_DTYPE_NULL                 0           // no derived type.
+#define IMAGE_SYM_DTYPE_POINTER              1           // pointer.
+#define IMAGE_SYM_DTYPE_FUNCTION             2           // function.
+#define IMAGE_SYM_DTYPE_ARRAY                3           // array.
+
+//
+// Storage classes.
+//
+
+#define IMAGE_SYM_CLASS_END_OF_FUNCTION      (BYTE )-1
+#define IMAGE_SYM_CLASS_NULL                 0
+#define IMAGE_SYM_CLASS_AUTOMATIC            1
+#define IMAGE_SYM_CLASS_EXTERNAL             2
+#define IMAGE_SYM_CLASS_STATIC               3
+#define IMAGE_SYM_CLASS_REGISTER             4
+#define IMAGE_SYM_CLASS_EXTERNAL_DEF         5
+#define IMAGE_SYM_CLASS_LABEL                6
+#define IMAGE_SYM_CLASS_UNDEFINED_LABEL      7
+#define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT     8
+#define IMAGE_SYM_CLASS_ARGUMENT             9
+#define IMAGE_SYM_CLASS_STRUCT_TAG           10
+#define IMAGE_SYM_CLASS_MEMBER_OF_UNION      11
+#define IMAGE_SYM_CLASS_UNION_TAG            12
+#define IMAGE_SYM_CLASS_TYPE_DEFINITION      13
+#define IMAGE_SYM_CLASS_UNDEFINED_STATIC     14
+#define IMAGE_SYM_CLASS_ENUM_TAG             15
+#define IMAGE_SYM_CLASS_MEMBER_OF_ENUM       16
+#define IMAGE_SYM_CLASS_REGISTER_PARAM       17
+#define IMAGE_SYM_CLASS_BIT_FIELD            18
+#define IMAGE_SYM_CLASS_BLOCK                100
+#define IMAGE_SYM_CLASS_FUNCTION             101
+#define IMAGE_SYM_CLASS_END_OF_STRUCT        102
+#define IMAGE_SYM_CLASS_FILE                 103
+// new
+#define IMAGE_SYM_CLASS_SECTION              104
+#define IMAGE_SYM_CLASS_WEAK_EXTERNAL        105
+
+// type packing constants
+
+#define N_BTMASK                            017
+#define N_TMASK                             060
+#define N_TMASK1                            0300
+#define N_TMASK2                            0360
+#define N_BTSHFT                            4
+#define N_TSHIFT                            2
+
+// MACROS
+
+//
+// Communal selection types.
+//
+
+#define IMAGE_COMDAT_SELECT_NODUPLICATES   1
+#define IMAGE_COMDAT_SELECT_ANY            2
+#define IMAGE_COMDAT_SELECT_SAME_SIZE      3
+#define IMAGE_COMDAT_SELECT_EXACT_MATCH    4
+#define IMAGE_COMDAT_SELECT_ASSOCIATIVE    5
+
+#define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY 1
+#define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY   2
+#define IMAGE_WEAK_EXTERN_SEARCH_ALIAS     3
+
+
+//
+// Relocation format.
+//
+
+typedef struct _IMAGE_RELOCATION {
+    UINT32   VirtualAddress;
+    UINT32   SymbolTableIndex;
+    UINT16    Type;
+} IMAGE_RELOCATION;
+
+#define IMAGE_SIZEOF_RELOCATION              10
+
+//
+// I386 relocation types.
+//
+
+#define IMAGE_REL_I386_ABSOLUTE              0           // Reference is absolute, no relocation is necessary
+#define IMAGE_REL_I386_DIR16                 01          // Direct 16-bit reference to the symbols virtual address
+#define IMAGE_REL_I386_REL16                 02          // PC-relative 16-bit reference to the symbols virtual address
+#define IMAGE_REL_I386_DIR32                 06          // Direct 32-bit reference to the symbols virtual address
+#define IMAGE_REL_I386_DIR32NB               07          // Direct 32-bit reference to the symbols virtual address, base not included
+#define IMAGE_REL_I386_SEG12                 011         // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address
+#define IMAGE_REL_I386_SECTION               012
+#define IMAGE_REL_I386_SECREL                013
+#define IMAGE_REL_I386_REL32                 024         // PC-relative 32-bit reference to the symbols virtual address
+
+//
+// MIPS relocation types.
+//
+
+#define IMAGE_REL_MIPS_ABSOLUTE              0           // Reference is absolute, no relocation is necessary
+#define IMAGE_REL_MIPS_REFHALF               01
+#define IMAGE_REL_MIPS_REFWORD               02
+#define IMAGE_REL_MIPS_JMPADDR               03
+#define IMAGE_REL_MIPS_REFHI                 04
+#define IMAGE_REL_MIPS_REFLO                 05
+#define IMAGE_REL_MIPS_GPREL                 06
+#define IMAGE_REL_MIPS_LITERAL               07
+#define IMAGE_REL_MIPS_SECTION               012
+#define IMAGE_REL_MIPS_SECREL                013
+#define IMAGE_REL_MIPS_REFWORDNB             042
+#define IMAGE_REL_MIPS_PAIR                  045
+
+//
+// Alpha Relocation types.
+//
+
+#define IMAGE_REL_ALPHA_ABSOLUTE             0x0
+#define IMAGE_REL_ALPHA_REFLONG              0x1
+#define IMAGE_REL_ALPHA_REFQUAD              0x2
+#define IMAGE_REL_ALPHA_GPREL32              0x3
+#define IMAGE_REL_ALPHA_LITERAL              0x4
+#define IMAGE_REL_ALPHA_LITUSE               0x5
+#define IMAGE_REL_ALPHA_GPDISP               0x6
+#define IMAGE_REL_ALPHA_BRADDR               0x7
+#define IMAGE_REL_ALPHA_HINT                 0x8
+#define IMAGE_REL_ALPHA_INLINE_REFLONG       0x9
+#define IMAGE_REL_ALPHA_REFHI                0xA
+#define IMAGE_REL_ALPHA_REFLO                0xB
+#define IMAGE_REL_ALPHA_PAIR                 0xC
+#define IMAGE_REL_ALPHA_MATCH                0xD
+#define IMAGE_REL_ALPHA_SECTION              0xE
+#define IMAGE_REL_ALPHA_SECREL               0xF
+#define IMAGE_REL_ALPHA_REFLONGNB            0x10
+
+//
+// IBM PowerPC relocation types.
+//
+
+#define IMAGE_REL_PPC_ABSOLUTE 0x0000  // NOP
+#define IMAGE_REL_PPC_ADDR64   0x0001  // 64-bit address
+#define IMAGE_REL_PPC_ADDR32   0x0002  // 32-bit address
+#define IMAGE_REL_PPC_ADDR24   0x0003  // 26-bit address, shifted left 2 (branch absolute)
+#define IMAGE_REL_PPC_ADDR16   0x0004  // 16-bit address
+#define IMAGE_REL_PPC_ADDR14   0x0005  // 16-bit address, shifted left 2 (load doubleword)
+#define IMAGE_REL_PPC_REL24    0x0006  // 26-bit PC-relative offset, shifted left 2 (branch relative)
+#define IMAGE_REL_PPC_REL14    0x0007  // 16-bit PC-relative offset, shifted left 2 (br cond relative)
+#define IMAGE_REL_PPC_TOCREL16 0x0008  // 16-bit offset from TOC base
+#define IMAGE_REL_PPC_TOCREL14 0x0009  // 16-bit offset from TOC base, shifted left 2 (load doubleword)
+
+#define IMAGE_REL_PPC_ADDR32NB 0x000A  // 32-bit addr w/o image base
+#define IMAGE_REL_PPC_SECREL   0x000B  // va of containing section (as in an image sectionhdr)
+#define IMAGE_REL_PPC_SECTION  0x000C  // sectionheader number
+#define IMAGE_REL_PPC_IFGLUE   0x000D  // substitute TOC restore instruction iff symbol is glue code
+#define IMAGE_REL_PPC_IMGLUE   0x000E  // symbol is glue code; virtual address is TOC restore instruction
+
+#define IMAGE_REL_PPC_TYPEMASK 0x00FF  // mask to isolate above values in IMAGE_RELOCATION.Type
+
+// Flag bits in IMAGE_RELOCATION.TYPE
+
+#define IMAGE_REL_PPC_NEG      0x0100  // subtract reloc value rather than adding it
+#define IMAGE_REL_PPC_BRTAKEN  0x0200  // fix branch prediction bit to predict branch taken
+#define IMAGE_REL_PPC_BRNTAKEN 0x0400  // fix branch prediction bit to predict branch not taken
+#define IMAGE_REL_PPC_TOCDEFN  0x0800  // toc slot defined in file (or, data in toc)
+
+//
+// Based relocation format.
+//
+
+typedef struct _IMAGE_BASE_RELOCATION {
+    UINT32   VirtualAddress;
+    UINT32   SizeOfBlock;
+//  UINT16    TypeOffset[1];
+} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION;
+
+#define IMAGE_SIZEOF_BASE_RELOCATION         8
+
+//
+// Based relocation types.
+//
+
+#define IMAGE_REL_BASED_ABSOLUTE              0
+#define IMAGE_REL_BASED_HIGH                  1
+#define IMAGE_REL_BASED_LOW                   2
+#define IMAGE_REL_BASED_HIGHLOW               3
+#define IMAGE_REL_BASED_HIGHADJ               4
+#define IMAGE_REL_BASED_MIPS_JMPADDR          5
+#define IMAGE_REL_BASED_IA64_IMM64            9
+#define IMAGE_REL_BASED_DIR64                 10
+
+//
+// Line number format.
+//
+
+typedef struct _IMAGE_LINENUMBER {
+    union {
+        UINT32   SymbolTableIndex;               // Symbol table index of function name if Linenumber is 0.
+        UINT32   VirtualAddress;                 // Virtual address of line number.
+    } Type;
+    UINT16    Linenumber;                         // Line number.
+} IMAGE_LINENUMBER;
+
+#define IMAGE_SIZEOF_LINENUMBER              6
+
+//
+// Archive format.
+//
+
+#define IMAGE_ARCHIVE_START_SIZE             8
+#define IMAGE_ARCHIVE_START                  "!<arch>\n"
+#define IMAGE_ARCHIVE_END                    "`\n"
+#define IMAGE_ARCHIVE_PAD                    "\n"
+#define IMAGE_ARCHIVE_LINKER_MEMBER          "/               "
+#define IMAGE_ARCHIVE_LONGNAMES_MEMBER       "//              "
+
+typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER {
+    UINT8     Name[16];                          // File member name - `/' terminated.
+    UINT8     Date[12];                          // File member date - decimal.
+    UINT8     UserID[6];                         // File member user id - decimal.
+    UINT8     GroupID[6];                        // File member group id - decimal.
+    UINT8     Mode[8];                           // File member mode - octal.
+    UINT8     Size[10];                          // File member size - decimal.
+    UINT8     EndHeader[2];                      // String to end header.
+} IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER;
+
+#define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR      60
+
+//
+// DLL support.
+//
+
+//
+// Export Format
+//
+
+typedef struct _IMAGE_EXPORT_DIRECTORY {
+    UINT32   Characteristics;
+    UINT32   TimeDateStamp;
+    UINT16   MajorVersion;
+    UINT16   MinorVersion;
+    UINT32   Name;
+    UINT32   Base;
+    UINT32   NumberOfFunctions;
+    UINT32   NumberOfNames;
+    UINT32   *AddressOfFunctions;
+    UINT32   *AddressOfNames;
+    UINT32   *AddressOfNameOrdinals;
+} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
+
+//
+// Import Format
+//
+
+typedef struct _IMAGE_IMPORT_BY_NAME {
+    UINT16    Hint;
+    UINT8     Name[1];
+} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
+
+typedef struct _IMAGE_THUNK_DATA {
+    union {
+        UINT32 Function;
+        UINT32 Ordinal;
+        PIMAGE_IMPORT_BY_NAME AddressOfData;
+    } u1;
+} IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA;
+
+#define IMAGE_ORDINAL_FLAG 0x80000000
+#define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0)
+#define IMAGE_ORDINAL(Ordinal) (Ordinal & 0xffff)
+
+typedef struct _IMAGE_IMPORT_DESCRIPTOR {
+    UINT32   Characteristics;
+    UINT32   TimeDateStamp;
+    UINT32   ForwarderChain;
+    UINT32   Name;
+    PIMAGE_THUNK_DATA FirstThunk;
+} IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR;
+
+#endif

src/kernel/interrupts.cpp

@@ -1,7 +1,5 @@
 #include <stdint.h>
 
-#include "kernel_memory.h"
-
 #include "apic.h"
 #include "console.h"
 #include "cpu.h"
@@ -17,8 +15,6 @@
 static const uint16_t PIC1 = 0x20;
 static const uint16_t PIC2 = 0xa0;
 
-constexpr uintptr_t apic_eoi_addr = 0xfee000b0 + ::memory::page_offset;
-
 extern "C" {
 	void _halt();
 
@@ -277,7 +273,7 @@ isr_handler(cpu_state *regs)
 		print_stacktrace(2);
 		_halt();
 	}
-	*reinterpret_cast<uint32_t *>(apic_eoi_addr) = 0;
+	*reinterpret_cast<uint32_t *>(0xffffff80fee000b0) = 0;
 }
 
 void
@@ -294,5 +290,5 @@ irq_handler(cpu_state *regs)
 		_halt();
 	}
 
-	*reinterpret_cast<uint32_t *>(apic_eoi_addr) = 0;
+	*reinterpret_cast<uint32_t *>(0xffffff80fee000b0) = 0;
 }