Move XTLDR under boot directory

boot/xtldr/modules/xtos_o/CMakeLists.txt

@@ -0,0 +1,28 @@
+# XT Boot Loader
+PROJECT(XTLDR_XTOS_O)
+
+# Specify include directories
+include_directories(
+    ${EXECTOS_SOURCE_DIR}/sdk/xtdk
+    ${XTLDR_XTOS_O_SOURCE_DIR}/includes)
+
+# Specify list of source code files
+list(APPEND XTLDR_XTOS_O_SOURCE
+    ${XTLDR_XTOS_O_SOURCE_DIR}/${ARCH}/memory.cc
+    ${XTLDR_XTOS_O_SOURCE_DIR}/data.cc
+    ${XTLDR_XTOS_O_SOURCE_DIR}/xtos.cc)
+
+# Link bootloader executable
+add_executable(xtos_o ${XTLDR_XTOS_O_SOURCE})
+
+# Add linker libraries
+target_link_libraries(xtos_o libxtos libxtldr)
+
+# Set proper binary name and install target
+set_target_properties(xtos_o PROPERTIES SUFFIX .efi)
+set_install_target(xtos_o efi/boot/xtldr/modules)
+
+# Set module entrypoint and subsystem
+set_entrypoint(xtos_o "XtLdrModuleMain")
+set_linker_map(xtos_o TRUE)
+set_subsystem(xtos_o efi_boot_service_driver)

boot/xtldr/modules/xtos_o/amd64/memory.cc

@@ -0,0 +1,298 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtldr/amd64/memory.cc
+ * DESCRIPTION:     EFI memory management for AMD64 target
+ * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
+ *                  Aiken Harris <harraiken91@gmail.com>
+ */
+
+#include <xtos.hh>
+
+
+/**
+ * Determines the appropriate paging level (PML) for the AMD64 architecture.
+ *
+ * @param Parameters
+ *        A pointer to the wide character string containing the kernel boot parameters.
+ *
+ * @return This routine returns the appropriate page map level (5 if LA57 is enabled, 4 otherwise).
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+ULONG
+Xtos::DeterminePagingLevel(IN CONST PWCHAR Parameters)
+{
+    CPUID_REGISTERS CpuRegisters;
+
+    /* Prepare CPUID registers to query for STD7 features */
+    XtLdrProtocol->Memory.ZeroMemory(&CpuRegisters, sizeof(CPUID_REGISTERS));
+    CpuRegisters.Leaf = CPUID_GET_VENDOR_STRING;
+
+    /* Query CPUID */
+    XtLdrProtocol->Cpu.CpuId(&CpuRegisters);
+
+    /* Verify if the CPU supports the STD7 feature leaf (0x00000007) */
+    if(CpuRegisters.Eax >= CPUID_GET_STANDARD7_FEATURES)
+    {
+        /* Prepare CPUID registers to query for LA57 support */
+        XtLdrProtocol->Memory.ZeroMemory(&CpuRegisters, sizeof(CPUID_REGISTERS));
+        CpuRegisters.Leaf = CPUID_GET_STANDARD7_FEATURES;
+
+        /* Query CPUID */
+        XtLdrProtocol->Cpu.CpuId(&CpuRegisters);
+
+        /* Check if eXtended Physical Addressing (XPA) is enabled and if LA57 is supported by the CPU */
+        if((CpuRegisters.Ecx & CPUID_FEATURES_ECX_LA57) &&
+           !(XtLdrProtocol->BootUtils.GetBooleanParameter(Parameters, L"NOXPA")))
+        {
+            /* Enable LA57 (PML5) */
+            return 5;
+        }
+    }
+
+    /* Disable LA57 and use PML4 by default */
+    return 4;
+}
+
+/**
+ * Builds the actual memory mapping page table and enables paging. This routine exits EFI boot services as well.
+ *
+ * @param PageMap
+ *        Supplies a pointer to the page mapping structure.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::EnablePaging(IN PXTBL_PAGE_MAPPING PageMap)
+{
+    EFI_STATUS Status;
+    EFI_PHYSICAL_ADDRESS TrampolineAddress;
+    PXT_TRAMPOLINE_ENTRY TrampolineEntry;
+    ULONG_PTR TrampolineSize;
+    PVOID TrampolineCode;
+
+    /* Build page map */
+    Status = XtLdrProtocol->Memory.BuildPageMap(PageMap, (PageMap->PageMapLevel > 4) ? MM_P5E_LA57_BASE : MM_PXE_BASE);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to build page map */
+        XtLdrProtocol->Debug.Print(L"Failed to build page map (Status code: %zX)\n", Status);
+        return Status;
+    }
+
+    /* Map memory for hardware layer */
+    Status = MapHardwareMemoryPool(PageMap);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to map memory for hardware layer */
+        XtLdrProtocol->Debug.Print(L"Failed to map memory for hardware leyer (Status code: %zX)\n", Status);
+        return Status;
+    }
+
+    /* Check the configured page map level to set the LA57 state accordingly */
+    if(PageMap->PageMapLevel == 5)
+    {
+        /* Get the trampoline code information */
+        XtLdrProtocol->BootUtils.GetTrampolineInformation(TrampolineEnableXpa, &TrampolineCode, &TrampolineSize);
+        if(TrampolineCode == NULLPTR || TrampolineSize == 0)
+        {
+            /* Failed to get trampoline information */
+            XtLdrProtocol->Debug.Print(L"Failed to get trampoline information\n");
+            return STATUS_EFI_INVALID_PARAMETER;
+        }
+
+        /* Set the address of the trampoline code below 1MB */
+        TrampolineAddress = MM_TRAMPOLINE_ADDRESS;
+
+        /* Allocate pages for the trampoline */
+        Status = XtLdrProtocol->Memory.AllocatePages(AllocateAddress, EFI_SIZE_TO_PAGES(TrampolineSize), &TrampolineAddress);
+        if(Status != STATUS_EFI_SUCCESS)
+        {
+            /* Failed to allocate memory for trampoline code */
+            XtLdrProtocol->Debug.Print(L"Failed to allocate memory for trampoline code (Status code: %zX)\n", Status);
+            return Status;
+        }
+
+        /* Set the trampoline entry point and copy its code into the allocated buffer */
+        TrampolineEntry = (PXT_TRAMPOLINE_ENTRY)(UINT_PTR)TrampolineAddress;
+        XtLdrProtocol->Memory.CopyMemory((PVOID)TrampolineEntry, TrampolineCode, TrampolineSize);
+    }
+
+    /* Exit EFI Boot Services */
+    XtLdrProtocol->Debug.Print(L"Exiting EFI boot services\n");
+    Status = XtLdrProtocol->Utils.ExitBootServices();
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to exit boot services */
+        XtLdrProtocol->Debug.Print(L"Failed to exit boot services (Status code: %zX)\n", Status);
+        return STATUS_EFI_ABORTED;
+    }
+
+    /* Check the configured page map level to set the LA57 state accordingly */
+    if(PageMap->PageMapLevel == 5)
+    {
+        /* Enable Linear Address 57-bit (LA57) extension */
+        XtLdrProtocol->Debug.Print(L"Enabling Linear Address 57-bit (LA57)\n");
+
+        /* Execute the trampoline to enable LA57 and write PML5 to CR3 */
+        TrampolineEntry((UINT64)PageMap->PtePointer);
+    }
+    else
+    {
+        /* Disable Linear Address 57-bit (LA57) extension */
+        XtLdrProtocol->Debug.Print(L"Disabling Linear Address 57-bit (LA57)\n");
+
+        /* Write PML4 to CR3 and enable paging */
+        XtLdrProtocol->Cpu.WriteControlRegister(3, (UINT_PTR)PageMap->PtePointer);
+        XtLdrProtocol->Cpu.WriteControlRegister(0, XtLdrProtocol->Cpu.ReadControlRegister(0) | CR0_PG);
+    }
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}
+
+/**
+ * Maps the page table for hardware layer addess space.
+ *
+ * @param PageMap
+ *        Supplies a pointer to the page mapping structure.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::MapHardwareMemoryPool(IN PXTBL_PAGE_MAPPING PageMap)
+{
+    PHARDWARE_PTE P5eBase, PdeBase, PpeBase, PxeBase;
+    EFI_PHYSICAL_ADDRESS Address;
+    EFI_STATUS Status;
+
+    if(PageMap->PageMapLevel == 5)
+    {
+        /* Get P5E (PML5) base address */
+        P5eBase = (PHARDWARE_PTE)PageMap->PtePointer;
+
+        /* Check if P5E entry already exists */
+        if(!P5eBase[(MM_HARDWARE_VA_START >> MM_P5I_SHIFT) & 0x1FF].Valid)
+        {
+            /* No valid P5E, allocate memory */
+            Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, 1, &Address);
+            if(Status != STATUS_EFI_SUCCESS)
+            {
+                /* Memory allocation failure, return error */
+                return Status;
+            }
+
+            /* Zero fill memory used by P5E */
+            XtLdrProtocol->Memory.ZeroMemory((PVOID)Address, EFI_PAGE_SIZE);
+
+            /* Make P5E valid */
+            P5eBase[(MM_HARDWARE_VA_START >> MM_P5I_SHIFT) & 0x1FF].Valid = 1;
+            P5eBase[(MM_HARDWARE_VA_START >> MM_P5I_SHIFT) & 0x1FF].PageFrameNumber = Address / EFI_PAGE_SIZE;
+            P5eBase[(MM_HARDWARE_VA_START >> MM_P5I_SHIFT) & 0x1FF].Writable = 1;
+
+            /* Set PXE base address */
+            PxeBase = (PHARDWARE_PTE)(UINT_PTR)Address;
+        }
+        else
+        {
+            /* Set PXE base address based on existing P5E */
+            PxeBase = (PHARDWARE_PTE)((P5eBase[(MM_HARDWARE_VA_START >> MM_P5I_SHIFT) & 0x1FF].PageFrameNumber) << EFI_PAGE_SHIFT);
+        }
+    }
+    else
+    {
+        /* Get PXE (PML4) base address */
+        PxeBase = (PHARDWARE_PTE)PageMap->PtePointer;
+    }
+
+    /* Check if PXE entry already exists */
+    if(!PxeBase[(MM_HARDWARE_VA_START >> MM_PXI_SHIFT) & 0x1FF].Valid)
+    {
+        /* No valid PXE, allocate memory */
+        Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, 1, &Address);
+        if(Status != STATUS_EFI_SUCCESS)
+        {
+            /* Memory allocation failure, return error */
+            return Status;
+        }
+
+        /* Zero fill memory used by PXE */
+        XtLdrProtocol->Memory.ZeroMemory((PVOID)Address, EFI_PAGE_SIZE);
+
+        /* Make PXE valid */
+        PxeBase[(MM_HARDWARE_VA_START >> MM_PXI_SHIFT) & 0x1FF].Valid = 1;
+        PxeBase[(MM_HARDWARE_VA_START >> MM_PXI_SHIFT) & 0x1FF].PageFrameNumber = Address / EFI_PAGE_SIZE;
+        PxeBase[(MM_HARDWARE_VA_START >> MM_PXI_SHIFT) & 0x1FF].Writable = 1;
+
+        /* Set PPE base address */
+        PpeBase = (PHARDWARE_PTE)(UINT_PTR)Address;
+    }
+    else
+    {
+        /* Set PPE base address based on existing PXE */
+        PpeBase = (PHARDWARE_PTE)((PxeBase[(MM_HARDWARE_VA_START >> MM_PXI_SHIFT) & 0x1FF].PageFrameNumber) << EFI_PAGE_SHIFT);
+    }
+
+    /* Check if PPE entry already exists */
+    if(!PpeBase[(MM_HARDWARE_VA_START >> MM_PPI_SHIFT) & 0x1FF].Valid)
+    {
+        /* No valid PPE, allocate memory */
+        Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, 1, &Address);
+        if(Status != STATUS_EFI_SUCCESS)
+        {
+            /* Memory allocation failure, return error */
+            return Status;
+        }
+
+        /* Zero fill memory used by PPE */
+        XtLdrProtocol->Memory.ZeroMemory((PVOID)Address, EFI_PAGE_SIZE);
+
+        /* Make PPE valid */
+        PpeBase[(MM_HARDWARE_VA_START >> MM_PPI_SHIFT) & 0x1FF].Valid = 1;
+        PpeBase[(MM_HARDWARE_VA_START >> MM_PPI_SHIFT) & 0x1FF].PageFrameNumber = Address / EFI_PAGE_SIZE;
+        PpeBase[(MM_HARDWARE_VA_START >> MM_PPI_SHIFT) & 0x1FF].Writable = 1;
+
+        /* Set PDE base address */
+        PdeBase = (PHARDWARE_PTE)Address;
+    }
+    else
+    {
+        /* Set PDE base address, based on existing PPE */
+        PdeBase = (PHARDWARE_PTE)((PpeBase[(MM_HARDWARE_VA_START >> MM_PPI_SHIFT) & 0x1FF].PageFrameNumber) << EFI_PAGE_SHIFT);
+    }
+
+    /* Loop through 2 PDE entries */
+    for(UINT Index = 0 ; Index < 2 ; Index++)
+    {
+        /* Check if PDE entry already exists */
+        if(!PdeBase[((MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF) + Index].Valid)
+        {
+            /* No valid PDE, allocate memory */
+            Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, 1, &Address);
+            if(Status != STATUS_EFI_SUCCESS)
+            {
+                /* Memory allocation failure, return error */
+                return Status;
+            }
+
+            /* Zero fill memory used by PDE */
+            XtLdrProtocol->Memory.ZeroMemory((PVOID)Address, EFI_PAGE_SIZE);
+
+            /* Make PDE valid */
+            PdeBase[((MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF) + Index].Valid = 1;
+            PdeBase[((MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF) + Index].PageFrameNumber = Address / EFI_PAGE_SIZE;
+            PdeBase[((MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF) + Index].Writable = 1;
+        }
+    }
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}

boot/xtldr/modules/xtos_o/data.cc

@@ -0,0 +1,19 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtldr/modules/xtos/data.cc
+ * DESCRIPTION:     XTOS module global and static data
+ * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
+ */
+
+#include <xtos.hh>
+
+
+/* XTOS Boot Protocol */
+XTBL_BOOT_PROTOCOL Xtos::BootProtocol;
+
+/* XTOS PE/COFF Image Protocol */
+PXTBL_EXECUTABLE_IMAGE_PROTOCOL Xtos::PeCoffProtocol;
+
+/* EFI XT Loader Protocol */
+PXTBL_LOADER_PROTOCOL Xtos::XtLdrProtocol;

boot/xtldr/modules/xtos_o/i686/memory.cc

@@ -0,0 +1,181 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtldr/i686/memory.cc
+ * DESCRIPTION:     EFI memory management for i686 target
+ * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
+ */
+
+#include <xtos.hh>
+
+
+/**
+ * Determines the appropriate paging level (PML) for the i686 architecture.
+ *
+ * @param Parameters
+ *        A pointer to the wide character string containing the kernel boot parameters.
+ *
+ * @return This routine returns the appropriate page map level (3 if PAE is enabled, 2 otherwise).
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+ULONG
+Xtos::DeterminePagingLevel(IN CONST PWCHAR Parameters)
+{
+    CPUID_REGISTERS CpuRegisters;
+
+    /* Prepare CPUID registers to query for PAE support */
+    XtLdrProtocol->Memory.ZeroMemory(&CpuRegisters, sizeof(CPUID_REGISTERS));
+    CpuRegisters.Leaf = CPUID_GET_STANDARD1_FEATURES;
+
+    /* Query CPUID */
+    XtLdrProtocol->Cpu.CpuId(&CpuRegisters);
+
+    /* Check if eXtended Physical Addressing (XPA) is enabled and if PAE is supported by the CPU */
+    if((CpuRegisters.Edx & CPUID_FEATURES_EDX_PAE) &&
+       !(XtLdrProtocol->BootUtils.GetBooleanParameter(Parameters, L"NOXPA")))
+    {
+        /* Enable PAE (PML3) */
+        return 3;
+    }
+
+    /* Disable PAE and use PML2 by default */
+    return 2;
+}
+
+/**
+ * Builds the actual memory mapping page table and enables paging. This routine exits EFI boot services as well.
+ *
+ * @param PageMap
+ *        Supplies a pointer to the page mapping structure.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::EnablePaging(IN PXTBL_PAGE_MAPPING PageMap)
+{
+    EFI_STATUS Status;
+
+    /* Build page map */
+    Status = XtLdrProtocol->Memory.BuildPageMap(PageMap, MM_PTE_BASE);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to build page map */
+        XtLdrProtocol->Debug.Print(L"Failed to build page map (Status code: %zX)\n", Status);
+        return Status;
+    }
+
+    /* Map memory for hardware layer */
+    Status = MapHardwareMemoryPool(PageMap);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to map memory for hardware layer */
+        XtLdrProtocol->Debug.Print(L"Failed to map memory for hardware layer (Status code: %zX)\n", Status);
+        return Status;
+    }
+
+    /* Exit EFI Boot Services */
+    XtLdrProtocol->Debug.Print(L"Exiting EFI boot services\n");
+    Status = XtLdrProtocol->Utils.ExitBootServices();
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to exit boot services */
+        XtLdrProtocol->Debug.Print(L"Failed to exit boot services (Status code: %zX)\n", Status);
+        return STATUS_EFI_ABORTED;
+    }
+
+    /* Disable paging */
+    XtLdrProtocol->Cpu.WriteControlRegister(0, XtLdrProtocol->Cpu.ReadControlRegister(0) & ~CR0_PG);
+
+    /* Check the configured page map level to set the PAE state accordingly */
+    if(PageMap->PageMapLevel == 3)
+    {
+        /* Enable Physical Address Extension (PAE) */
+        XtLdrProtocol->Debug.Print(L"Enabling Physical Address Extension (PAE)\n");
+        XtLdrProtocol->Cpu.WriteControlRegister(4, XtLdrProtocol->Cpu.ReadControlRegister(4) | CR4_PAE);
+    }
+    else
+    {
+        /* Disable Physical Address Extension (PAE) */
+        XtLdrProtocol->Debug.Print(L"Disabling Physical Address Extension (PAE)\n");
+        XtLdrProtocol->Cpu.WriteControlRegister(4, XtLdrProtocol->Cpu.ReadControlRegister(4) & ~CR4_PAE);
+    }
+
+    /* Write page mappings to CR3 */
+    XtLdrProtocol->Cpu.WriteControlRegister(3, (UINT_PTR)PageMap->PtePointer);
+
+    /* Enable paging */
+    XtLdrProtocol->Cpu.WriteControlRegister(0, XtLdrProtocol->Cpu.ReadControlRegister(0) | CR0_PG);
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}
+
+/**
+ * Maps the page table for hardware layer addess space.
+ *
+ * @param PageMap
+ *        Supplies a pointer to the page mapping structure.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::MapHardwareMemoryPool(IN PXTBL_PAGE_MAPPING PageMap)
+{
+    EFI_PHYSICAL_ADDRESS Address;
+    PHARDWARE_LEGACY_PTE LegacyPdeBase;
+    PHARDWARE_MODERN_PTE PdeBase;
+    EFI_STATUS Status;
+
+    /* Allocate memory */
+    Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, 1, &Address);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Memory allocation failure, return error */
+        return Status;
+    }
+
+    /* Zero fill allocated memory */
+    XtLdrProtocol->Memory.ZeroMemory((PVOID)Address, EFI_PAGE_SIZE);
+
+    /* Check if PAE is enabled (3-level paging) */
+    if(PageMap->PageMapLevel == 3)
+    {
+        /* Get PDE base address (PAE enabled) */
+        PdeBase = (PHARDWARE_MODERN_PTE)(((PHARDWARE_MODERN_PTE)PageMap->PtePointer)[MM_HARDWARE_VA_START >> MM_PPI_SHIFT].PageFrameNumber << MM_PAGE_SHIFT);
+
+        /* Make PDE valid */
+        XtLdrProtocol->Memory.ZeroMemory(&PdeBase[(MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF], sizeof(HARDWARE_MODERN_PTE));
+        PdeBase[(MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF].PageFrameNumber = Address >> MM_PAGE_SHIFT;
+        PdeBase[(MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF].Valid = 1;
+        PdeBase[(MM_HARDWARE_VA_START >> MM_PDI_SHIFT) & 0x1FF].Writable = 1;
+    }
+    else
+    {
+        /* Get PDE base address (PAE disabled) */
+        LegacyPdeBase = (PHARDWARE_LEGACY_PTE)PageMap->PtePointer;
+
+        /* Check for a conflicting PDE */
+        if(LegacyPdeBase[MM_HARDWARE_VA_START >> MM_PDI_LEGACY_SHIFT].Valid)
+        {
+            /* PDE already exists and is valid, nothing to do */
+            return STATUS_EFI_SUCCESS;
+        }
+
+        /* Make PDE valid  */
+        XtLdrProtocol->Memory.ZeroMemory(&LegacyPdeBase[MM_HARDWARE_VA_START >> MM_PDI_LEGACY_SHIFT], sizeof(HARDWARE_LEGACY_PTE));
+        LegacyPdeBase[MM_HARDWARE_VA_START >> MM_PDI_LEGACY_SHIFT].Valid = 1;
+        LegacyPdeBase[MM_HARDWARE_VA_START >> MM_PDI_LEGACY_SHIFT].PageFrameNumber = Address >> MM_PAGE_SHIFT;
+        LegacyPdeBase[MM_HARDWARE_VA_START >> MM_PDI_LEGACY_SHIFT].Writable = 1;
+    }
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}

boot/xtldr/modules/xtos_o/includes/xtos.hh

@@ -0,0 +1,78 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtldr/modules/xtos/includes/xtos.hh
+ * DESCRIPTION:     XTOS boot protocol support header
+ * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
+ */
+
+#ifndef __XTLDR_MODULES_XTOS_HH
+#define __XTLDR_MODULES_XTOS_HH
+
+#include <xtblapi.h>
+
+
+/* XTOS kernel entry point */
+typedef VOID (XTAPI *PXT_ENTRY_POINT)(IN PKERNEL_INITIALIZATION_BLOCK BootParameters);
+
+/* XTOS trampoline entry point */
+typedef VOID (*PXT_TRAMPOLINE_ENTRY)(UINT64 PageMap);
+
+
+/* XTOS module for XTLDR */
+class Xtos
+{
+    private:
+        STATIC XTBL_BOOT_PROTOCOL BootProtocol;
+        STATIC PXTBL_EXECUTABLE_IMAGE_PROTOCOL PeCoffProtocol;
+        STATIC PXTBL_LOADER_PROTOCOL XtLdrProtocol;
+
+    public:
+        STATIC XTCDECL EFI_STATUS BootSystem(IN PXTBL_BOOT_PARAMETERS Parameters);
+        STATIC XTCDECL EFI_STATUS InitializeModule(IN EFI_HANDLE ImageHandle,
+                                                   IN PEFI_SYSTEM_TABLE SystemTable);
+
+    private:
+        STATIC XTCDECL EFI_STATUS AddVirtualMemoryMapping(IN PLIST_ENTRY MemoryMappings,
+                                                          IN PVOID VirtualAddress,
+                                                          IN PVOID PhysicalAddress,
+                                                          IN UINT NumberOfPages,
+                                                          IN LOADER_MEMORY_TYPE MemoryType);
+        STATIC XTCDECL LOADER_MEMORY_TYPE ConvertEfiMemoryType(IN EFI_MEMORY_TYPE EfiMemoryType);
+        STATIC XTCDECL ULONG DeterminePagingLevel(IN CONST PWCHAR Parameters);
+        STATIC XTCDECL EFI_STATUS EnablePaging(IN PXTBL_PAGE_MAPPING PageMap);
+        STATIC XTCDECL VOID GetDisplayInformation(OUT PSYSTEM_RESOURCE_FRAMEBUFFER FrameBufferResource,
+                                                  IN PEFI_PHYSICAL_ADDRESS FrameBufferBase,
+                                                  IN PULONG_PTR FrameBufferSize,
+                                                  IN PXTBL_FRAMEBUFFER_MODE_INFORMATION FrameBufferModeInfo);
+        STATIC XTCDECL EFI_STATUS GetMemoryDescriptorList(IN PXTBL_PAGE_MAPPING PageMap,
+                                                          IN PVOID *VirtualAddress,
+                                                          OUT PLIST_ENTRY MemoryDescriptorList);
+        STATIC XTCDECL EFI_STATUS GetSystemResourcesList(IN PXTBL_PAGE_MAPPING PageMap,
+                                                         IN PVOID *VirtualAddress,
+                                                         OUT PLIST_ENTRY SystemResourcesList);
+        STATIC XTCDECL EFI_STATUS GetVirtualAddress(IN PLIST_ENTRY MemoryMappings,
+                                                    IN PVOID PhysicalAddress,
+                                                    OUT PVOID *VirtualAddress);
+        STATIC XTCDECL EFI_STATUS InitializeApicBase(IN PXTBL_PAGE_MAPPING PageMap);
+        STATIC XTCDECL EFI_STATUS InitializeLoaderBlock(IN PXTBL_PAGE_MAPPING PageMap,
+                                                        IN PVOID *VirtualAddress,
+                                                        IN PXTBL_BOOT_PARAMETERS Parameters);
+        STATIC XTCDECL EFI_STATUS InitializeVirtualMemory(IN OUT PLIST_ENTRY MemoryMappings,
+                                                          IN OUT PVOID *MemoryMapAddress);
+        STATIC XTCDECL EFI_STATUS LoadModule(IN PEFI_FILE_HANDLE BootDir,
+                                             IN PWCHAR FileName,
+                                             IN PVOID VirtualAddress,
+                                             IN LOADER_MEMORY_TYPE MemoryType,
+                                             OUT PPECOFF_IMAGE_CONTEXT *ImageContext);
+        STATIC XTCDECL EFI_STATUS MapHardwareMemoryPool(IN PXTBL_PAGE_MAPPING PageMap);
+        STATIC XTCDECL EFI_STATUS MapVirtualMemory(IN PLIST_ENTRY MemoryMappings,
+                                                   IN UINT_PTR VirtualAddress,
+                                                   IN UINT_PTR PhysicalAddress,
+                                                   IN UINT NumberOfPages,
+                                                   IN OUT PVOID *PtePointer);
+        STATIC XTCDECL EFI_STATUS RunBootSequence(IN PEFI_FILE_HANDLE BootDir,
+                                                  IN PXTBL_BOOT_PARAMETERS Parameters);
+};
+
+#endif /* __XTLDR_MODULES_XTOS_HH */

boot/xtldr/modules/xtos_o/xtos.cc

@@ -0,0 +1,729 @@
+/**
+ * PROJECT:         ExectOS
+ * COPYRIGHT:       See COPYING.md in the top level directory
+ * FILE:            xtldr/modules/xtos/xtos.cc
+ * DESCRIPTION:     XTOS boot protocol support
+ * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
+ */
+
+#include <xtos.hh>
+
+
+/* XTOS module information */
+MODULE_AUTHOR(L"Rafal Kupiec <belliash@codingworkshop.eu.org>");
+MODULE_DESCRIPTION(L"XTOS boot protocol support");
+MODULE_DEPENDENCY(L"acpi framebuf pecoff");
+MODULE_LICENSE(L"GPLv3");
+MODULE_VERSION(L"0.1");
+
+
+/**
+ * Starts the operating system according to the provided parameters using XTOS boot protocol.
+ *
+ * @param Parameters
+ *        Input parameters with detailed system configuration like boot device or kernel path.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::BootSystem(IN PXTBL_BOOT_PARAMETERS Parameters)
+{
+    EFI_GUID PeCoffProtocolGuid = XT_PECOFF_IMAGE_PROTOCOL_GUID;
+    EFI_HANDLE DiskHandle, ProtocolHandle;
+    PEFI_FILE_HANDLE FsHandle, BootDir;
+    PWCHAR SystemPath;
+    EFI_STATUS Status;
+
+    /* Print debug message */
+    XtLdrProtocol->Debug.Print(L"XTOS boot protocol activated\n");
+
+    /* Open the XT PE/COFF protocol */
+    Status = XtLdrProtocol->Protocol.Open(&ProtocolHandle, (PVOID *)&PeCoffProtocol, &PeCoffProtocolGuid);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to open loader protocol */
+        XtLdrProtocol->Debug.Print(L"ERROR: Unable to load PE/COFF image protocol\n");
+        return STATUS_EFI_PROTOCOL_ERROR;
+    }
+
+    /* Check device path */
+    if(Parameters->DevicePath == NULLPTR)
+    {
+        /* No device path set */
+        XtLdrProtocol->Debug.Print(L"ERROR: No device path provided, unable to boot system\n");
+        return STATUS_EFI_INVALID_PARAMETER;
+    }
+
+    /* Check if system path is set */
+    if(Parameters->SystemPath != NULLPTR)
+    {
+        /* Make sure system path begins with backslash, the only separator supported by EFI */
+        if(Parameters->SystemPath[0] == '/')
+        {
+            /* Replace directory separator if needed */
+            Parameters->SystemPath[0] = '\\';
+        }
+
+        /* Validate system path */
+        SystemPath = &Parameters->SystemPath[1];
+        while(*SystemPath)
+        {
+            /* Make sure it does not point to any subdirectory and not contains special characters */
+            if(((*SystemPath | 32) - 'a' >= 26) && ((*SystemPath - '0') >= 10))
+            {
+                /* Invalid path specified */
+                XtLdrProtocol->Debug.Print(L"ERROR: System path does not point to the valid XTOS installation\n");
+                return STATUS_EFI_INVALID_PARAMETER;
+            }
+            /* Check next character in the path */
+            SystemPath++;
+        }
+    }
+    else
+    {
+        /* Fallback to '/ExectOS' by default */
+        XtLdrProtocol->Debug.Print(L"WARNING: No system path set, falling back to defaults\n");
+        Parameters->SystemPath = (PWCHAR)L"\\ExectOS";
+    }
+
+    /* Check if kernel file is set */
+    if(Parameters->KernelFile == NULLPTR)
+    {
+        /* No kernel filename set, fallback to default */
+        XtLdrProtocol->Debug.Print(L"WARNING: No kernel file specified, falling back to defaults\n");
+        Parameters->KernelFile = (PWCHAR)L"xtoskrnl.exe";
+    }
+
+    /* Check if provided any kernel boot arguments */
+    if(Parameters->Parameters == NULLPTR)
+    {
+        /* No argument supplied */
+        Parameters->Parameters = (PWCHAR)L"";
+    }
+
+    /* Print a debug message */
+    XtLdrProtocol->Debug.Print(L"[XTOS] ARC Path: %S\n"
+                               L"[XTOS] System Path: %S\n"
+                               L"[XTOS] Kernel File: %S\n"
+                               L"[XTOS] Boot Arguments: %S\n",
+                               Parameters->ArcName, Parameters->SystemPath,
+                               Parameters->KernelFile, Parameters->Parameters);
+
+    /* Open EFI volume */
+    Status = XtLdrProtocol->Disk.OpenVolume(Parameters->DevicePath, &DiskHandle, &FsHandle);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to open a volume */
+        XtLdrProtocol->Debug.Print(L"ERROR: Unable to open boot volume\n");
+        return Status;
+    }
+
+    /* System path has to point to the boot directory */
+    XtLdrProtocol->WideString.Concatenate(Parameters->SystemPath, (PWCHAR)L"\\Boot", 0);
+
+    /* Open XTOS system boot directory */
+    Status = FsHandle->Open(FsHandle, &BootDir, Parameters->SystemPath, EFI_FILE_MODE_READ, 0);
+    FsHandle->Close(FsHandle);
+
+    /* Check if system path directory opened successfully */
+    if(Status == STATUS_EFI_NOT_FOUND)
+    {
+        /* Directory not found, nothing to load */
+        XtLdrProtocol->Debug.Print(L"ERROR: System boot directory not found\n");
+
+        /* Close volume */
+        XtLdrProtocol->Disk.CloseVolume(&DiskHandle);
+        return Status;
+    }
+    else if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to open directory */
+        XtLdrProtocol->Debug.Print(L"ERROR: Unable to open system boot directory\n");
+        XtLdrProtocol->Disk.CloseVolume(&DiskHandle);
+        return Status;
+    }
+
+    /* Start boot sequence */
+    return RunBootSequence(BootDir, Parameters);
+}
+
+/**
+ * Returns information about frame buffer in XTOS compatible format.
+ *
+ * @param InformationBlock
+ *        A pointer to memory area containing XT structure where all the information will be stored.
+ *
+ * @return This routine does not return any value.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+VOID
+Xtos::GetDisplayInformation(OUT PSYSTEM_RESOURCE_FRAMEBUFFER FrameBufferResource,
+                            IN PEFI_PHYSICAL_ADDRESS FrameBufferBase,
+                            IN PULONG_PTR FrameBufferSize,
+                            IN PXTBL_FRAMEBUFFER_MODE_INFORMATION FrameBufferModeInfo)
+{
+    /* Fill in frame buffer resource */
+    FrameBufferResource->Header.PhysicalAddress = (PVOID)*FrameBufferBase;
+    FrameBufferResource->Header.ResourceType = SystemResourceFrameBuffer;
+    FrameBufferResource->Header.ResourceSize = sizeof(SYSTEM_RESOURCE_FRAMEBUFFER);
+    FrameBufferResource->BufferSize = *FrameBufferSize;
+    FrameBufferResource->Width = FrameBufferModeInfo->Width;
+    FrameBufferResource->Height = FrameBufferModeInfo->Height;
+    FrameBufferResource->Depth = FrameBufferModeInfo->Depth;
+    FrameBufferResource->BitsPerPixel = FrameBufferModeInfo->BitsPerPixel;
+    FrameBufferResource->PixelsPerScanLine = FrameBufferModeInfo->PixelsPerScanLine;
+    FrameBufferResource->Pitch = FrameBufferModeInfo->Pitch;
+    FrameBufferResource->Pixels.BlueShift = FrameBufferModeInfo->PixelInformation.BlueShift;
+    FrameBufferResource->Pixels.BlueSize = FrameBufferModeInfo->PixelInformation.BlueSize;
+    FrameBufferResource->Pixels.GreenShift = FrameBufferModeInfo->PixelInformation.GreenShift;
+    FrameBufferResource->Pixels.GreenSize = FrameBufferModeInfo->PixelInformation.GreenSize;
+    FrameBufferResource->Pixels.RedShift = FrameBufferModeInfo->PixelInformation.RedShift;
+    FrameBufferResource->Pixels.RedSize = FrameBufferModeInfo->PixelInformation.RedSize;
+    FrameBufferResource->Pixels.ReservedShift = FrameBufferModeInfo->PixelInformation.ReservedShift;
+    FrameBufferResource->Pixels.ReservedSize = FrameBufferModeInfo->PixelInformation.ReservedSize;
+}
+
+XTCDECL
+EFI_STATUS
+Xtos::GetMemoryDescriptorList(IN PXTBL_PAGE_MAPPING PageMap,
+                              IN PVOID *VirtualAddress,
+                              OUT PLIST_ENTRY MemoryDescriptorList)
+{
+    EFI_PHYSICAL_ADDRESS Address;
+    EFI_STATUS Status;
+    ULONGLONG Pages;
+
+    Pages = (ULONGLONG)EFI_SIZE_TO_PAGES((PageMap->MapSize + 1) * sizeof(LOADER_MEMORY_DESCRIPTOR));
+
+    Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, Pages, &Address);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        return Status;
+    }
+
+    Status = XtLdrProtocol->Memory.MapVirtualMemory(PageMap, *VirtualAddress, (PVOID)Address, Pages, LoaderMemoryData);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        XtLdrProtocol->Memory.FreePages(Address, Pages);
+        return Status;
+    }
+
+    PVOID PhysicalBase = (PVOID)Address;
+
+    PLIST_ENTRY ListEntry;
+    ListEntry = PageMap->MemoryMap.Flink;
+    while(ListEntry != &PageMap->MemoryMap)
+    {
+        PXTBL_MEMORY_MAPPING MemoryMapping = CONTAIN_RECORD(ListEntry, XTBL_MEMORY_MAPPING, ListEntry);
+        PLOADER_MEMORY_DESCRIPTOR MemoryDescriptor = (PLOADER_MEMORY_DESCRIPTOR)Address;
+
+        MemoryDescriptor->MemoryType = MemoryMapping->MemoryType;
+        MemoryDescriptor->BasePage = (UINT_PTR)MemoryMapping->PhysicalAddress / EFI_PAGE_SIZE;
+        MemoryDescriptor->PageCount = MemoryMapping->NumberOfPages;
+
+        XtLdrProtocol->LinkedList.InsertTail(MemoryDescriptorList, &MemoryDescriptor->ListEntry);
+
+        Address = Address + sizeof(LOADER_MEMORY_DESCRIPTOR);
+        ListEntry = ListEntry->Flink;
+    }
+
+    XtLdrProtocol->Memory.PhysicalListToVirtual(PageMap, MemoryDescriptorList, PhysicalBase, *VirtualAddress);
+
+    return STATUS_EFI_SUCCESS;
+}
+
+XTCDECL
+EFI_STATUS
+Xtos::GetSystemResourcesList(IN PXTBL_PAGE_MAPPING PageMap,
+                             IN PVOID *VirtualAddress,
+                             OUT PLIST_ENTRY SystemResourcesList)
+{
+    XTSTATUS Status;
+    EFI_HANDLE ProtocolHandle;
+    EFI_GUID AcpiGuid = XT_ACPI_PROTOCOL_GUID;
+    EFI_GUID FrameBufGuid = XT_FRAMEBUFFER_PROTOCOL_GUID;
+    PXTBL_ACPI_PROTOCOL AcpiProtocol;
+    PXTBL_FRAMEBUFFER_PROTOCOL FrameBufProtocol;
+    XTBL_FRAMEBUFFER_MODE_INFORMATION FbModeInfo;
+    EFI_PHYSICAL_ADDRESS FbAddress;
+    ULONG_PTR FbSize;
+    UINT FrameBufferPages;
+    PSYSTEM_RESOURCE_FRAMEBUFFER FrameBufferResource;
+    PSYSTEM_RESOURCE_ACPI AcpiResource;
+    ULONGLONG Pages;
+    EFI_PHYSICAL_ADDRESS Address;
+    PVOID PhysicalBase, VirtualBase;
+
+    Pages = (ULONGLONG)EFI_SIZE_TO_PAGES(sizeof(SYSTEM_RESOURCE_ACPI) + sizeof(SYSTEM_RESOURCE_FRAMEBUFFER));
+
+    Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, Pages, &Address);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        return Status;
+    }
+    Status = XtLdrProtocol->Memory.MapVirtualMemory(PageMap, *VirtualAddress, (PVOID)Address, Pages, LoaderFirmwarePermanent);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        XtLdrProtocol->Memory.FreePages(Address, Pages);
+        return Status;
+    }
+
+    PhysicalBase = (PVOID)Address;
+    VirtualBase = *VirtualAddress;
+
+    /* Calculate next valid virtual address */
+    *VirtualAddress = (PUINT8)*VirtualAddress + (Pages * EFI_PAGE_SIZE);
+
+    AcpiResource = (PSYSTEM_RESOURCE_ACPI)Address;
+
+    XtLdrProtocol->Memory.ZeroMemory(AcpiResource, sizeof(SYSTEM_RESOURCE_ACPI));
+
+    /* Load FrameBuffer protocol */
+    Status = XtLdrProtocol->Protocol.Open(&ProtocolHandle, (PVOID*)&AcpiProtocol, &AcpiGuid);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        return Status;
+    }
+
+    AcpiResource->Header.ResourceType = SystemResourceAcpi;
+    AcpiResource->Header.ResourceSize = sizeof(SYSTEM_RESOURCE_ACPI);
+
+    /* Get APIC and XSDP/RSDP addresses */
+    AcpiProtocol->GetApicBase(&AcpiResource->ApicBase);
+    AcpiProtocol->GetAcpiDescriptionPointer(&AcpiResource->Header.PhysicalAddress);
+
+    /* No need to map ACPI */
+    AcpiResource->Header.VirtualAddress = 0;
+
+    XtLdrProtocol->LinkedList.InsertTail(SystemResourcesList, &AcpiResource->Header.ListEntry);
+
+    /* Close FrameBuffer protocol */
+    XtLdrProtocol->Protocol.Close(&ProtocolHandle, &FrameBufGuid);
+
+    Address = Address + sizeof(SYSTEM_RESOURCE_ACPI);
+
+    FrameBufferResource = (PSYSTEM_RESOURCE_FRAMEBUFFER)Address;
+
+    XtLdrProtocol->Memory.ZeroMemory(FrameBufferResource, sizeof(SYSTEM_RESOURCE_FRAMEBUFFER));
+
+    /* Load FrameBuffer protocol */
+    Status = XtLdrProtocol->Protocol.Open(&ProtocolHandle, (PVOID*)&FrameBufProtocol, &FrameBufGuid);
+    if(Status == STATUS_EFI_SUCCESS)
+    {
+        /* Get FrameBuffer information */
+        Status = FrameBufProtocol->GetDisplayInformation(&FbAddress, &FbSize, &FbModeInfo);
+        if(Status == STATUS_EFI_SUCCESS)
+        {
+
+            /* Store information about FrameBuffer device */
+            GetDisplayInformation(FrameBufferResource, &FbAddress, &FbSize, &FbModeInfo);
+        }
+    }
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        return Status;
+    }
+
+    /* Calculate pages needed to map framebuffer */
+    FrameBufferPages = EFI_SIZE_TO_PAGES(FbSize);
+
+    /* Rewrite framebuffer address by using virtual address */
+    FrameBufferResource->Header.VirtualAddress = *VirtualAddress;
+
+    /* Map frame buffer memory */
+    XtLdrProtocol->Memory.MapVirtualMemory(PageMap, FrameBufferResource->Header.VirtualAddress,
+                                           FrameBufferResource->Header.PhysicalAddress,
+                                           FrameBufferPages, LoaderFirmwarePermanent);
+
+    /* Close FrameBuffer protocol */
+    XtLdrProtocol->Protocol.Close(&ProtocolHandle, &FrameBufGuid);
+
+    *VirtualAddress = (PUINT8)*VirtualAddress + (FrameBufferPages * EFI_PAGE_SIZE);
+
+    XtLdrProtocol->LinkedList.InsertTail(SystemResourcesList, &FrameBufferResource->Header.ListEntry);
+
+    XtLdrProtocol->Memory.PhysicalListToVirtual(PageMap, SystemResourcesList, PhysicalBase, VirtualBase);
+
+    return STATUS_EFI_SUCCESS;
+}
+
+/**
+ * Checks if APIC is present in the system and finds its base address.
+ *
+ * @param MemoryMappings
+ *        Supplies a pointer to linked list containing all memory mappings.
+ *
+ * @return This routine returns an EFI status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::InitializeApicBase(IN PXTBL_PAGE_MAPPING PageMap)
+{
+    EFI_GUID AcpiGuid = XT_ACPI_PROTOCOL_GUID;
+    PXTBL_ACPI_PROTOCOL AcpiProtocol;
+    EFI_HANDLE ProtocolHandle;
+    PVOID ApicBaseAddress;
+    EFI_STATUS Status;
+
+    /* Open ACPI protocol */
+    Status = XtLdrProtocol->Protocol.Open(&ProtocolHandle, (PVOID*)&AcpiProtocol, &AcpiGuid);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* ACPI protocol not found */
+        return Status;
+    }
+
+    /* Get APIC base address */
+    Status = AcpiProtocol->GetApicBase(&ApicBaseAddress);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to get APIC base address */
+        return Status;
+    }
+
+    /* Map APIC base address */
+    XtLdrProtocol->Memory.MapVirtualMemory(PageMap, (PVOID)APIC_BASE, ApicBaseAddress, 1, LoaderFirmwarePermanent);
+    return STATUS_EFI_SUCCESS;
+}
+
+/**
+ * Initializes and maps the kernel initialization block.
+ *
+ * @param MemoryMappings
+ *        Supplies a pointer to linked list containing all memory mappings.
+ *
+ * @param VirtualAddress
+ *        Supplies a pointer to the next valid, free and available virtual address.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::InitializeLoaderBlock(IN PXTBL_PAGE_MAPPING PageMap,
+                            IN PVOID *VirtualAddress,
+                            IN PXTBL_BOOT_PARAMETERS Parameters)
+{
+    PKERNEL_INITIALIZATION_BLOCK LoaderBlock;
+    EFI_PHYSICAL_ADDRESS Address;
+    EFI_STATUS Status;
+    UINT BlockPages;
+    UINT ParametersSize;
+
+    /* Calculate size of parameters */
+    ParametersSize = (XtLdrProtocol->WideString.Length(Parameters->Parameters, 0) + 1) * sizeof(WCHAR);
+
+    /* Calculate number of pages needed for initialization block */
+    BlockPages = EFI_SIZE_TO_PAGES(sizeof(KERNEL_INITIALIZATION_BLOCK) + ParametersSize);
+
+    /* Allocate memory for kernel initialization block */
+    Status = XtLdrProtocol->Memory.AllocatePages(AllocateAnyPages, BlockPages, &Address);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Memory allocation failure */
+        return Status;
+    }
+
+    /* Initialize and zero-fill kernel initialization block */
+    LoaderBlock = (PKERNEL_INITIALIZATION_BLOCK)(UINT_PTR)Address;
+    XtLdrProtocol->Memory.ZeroMemory(LoaderBlock, sizeof(KERNEL_INITIALIZATION_BLOCK) + ParametersSize);
+
+    /* Set basic loader block properties */
+    LoaderBlock->BlockSize = sizeof(KERNEL_INITIALIZATION_BLOCK);
+    LoaderBlock->BlockVersion = INITIALIZATION_BLOCK_VERSION;
+    LoaderBlock->ProtocolVersion = BOOT_PROTOCOL_VERSION;
+
+    /* Set LoaderInformation block properties */
+    LoaderBlock->LoaderInformation.DbgPrint = (PVOID)XtLdrProtocol->Debug.Print;
+
+    /* Set FirmwareInformation block properties */
+    LoaderBlock->FirmwareInformation.FirmwareType = SystemFirmwareEfi;
+    // LoaderBlock->FirmwareInformation.EfiFirmware.EfiVersion = EfiSystemTable->Hdr.Revision;
+    LoaderBlock->FirmwareInformation.EfiFirmware.EfiRuntimeServices = NULLPTR;
+
+    /* Copy parameters to kernel initialization block */
+    LoaderBlock->KernelParameters = (PWCHAR)((UINT_PTR)*VirtualAddress + sizeof(KERNEL_INITIALIZATION_BLOCK));
+    XtLdrProtocol->Memory.CopyMemory((PVOID)((UINT_PTR)LoaderBlock + sizeof(KERNEL_INITIALIZATION_BLOCK)),
+                  Parameters->Parameters,
+                  ParametersSize);
+
+    /* Map kernel initialization block */
+    XtLdrProtocol->Memory.MapVirtualMemory(PageMap, *VirtualAddress, (PVOID)LoaderBlock,
+                                           BlockPages, LoaderSystemBlock);
+
+    /* Calculate next valid virtual address */
+    *VirtualAddress = (PUINT8)*VirtualAddress + (BlockPages * EFI_PAGE_SIZE);
+
+    XtLdrProtocol->LinkedList.InitializeHead(&LoaderBlock->SystemResourcesListHead);
+    GetSystemResourcesList(PageMap, VirtualAddress, &LoaderBlock->SystemResourcesListHead);
+
+    /* Initialize memory descriptor list */
+    XtLdrProtocol->LinkedList.InitializeHead(&LoaderBlock->MemoryDescriptorListHead);
+    GetMemoryDescriptorList(PageMap, VirtualAddress, &LoaderBlock->MemoryDescriptorListHead);
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}
+
+XTCDECL
+EFI_STATUS
+Xtos::InitializeModule(IN EFI_HANDLE ImageHandle,
+                       IN PEFI_SYSTEM_TABLE SystemTable)
+{
+    EFI_GUID Guid = XT_XTOS_BOOT_PROTOCOL_GUID;
+    EFI_STATUS Status;
+
+    /* Open the XTLDR protocol */
+    Status = BlGetXtLdrProtocol(SystemTable, ImageHandle, &XtLdrProtocol);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to open loader protocol */
+        return STATUS_EFI_PROTOCOL_ERROR;
+    }
+
+    /* Set routines available via XTOS boot protocol */
+    BootProtocol.BootSystem = Xtos::BootSystem;
+
+    /* Register XTOS boot protocol */
+    XtLdrProtocol->Boot.RegisterProtocol(L"XTOS", &Guid);
+
+    /* Install XTOS protocol */
+    return XtLdrProtocol->Protocol.Install(&BootProtocol, &Guid);
+}
+
+/**
+ * Loads XTOS PE/COFF module.
+ *
+ * @param SystemDir
+ *        An EFI handle to the opened system directory containing a module that will be loaded.
+ *
+ * @param FileName
+ *        An on disk filename of the module that will be loaded.
+ *
+ * @param VirtualAddress
+ *        Optional virtual address pointing to the memory area where PE/COFF file will be loaded.
+ *
+ * @param MemoryType
+ *        Supplies the type of memory to be assigned to the memory descriptor.
+ *
+ * @param ImageContext
+ *        Supplies pointer to the memory area where loaded PE/COFF image context will be stored.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::LoadModule(IN PEFI_FILE_HANDLE SystemDir,
+                 IN PWCHAR FileName,
+                 IN PVOID VirtualAddress,
+                 IN LOADER_MEMORY_TYPE MemoryType,
+                 OUT PPECOFF_IMAGE_CONTEXT *ImageContext)
+{
+    PEFI_FILE_HANDLE ModuleHandle;
+    USHORT MachineType, SubSystem;
+    EFI_STATUS Status;
+
+    /* Print debug message */
+    XtLdrProtocol->Debug.Print(L"Loading %S ... \n", FileName);
+
+    /* Open module file */
+    Status = SystemDir->Open(SystemDir, &ModuleHandle, FileName, EFI_FILE_MODE_READ, 0);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Unable to open the file */
+        XtLdrProtocol->Debug.Print(L"ERROR: Failed to open '%S'\n", FileName);
+        return Status;
+    }
+
+    /* Load the PE/COFF image file */
+    Status = PeCoffProtocol->LoadImage(ModuleHandle, MemoryType, VirtualAddress, (PVOID*)ImageContext);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Unable to load the file */
+        XtLdrProtocol->Debug.Print(L"ERROR: Failed to load '%S'\n", FileName);
+        return Status;
+    }
+
+    /* Close image file */
+    ModuleHandle->Close(ModuleHandle);
+
+    /* Check PE/COFF image machine type compatibility */
+    PeCoffProtocol->GetMachineType(*ImageContext, &MachineType);
+    if(MachineType != _ARCH_IMAGE_MACHINE_TYPE)
+    {
+        /* Machine type mismatch */
+        XtLdrProtocol->Debug.Print(L"ERROR: Loaded incompatible PE/COFF image (machine type mismatch)\n");
+        return STATUS_EFI_INCOMPATIBLE_VERSION;
+    }
+
+    /* Check PE/COFF image subsystem */
+    PeCoffProtocol->GetSubSystem(*ImageContext, &SubSystem);
+    if(SubSystem != PECOFF_IMAGE_SUBSYSTEM_XT_NATIVE_KERNEL &&
+       SubSystem != PECOFF_IMAGE_SUBSYSTEM_XT_NATIVE_APPLICATION &&
+       SubSystem != PECOFF_IMAGE_SUBSYSTEM_XT_NATIVE_DRIVER)
+    {
+        XtLdrProtocol->Debug.Print(L"WARNING: Loaded PE/COFF image with non-XT subsystem set\n");
+    }
+
+    /* Print debug message */
+    XtLdrProtocol->Debug.Print(L"Loaded %S at PA: %P, VA: %P\n", FileName,
+                               (*ImageContext)->PhysicalAddress, (*ImageContext)->VirtualAddress);
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}
+
+/**
+ * This routine initiates an XTOS boot sequence.
+ *
+ * @param BootDir
+ *        An EFI handle to the XTOS boot directory.
+ *
+ * @param Parameters
+ *        Input parameters with detailed system configuration like boot device or kernel path.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Xtos::RunBootSequence(IN PEFI_FILE_HANDLE BootDir,
+                      IN PXTBL_BOOT_PARAMETERS Parameters)
+{
+    EFI_GUID LoadedImageGuid = EFI_LOADED_IMAGE_PROTOCOL_GUID;
+    EFI_GUID FrameBufGuid = XT_FRAMEBUFFER_PROTOCOL_GUID;
+    PKERNEL_INITIALIZATION_BLOCK KernelParameters;
+    PXTBL_FRAMEBUFFER_PROTOCOL FrameBufProtocol;
+    PPECOFF_IMAGE_CONTEXT ImageContext = NULLPTR;
+    PEFI_LOADED_IMAGE_PROTOCOL ImageProtocol;
+    PVOID VirtualAddress, VirtualMemoryArea;
+    PXT_ENTRY_POINT KernelEntryPoint;
+    EFI_HANDLE ProtocolHandle;
+    EFI_STATUS Status;
+    XTBL_PAGE_MAPPING PageMap;
+
+    /* Initialize XTOS startup sequence */
+    XtLdrProtocol->Debug.Print(L"Initializing XTOS startup sequence\n");
+
+    /* Load FrameBuffer protocol */
+    Status = XtLdrProtocol->Protocol.Open(&ProtocolHandle, (PVOID*)&FrameBufProtocol, &FrameBufGuid);
+    if(Status == STATUS_EFI_SUCCESS)
+    {
+        /* Make sure FrameBuffer is initialized */
+        FrameBufProtocol->Initialize();
+        FrameBufProtocol->SetScreenResolution(0, 0);
+    }
+
+    /* Close FrameBuffer protocol */
+    XtLdrProtocol->Protocol.Close(&ProtocolHandle, &FrameBufGuid);
+
+    /* Set base virtual memory area for the kernel mappings */
+    VirtualMemoryArea = (PVOID)KSEG0_BASE;
+    VirtualAddress = (PVOID)(KSEG0_BASE + KSEG0_KERNEL_BASE);
+
+    /* Initialize virtual memory mappings */
+    XtLdrProtocol->Memory.InitializePageMap(&PageMap, DeterminePagingLevel(Parameters->Parameters), Size4K);
+
+    Status = XtLdrProtocol->Memory.MapEfiMemory(&PageMap, &VirtualMemoryArea, NULLPTR);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        return Status;
+    }
+
+    /* Load the kernel */
+    Status = LoadModule(BootDir, Parameters->KernelFile, VirtualAddress, LoaderSystemCode, &ImageContext);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to load the kernel */
+        return Status;
+    }
+
+    /* Add kernel image memory mapping */
+    Status = XtLdrProtocol->Memory.MapVirtualMemory(&PageMap, ImageContext->VirtualAddress,
+                                                    ImageContext->PhysicalAddress, ImageContext->ImagePages,
+                                                    LoaderSystemCode);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        return Status;
+    }
+
+    /* Set next valid virtual address right after the kernel */
+    VirtualAddress = (PUINT8)VirtualAddress + (ImageContext->ImagePages * EFI_PAGE_SIZE);
+
+    /* Find and map APIC base address */
+    Status = InitializeApicBase(&PageMap);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to setup kernel initialization block */
+        XtLdrProtocol->Debug.Print(L"Failed to initialize APIC (Status Code: 0x%zX)\n", Status);
+        return Status;
+    }
+
+    /* Store virtual address of kernel initialization block for future kernel call */
+    KernelParameters = (PKERNEL_INITIALIZATION_BLOCK)VirtualAddress;
+
+    /* Setup and map kernel initialization block */
+    Status = InitializeLoaderBlock(&PageMap, &VirtualAddress, Parameters);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to setup kernel initialization block */
+        XtLdrProtocol->Debug.Print(L"Failed to setup kernel initialization block (Status Code: 0x%zX)\n", Status);
+        return Status;
+    }
+
+    /* Get kernel entry point */
+    PeCoffProtocol->GetEntryPoint(ImageContext, (PVOID*)&KernelEntryPoint);
+
+    /* Close boot directory handle */
+    BootDir->Close(BootDir);
+
+    /* Enable paging */
+    XtLdrProtocol->Protocol.Open(&ProtocolHandle, (PVOID*)&ImageProtocol, &LoadedImageGuid);
+    Status = EnablePaging(&PageMap);
+    if(Status != STATUS_EFI_SUCCESS)
+    {
+        /* Failed to enable paging */
+        XtLdrProtocol->Debug.Print(L"Failed to enable paging (Status Code: 0x%zX)\n", Status);
+        return Status;
+    }
+
+    /* Call XTOS kernel */
+    XtLdrProtocol->Debug.Print(L"Booting the XTOS kernel\n");
+    KernelEntryPoint(KernelParameters);
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}
+
+/**
+ * This routine is the entry point of the XT EFI boot loader module.
+ *
+ * @param ImageHandle
+ *        Firmware-allocated handle that identifies the image.
+ *
+ * @param SystemTable
+ *        Provides the EFI system table.
+ *
+ * @return This routine returns status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+XtLdrModuleMain(IN EFI_HANDLE ImageHandle,
+                IN PEFI_SYSTEM_TABLE SystemTable)
+{
+    /* Initialize XTOS module */
+    return Xtos::InitializeModule(ImageHandle, SystemTable);
+}