Add support for WHPX accelerator on Windows and introduce OVMF Pure EFI firmware

2025-10-05 21:23:42 +02:00
134 changed files with 1023 additions and 8151 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -60,10 +60,12 @@ file(RELATIVE_PATH _PATH_PREFIX ${EXECTOS_BINARY_DIR} ${EXECTOS_SOURCE_DIR})
 add_compiler_flags(-D__RELFILE__="&__FILE__[__FILE__[0] == '.' ? sizeof \\\"${_PATH_PREFIX}\\\" - 1 : sizeof XTOS_SOURCE_DIR]")

 # Set the virtual disk image size (in MiB)
-set_disk_image_size(48)
+set_disk_image_size(32)

 # Build all subprojects
 add_subdirectory(boot)
+add_subdirectory(bootdata)
 add_subdirectory(drivers)
 add_subdirectory(sdk)
+add_subdirectory(xtldr)
 add_subdirectory(xtoskrnl)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -9,7 +9,8 @@ porting drivers, fixing bugs, writing tests, creating documentation, or helping
 love the help.

 ## Wish List
-If you are looking for a way to contribute, but you are not sure where to start, check our list of
+If you are looking for a way to contribute, but you are not sure where to start, check our [IDEAS](IDEAS.md) and
+[KNOWN ISSUES](KNOWN_ISSUES.md) pages for suggestions. We try to keep them up to date. You can also check a list of
 [open issues](https://git.codingworkshop.eu.org/xt-sys/exectos/issues). If you find interesting task and you are serious
 about tackling one, feel free to contact us. We will be able to provide a more detailed information and suggestions
 towards getting started.
--- a/IDEAS.md
+++ b/IDEAS.md
@@ -0,0 +1,9 @@
+## ExectOS Ideas
+This is a list of ideas that migh but not must be realized.
+
+### XTOSKRNL
+ - [ ] Implement mechanism for detecting CPU features and checking hardware requirements. If CPU does not meet
+       requirements, it should cause a kernel panic before any non-supported instruction is being used.
+ - [ ] Finish framebuffer and terminal implementation. Initialization code is already prepared as well as routines for
+       clearing the screen and drawing single points. Terminal should be instantiable (should be able to create many
+       terminals and switch between them) and work on top of FB. It should define ANSI colors and scrollback buffer.
--- a/KNOWN_ISSUES.md
+++ b/KNOWN_ISSUES.md
@@ -0,0 +1,6 @@
+## ExectOS Known Issues
+This is a list of well known bugs that exists in all master branch builds.
+
+### XTLDR
+ - [ ] EFI Runtime Services are not mapped properly into higher half. They are mapped itself, but all pointers inside
+       that structure point to some physical address that is unavailable after paging is enabled.
--- a/README.md
+++ b/README.md
@@ -53,23 +53,20 @@ implement any environment subsystem to support applications that are strictly wr
 * NT drivers compatibility layer

 # Requirements
-ExectOS is currently in a very early stage of development, so its specific requirements are not fully defined yet.
-However, based on the current design, it requires modern EFI hardware. You cannot boot ExectOS on a legacy BIOS
-right now, but there are plans to add BIOS support in the future.
+ExectOS is in very early development stage, thus its requirements have been not specified yet. However according to its
+design, it requires a modern EFI enabled hardware. It is not possible currently to boot ExectOS on a legacy BIOS.

 # Source structure
-| Directory        | Description                                                  |
-|------------------|--------------------------------------------------------------|
-| boot/bootdata    | default configuration and data needed to boot XTOS           |
-| boot/bootsect    | boot sector code (MBR & VBR) initializing the boot process   |
-| boot/xtldr       | XTOS boot loader source code                                 |
-| drivers          | XT native drivers source code                                |
-| sdk/cmake        | host toolchain configuration and build-related functions     |
-| sdk/firmware     | firmware enabling XTOS to boot on virtual machines           |
-| sdk/xtdk         | XT Software Development Kit headers                          |
-| services         | integral subsystems services source code                     |
-| subsystems       | environment subsystems source code                           |
-| xtoskrnl         | XTOS kernel source code                                      |
+| Directory   | Description                                              |
+|-------------|----------------------------------------------------------|
+| bootdata    | default configuration and data needed to boot XTOS       |
+| drivers     | XT native drivers source code                            |
+| sdk/cmake   | Host toolchain configuration and build-related functions |
+| sdk/xtdk    | XT Software Development Kit headers                      |
+| services    | integral subsystems services source code                 |
+| subsystems  | environment subsystems source code                       |
+| xtoskrnl    | XTOS kernel source code                                  |
+| xtldr       | XTOS boot loader source code                             |

 # Build
 XTOS can only be built using [XTchain](https://git.codingworkshop.eu.org/xt-sys/xtchain), a dedicated toolchain designed
--- a/boot/CMakeLists.txt
+++ b/boot/CMakeLists.txt
@@ -1,3 +1 @@
-add_subdirectory(bootdata)
 add_subdirectory(bootsect)
-add_subdirectory(xtldr)
--- a/boot/bootsect/CMakeLists.txt
+++ b/boot/bootsect/CMakeLists.txt
@@ -1,8 +1,6 @@
 # XT Boot Sector
 PROJECT(BOOTSECT)

-add_definitions("-DARCH_ESP_SOURCE=\\\"${ARCH}/cpu.S\\\"")
-
 # Compile boot sectors
 compile_bootsector(mbrboot ${BOOTSECT_SOURCE_DIR}/mbrboot.S 0x7C00 Start)
 compile_bootsector(espboot ${BOOTSECT_SOURCE_DIR}/espboot.S 0x7C00 Start)
--- a/boot/bootsect/amd64/cpu.S
+++ b/boot/bootsect/amd64/cpu.S
@@ -1,144 +0,0 @@
-/**
- * PROJECT:         ExectOS
- * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            boot/bootsect/amd64/cpu.S
- * DESCRIPTION:     Low-level support for CPU initialization
- * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
- */
-
-
-BuildPageMap:
-    /* Generate page map for first 1GB of memory */
-    pushaw
-    pushw %es
-    cld
-    movw $(0x1000 / 16), %ax
-    movw %ax, %es
-    xorw %di, %di
-    movl $(0x2000 | 0x07), %eax
-    stosl
-    xorl %eax, %eax
-    movw $1021, %cx
-    rep stosl
-    movw $(0x2000 / 16), %ax
-    movw %ax, %es
-    xorw %di, %di
-    movl $(0x3000 | 0x07), %eax
-    stosl
-    xorl %eax, %eax
-    movw $1021, %cx
-    rep stosl
-    movw $(0x3000 / 16), %ax
-    movw %ax, %es
-    xorw %di, %di
-    movw $512, %cx
-    movl $0x00000083, %eax
-.BuildPageMapLoop:
-    /* Identity map 512 pages of 2MB */
-    movl %eax, %es:(%di)
-    addl $2097152, %eax
-    addw $0x08, %di
-    loop .BuildPageMapLoop
-    popw %es
-    popaw
-    ret
-
-InitializeCpu:
-    /* Check if CPU supports CPUID, long mode and PAE */
-    pushal
-    pushfl
-    popl %eax
-    movl %eax, %ebx
-    xorl $0x00200000, %eax
-    pushl %eax
-    popfl
-    pushfl
-    popl %eax
-    cmpl %ebx, %eax
-    je CpuUnsupported
-    movl $0x01, %eax
-    cpuid
-    testl $0x40, %edx
-    jz CpuUnsupported
-    movl $0x80000000, %eax
-    cpuid
-    cmpl $0x80000000, %eax
-    jbe CpuUnsupported
-    movl $0x80000001, %eax
-    cpuid
-    testl $0x20000000, %edx
-    jz CpuUnsupported
-    popal
-    call LoadGdt
-    ret
-
-LoadGdt:
-    /* Load Global Descriptor Table */
-    lgdt .GdtPointer
-    ret
-
-RunStage2:
-    /* Switch to long mode and pass control to Stage 2 */
-    call BuildPageMap
-    call ParseExecutableHeader
-    xorl %edx, %edx
-    pushl %edx
-    pushl %eax
-    cli
-    xorw %ax, %ax
-    movw %ax, %ds
-    movw %ax, %es
-    movw %ax, %fs
-    movw %ax, %gs
-    movw %ax, %ss
-    movl %cr4, %eax
-    orl $0x00A0, %eax
-    movl %eax, %cr4
-    movl $0x00001000, %eax
-    movl %eax, %cr3
-    movl $0xC0000080, %ecx
-    rdmsr
-    orl $0x00000100, %eax
-    wrmsr
-    movl %cr0, %eax
-    orl $0x80000001, %eax
-    movl %eax, %cr0
-    ljmp $0x10, $.Stage2LongMode
-.code64
-.Stage2LongMode:
-    /* Set segments and stack, then jump to Stage 2 */
-    movw $0x18, %ax
-    movw %ax, %ds
-    movw %ax, %es
-    movw %ax, %ss
-    xorw %ax, %ax
-    movw %ax, %fs
-    movw %ax, %gs
-    popq %rax
-    xorq %rbx, %rbx
-    xorq %rcx, %rcx
-    xorq %rdx, %rdx
-    xorq %rsi, %rsi
-    xorq %rdi, %rdi
-    xorq %rbp, %rbp
-    jmp *%rax
-
-.code16
-.GdtDescriptor:
-    /* Global Descriptor Table */
-    .quad 0x0000000000000000
-    .quad 0x0000000000000000
-    .quad 0x00AF9A000000FFFF
-    .quad 0x00CF92000000FFFF
-    .quad 0x00009E000000FFFF
-    .quad 0x000092000000FFFF
-    .quad 0x00CF9B000000FFFF
-
-.GdtPointer:
-    /* Pointer to Global Descriptor Table */
-    .word .GdtPointer - .GdtDescriptor - 1
-    .long .GdtDescriptor
-
-.Stage2FileName:
-    /* Name of Stage 2 executable file */
-    .ascii "BOOTX64 EFI"
--- a/boot/bootsect/espboot.S
+++ b/boot/bootsect/espboot.S
@@ -84,446 +84,30 @@ RealStart:
    leaw -16(%bp), %sp
    sti

-    /* Get drive number */
-    cmpb $0xFF, DriveNumber - Start(%bp)
-    jne GetDriveParameters
-    movb %dl, DriveNumber - Start(%bp)
-
-GetDriveParameters:
-    /* Get drive parameters from the BIOS */
-    movb DriveNumber - Start(%bp), %dl
-    movb $0x08, %ah
-    movb $0x00, %al
-    int $0x13
-    jnc GetDriveSize
-    movw $0xFFFF, %cx
-    movb %cl, %dh
-
-GetDriveSize:
-    /* Get drive size from the BIOS */
-    movzbl %dh, %eax
-    incw %ax
-    movzbl %cl, %edx
-    andb $0x3F, %dl
-    mulw %dx
-    xchgb %cl, %ch
-    shrb $0x06, %ch
-    incw %cx
-    movzwl %cx, %ecx
-    mull %ecx
-    movl %eax, %edi
-
-VerifyBiosParameterBlock:
-    /* Verify the FAT32 BPB */
-    cmpw $0x00, SectorsPerFat - Start(%bp)
-    jne FsError
-    cmpw $0x00, FsVersion - Start(%bp)
-    ja FsError
-
-ReadExtraCode:
-    /* Read second VBR sector with extra boot code (3 sectors starting from sector 2) */
-    movl HiddenSectors - Start(%bp), %eax
-    addl $0x02, %eax
-    movw $0x03, %cx
-    xorw %bx, %bx
-    movw %bx, %es
-    movw $0x7E00, %bx
-    call ReadSectors
-    jmp StartExtraCode
-
-ReadSectors:
-    /* Check for extended BIOS functions and use it only if available */
-    pushw %es
-    pushal
-    movb $0x41, %ah
-    movw $0x55AA, %bx
-    movb DriveNumber - Start(%bp), %dl
-    int $0x13
-    jc .ReadCHS
-    cmpw $0xAA55, %bx
-    jne .ReadCHS
-    testb $0x01, %cl
-    jz .ReadCHS
-
-    /* Verify drive size and determine whether to use CHS or LBA */
-    cmpl %edi, %eax
-    jnb .ReadLBA
-
-.ReadCHS:
-    /* Read sectors using CHS */
-    popal
-
-.CHSLoop:
-    /* Read sector by sector using CHS */
-    pushw %cx
-    pushal
-    xorl %edx, %edx
-    movzwl SectorsPerTrack - Start(%bp), %ecx
-    divl %ecx
-    incb %dl
-    movb %dl, %cl
-    movl %eax, %edx
-    shrl $0x10, %edx
-    divw NumberOfHeads - Start(%bp)
-    movb %dl, %dh
-    movb DriveNumber - Start(%bp), %dl
-    movb %al, %ch
-    rorb $0x01, %ah
-    rorb $0x01, %ah
-    orb %ah, %cl
-    movw $0x0201, %ax
-    int $0x13
-    popal
-    popw %cx
-    jc DiskError
-    incl %eax
-    movw %es, %dx
-    addw $0x20, %dx
-    movw %dx, %es
-    loop .CHSLoop
-    popw %es
-    ret
-
-.ReadLBA:
-    /* Prepare DAP packet and read sectors using LBA */
-    popal
-    pushw %cx
-    pushal
-    pushw $0x00
-    pushw $0x00
-    pushl %eax
-    pushw %es
-    pushw %bx
-    pushw %cx
-    pushw $0x10
-    movw %sp, %si
-    movb DriveNumber - Start(%bp), %dl
-    movb $0x42, %ah
-    int $0x13
-    jc DiskError
-    addw $0x10, %sp
-    popal
-    popw %si
-    pushw %bx
-    movzwl %si, %ebx
-    addl %ebx, %eax
-    shll $0x05, %ebx
-    movw %es, %dx
-    addw %bx, %dx
-    movw %dx, %es
-    popw %bx
-    subw %si, %cx
-    jnz .ReadLBA
-    popw %es
-    ret
-
-DiskError:
-    /* Display disk error message and reboot */
-    movw $.MsgDiskError, %si
+    /* Print message */
+    movw $msgUnavailable, %si
    call Print
-    jmp Reboot

-FsError:
-    /* Display FS error message and reboot */
-    movw $.MsgFsError, %si
-    call Print
-    jmp Reboot
+    /* Wait for key press and reboot */
+    xorw %ax, %ax
+    int $0x16
+    int $0x19

 Print:
    /* Simple routine to print messages */
    lodsb
    orb     %al, %al
-    jz      .DonePrint
+    jz      DonePrint
    movb    $0x0E, %ah
    movw    $0x07, %bx
    int     $0x10
    jmp     Print
-.DonePrint:
+DonePrint:
    retw

-Reboot:
-    /* Display a message, wait for a key press and reboot */
-    movw $.MsgAnyKey, %si
-    call Print
-    xorw %ax, %ax
-    int $0x16
-    int $0x19
-
-.MsgAnyKey:
-    .ascii "Press any key to restart...\r\n\0"
-
-.MsgDiskError:
-    .ascii "Disk error!\r\n\0"
-
-.MsgFsError:
-    .ascii "File system error!\r\n\0"
+msgUnavailable:
+    .ascii "XTLDR requires EFI-based system!\r\nPress any key to restart\r\n"

 /* Fill the rest of the VBR with zeros and add VBR signature at the end */
 .fill (510 - (. - Start)), 1, 0
 .word 0xAA55
-
-
-StartExtraCode:
-    /* Load XTLDR file from disk */
-    call LoadStage2
-
-    /* Enable A20 gate */
-    call EnableA20
-
-    /* Call architecture specific initialization code */
-    call InitializeCpu
-
-    /* Jump to Stage2 */
-    call RunStage2
-
-Clear8042:
-    /* Clear 8042 PS/2 buffer */
-    nop
-    nop
-    nop
-    nop
-    inb $0x64, %al
-    cmpb $0xff, %al
-    je .Clear8042_Done
-    testb $0x02, %al
-    jnz Clear8042
-.Clear8042_Done:
-    ret
-
-EnableA20:
-    /* Enable A20 gate */
-    pushaw
-    call Clear8042
-    movb $0xD1, %al
-    outb %al, $0x64
-    call Clear8042
-    movb $0xDF, %al
-    outb %al, $0x60
-    call Clear8042
-    movb $0xFF, %al
-    outb %al, $0x64
-    call Clear8042
-    popaw
-    ret
-
-FindFatEntry:
-    /* Find a file or directory in the FAT table */
-    pushw %bx
-    pushw %cx
-    pushw %dx
-    pushw %si
-    pushw %di
-.FindFatCluster:
-    /* Find FAT32 cluster holding the entry */
-    cmp $0x0FFFFFF8, %eax
-    jae .FindEntryFail
-    pushl %eax
-    movw $0x0200, %bx
-    movw %bx, %es
-    call ReadCluster
-    popl %eax
-    movb SectorsPerCluster - Start(%bp), %cl
-    shlw $0x04, %cx
-    xorw %di, %di
-.FindEntryLoop:
-    /* Find the entry */
-    movb %es:(%di), %al
-    cmpb $0x00, %al
-    je .FindEntryFail
-    cmpb $0xE5, %al
-    je .FindSkipEntry
-    movb %es:0x0B(%di), %ah
-    cmpb $0x0F, %ah
-    je .FindSkipEntry
-    pushw %di
-    pushw %si
-    pushw %cx
-    movw $0x0B, %cx
-    repe cmpsb
-    popw %cx
-    popw %si
-    popw %di
-    jnz .FindSkipEntry
-    movw %es:0x1A(%di), %ax
-    movw %es:0x14(%di), %dx
-    shll $0x10, %edx
-    orl %edx, %eax
-    clc
-    jmp .FindEntryDone
-.FindSkipEntry:
-    /* Skip to the next entry */
-    addw $0x20, %di
-    decw %cx
-    jnz .FindEntryLoop
-    call GetFatEntry
-    jmp .FindFatCluster
-.FindEntryFail:
-    /* Error, file/directory not found */
-    stc
-.FindEntryDone:
-    /* Clean up the stack */
-    popw %di
-    popw %si
-    popw %dx
-    popw %cx
-    popw %bx
-    ret
-
-GetFatEntry:
-    /* Get FAT32 sector and offset from FAT table */
-    shll $0x02, %eax
-    movl %eax, %ecx
-    xorl %edx, %edx
-    movzwl BytesPerSector - Start(%bp), %ebx
-    pushl %ebx
-    divl %ebx
-    movzwl ReservedSectors - Start(%bp), %ebx
-    addl %ebx, %eax
-    movl HiddenSectors - Start(%bp), %ebx
-    addl %ebx, %eax
-    popl %ebx
-    decl %ebx
-    andl %ebx, %ecx
-    movzwl ExtendedFlags - Start(%bp), %ebx
-    andw $0x0F, %bx
-    jz LoadFatSector
-    cmpb FatCopies - Start(%bp), %bl
-    jae FsError
-    pushl %eax
-    movl BigSectorsPerFat - Start(%bp), %eax
-    mull %ebx
-    popl %edx
-    addl %edx, %eax
-
-LoadFatSector:
-    /* Load FAT32 sector from disk */
-    pushl %ecx
-    movw $0x9000, %bx
-    movw %bx, %es
-    cmpl %esi, %eax
-    je .LoadFatSectorDone
-    movl %eax, %esi
-    xorw %bx, %bx
-    movw $0x01, %cx
-    call ReadSectors
-.LoadFatSectorDone:
-    /* Clean up the stack */
-    popl %ecx
-    movl %es:(%ecx), %eax
-    andl $0x0FFFFFFF, %eax
-    ret
-
-LoadStage2:
-    /* Load Stage2 executable, first find file in the path */
-    movl $0xFFFFFFFF, %esi
-    pushl %esi
-    movl 0x7C2C, %eax
-    movw $.EfiDirName, %si
-    call FindFatEntry
-    jc Stage2NotLoaded
-    movw $.BootDirName, %si
-    call FindFatEntry
-    jc Stage2NotLoaded
-    movw $.Stage2FileName, %si
-    call FindFatEntry
-    jc Stage2NotLoaded
-    popl %esi
-    /* Load XTLDR file from disk */
-    cmpl $0x02, %eax
-    jb FileNotFound
-    cmpl $0x0FFFFFF8, %eax
-    jae FileNotFound
-    movw $(0xF800 / 16), %bx
-    movw %bx, %es
-.LoadStage2Loop:
-    /* Load file data from disk */
-    pushl %eax
-    xorw %bx, %bx
-    pushw %es
-    call ReadCluster
-    popw %es
-    xorw %bx, %bx
-    movb SectorsPerCluster - Start(%bp), %bl
-    shlw $0x05, %bx
-    movw %es, %ax
-    addw %bx, %ax
-    movw %ax, %es
-    popl %eax
-    pushw %es
-    call GetFatEntry
-    popw %es
-    cmpl $0x0FFFFFF8, %eax
-    jb .LoadStage2Loop
-    ret
-
-ParseExecutableHeader:
-    /* Parse Stage2 PE/COFF executable header */
-    pushw %es
-    movw $(0xF800 / 16), %ax
-    movw %ax, %es
-    movl %es:60, %eax
-    addl $(4 + 20), %eax
-    movl %es:16(%eax), %eax
-    addl $0xF800, %eax
-    popw %es
-    ret
-
-ReadCluster:
-    /* Read FAT32 cluster from disk */
-    decl %eax
-    decl %eax
-    xorl %edx, %edx
-    movzbl SectorsPerCluster - Start(%bp), %ebx
-    mull %ebx
-    pushl %eax
-    xorl %edx, %edx
-    movzbl FatCopies - Start(%bp), %eax
-    mull BigSectorsPerFat - Start(%bp)
-    movzwl ReservedSectors - Start(%bp), %ebx
-    addl %ebx, %eax
-    addl HiddenSectors - Start(%bp), %eax
-    popl %ebx
-    addl %ebx, %eax
-    xorw %bx, %bx
-    movzbw SectorsPerCluster - Start(%bp), %cx
-    call ReadSectors
-    ret
-
-/* Include architecture specific code */
-.include ARCH_ESP_SOURCE
-
-CpuUnsupported:
-    /* Display CPU unsupported message and reboot */
-    popal
-    movw $.MsgCpuUnsupported, %si
-    call Print
-    jmp Reboot
-
-FileNotFound:
-    /* Display XTLDR not found message and reboot */
-    movw $.MsgXtLdrNotFound, %si
-    call Print
-    jmp Reboot
-
-Stage2NotLoaded:
-    /* Clean up the stack and display XTLDR not found message and reboot */
-    popl %esi
-    jmp FileNotFound
-
-.BootDirName:
-    /* Boot directory name */
-    .ascii "BOOT       "
-
-.EfiDirName:
-    /* EFI directory name */
-    .ascii "EFI        "
-
-.MsgCpuUnsupported:
-    .ascii "CPU not supported!\r\n\0"
-
-.MsgXtLdrNotFound:
-    .ascii "XTLDR Stage2 not found!\r\n\0"
-
-/* Fill the rest of the extra VBR with zeros and add signature */
-.fill (2043 - (. - Start)), 1, 0
-.ascii "XTLDR"
--- a/boot/bootsect/i686/cpu.S
+++ b/boot/bootsect/i686/cpu.S
@@ -1,124 +0,0 @@
-/**
- * PROJECT:         ExectOS
- * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            boot/bootsect/i686/cpu.S
- * DESCRIPTION:     Low-level support for CPU initialization
- * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
- */
-
-
-BuildPageMap:
-    /* Generate page map for first 16MB of memory */
-    pushaw
-    pushw %es
-    cld
-    movw $(0x1000 >> 0x04), %ax
-    movw %ax, %es
-    xorw %di, %di
-    movl $(0x2000 | 0x03), %eax
-    stosl
-    movl $(0x3000 | 0x03), %eax
-    stosl
-    movl $(0x4000 | 0x03), %eax
-    stosl
-    movl $(0x5000 | 0x03), %eax
-    stosl
-    xorl %eax, %eax
-    movw $(1024 - 4), %cx
-    rep stosl
-    movl $0x00000003, %eax
-    movl $4, %edx
-    movw $(0x2000 >> 0x04), %bx
-.BuildPageMapLoop:
-    /* Identity map 1024 pages of 4KB */
-    movw %bx, %es
-    xorw %di, %di
-    pushl %edx
-    movw $1024, %cx
-.FillPageMapTable:
-    /* Fill the page table */
-    movl %eax, %es:(%di)
-    addl $4096, %eax
-    addw $0x04, %di
-    loop .FillPageMapTable
-    popl %edx
-    addw $(0x1000 >> 0x04), %bx
-    decl %edx
-    jnz .BuildPageMapLoop
-    popw %es
-    popaw
-    ret
-
-InitializeCpu:
-    /* Check if CPU supports CPUID */
-    pushal
-    pushfl
-    popl %eax
-    movl %eax, %ebx
-    xorl $0x00200000, %eax
-    pushl %eax
-    popfl
-    pushfl
-    popl %eax
-    cmpl %ebx, %eax
-    je CpuUnsupported
-    popal
-    call LoadGdt
-    ret
-
-LoadGdt:
-    /* Load Global Descriptor Table */
-    lgdt .GdtPointer
-    ret
-
-RunStage2:
-    /* Switch to protected mode and pass control to Stage 2 */
-    call BuildPageMap
-    call ParseExecutableHeader
-    pushl %eax
-    cli
-    movl %cr0, %eax
-    orl $0x01, %eax
-    movl %eax, %cr0
-    ljmp $0x08, $.Stage2ProtectedMode
-.code32
-.Stage2ProtectedMode:
-    /* Set segments and stack, then jump to Stage 2 */
-    movw $0x10, %ax
-    movw %ax, %ds
-    movw %ax, %es
-    movw %ax, %ss
-    xorw %ax, %ax
-    movw %ax, %fs
-    movw %ax, %gs
-    popl %eax
-    xorl %ebx, %ebx
-    xorl %ecx, %ecx
-    xorl %edx, %edx
-    xorl %esi, %esi
-    xorl %edi, %edi
-    xorl %ebp, %ebp
-    movl $0x1000, %ebx
-    movl %ebx, %cr3
-    movl %cr0, %ebx
-    orl $0x80000000, %ebx
-    movl %ebx, %cr0
-    jmp *%eax
-
-.code16
-.GdtDescriptor:
-    /* Global Descriptor Table */
-    .quad 0x0000000000000000
-    .quad 0x00CF9A000000FFFF
-    .quad 0x00CF92000000FFFF
-    .quad 0x00009E000000FFFF
-    .quad 0x000092000000FFFF
-
-.GdtPointer:
-    /* Pointer to Global Descriptor Table */
-    .word .GdtPointer - .GdtDescriptor - 1
-    .long .GdtDescriptor
-
-.Stage2FileName:
-    /* Name of Stage 2 executable file */
-    .ascii "BOOTIA32EFI"
--- a/boot/bootsect/mbrboot.S
+++ b/boot/bootsect/mbrboot.S
@@ -4,7 +4,6 @@
 * FILE:            boot/bootsect/amd64/mbrboot.S
 * DESCRIPTION:     XT Boot Loader MBR boot code
 * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
- *                  Aiken Harris <aiken@codingworkshop.eu.org>
 */

 .text
@@ -42,7 +41,7 @@ RealStart:
    movw %ax, %ss

    /* Print welcome message */
-    leaw .MsgXtosBoot, %si
+    leaw msgXtosBoot, %si
    call Print

    /* Get BIOS boot drive and partition table offset */
@@ -91,19 +90,19 @@ PartitionFound:

 InvalidSignature:
    /* Invalid signature error */
-    leaw .MsgInvalidSignature, %si
+    leaw msgInvalidSignature, %si
    call Print
    jmp HaltSystem

 PartitionNotFound:
    /* Active partition not found error */
-    leaw .MsgPartitionNotFound, %si
+    leaw msgPartitionNotFound, %si
    call Print
    jmp HaltSystem

 VbrReadFail:
    /* VBR read failed error */
-    leaw .MsgVbrReadFail, %si
+    leaw msgVbrReadFail, %si
    call Print
    jmp HaltSystem

@@ -137,16 +136,16 @@ DonePrint:
    /* Storage for the LBA start */
    .long 0

-.MsgInvalidSignature:
+msgInvalidSignature:
    .asciz "Invalid partition signature!"

-.MsgPartitionNotFound:
+msgPartitionNotFound:
    .asciz "Bootable partition not found!"

-.MsgVbrReadFail:
+msgVbrReadFail:
    .asciz "VBR read failed!"

-.MsgXtosBoot:
+msgXtosBoot:
    .asciz "Starting XTOS boot loader...\r\n"

 /* Fill the rest of the MBR with zeros and add MBR signature at the end */
--- a/boot/xtldr/biosutil.cc
+++ b/boot/xtldr/biosutil.cc
@@ -1,190 +0,0 @@
-/**
- * PROJECT:         ExectOS
- * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtldr/biosutil.cc
- * DESCRIPTION:     Legacy BIOS support
- * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
- */
-
-#include <xtldr.hh>
-
-
-/**
- * Clears the entire screen and moves the cursor to the top-left corner.
- *
- * @return This routine does not return any value.
- *
- * @since XT 1.0
- */
-XTCDECL
-VOID
-BiosUtils::ClearScreen()
-{
-    VOLATILE PUSHORT VgaBuffer = (PUSHORT)0xB8000;
-    USHORT Blank;
-    UINT Index;
-
-    /* Set blank character */
-    Blank = (0x0F << 8) | L' ';
-
-    /* Fill the entire screen with blank characters */
-    for(Index = 0; Index < VgaWidth * VgaHeight; Index++)
-    {
-        VgaBuffer[Index] = Blank;
-    }
-
-    /* Reset cursor position to the top-left corner */
-    CursorX = 0;
-    CursorY = 0;
-
-    /* Update the hardware cursor position */
-    UpdateCursor();
-}
-
-/**
- * Formats the input string and prints it out to the screen.
- *
- * @param Format
- *        The formatted string that is to be written to the output.
- *
- * @param ...
- *        Depending on the format string, this routine might expect a sequence of additional arguments.
- *
- * @return This routine does not return any value.
- *
- * @since XT 1.0
- */
-XTCDECL
-VOID
-BiosUtils::Print(IN PCWSTR Format,
-                 IN ...)
-{
-    RTL_PRINT_CONTEXT PrintContext;
-    VA_LIST Arguments;
-
-    /* Initialise the print contexts */
-    PrintContext.WriteWideCharacter = PutChar;
-
-    /* Initialise the va_list */
-    VA_START(Arguments, Format);
-
-    /* Format and print the string to the stdout */
-    RTL::WideString::FormatWideString(&PrintContext, (PWCHAR)Format, Arguments);
-
-    /* Clean up the va_list */
-    VA_END(Arguments);
-}
-
-/**
- * Writes a single wide character to the screen using legacy BIOS VGA text mode.
- *
- * @param Character
- *        The wide character to be printed.
- *
- * @return This routine returns a status code.
- *
- * @since XT 1.0
- */
-XTCDECL
-XTSTATUS
-BiosUtils::PutChar(IN WCHAR Character)
-{
-    VOLATILE PUSHORT VgaBuffer = (PUSHORT)0xB8000;
-    USHORT VgaCharacter;
-
-    /* Handle special characters */
-    if(Character == L'\n')
-    {
-        /* Move to the next line */
-        CursorX = 0;
-        CursorY++;
-    }
-    else if(Character == L'\r')
-    {
-        /* Move to the beginning of the current line */
-        CursorX = 0;
-    }
-    else
-    {
-        /* Print character and move cursor to the right */
-        VgaCharacter = (0x0F << 8) | (Character & 0xFF);
-        VgaBuffer[CursorY * VgaWidth + CursorX] = VgaCharacter;
-        CursorX++;
-    }
-
-    /* Handle moving to the next line if cursor is at the end of the line */
-    if(CursorX >= VgaWidth)
-    {
-        CursorX = 0;
-        CursorY++;
-    }
-
-    /* Handle scrolling if cursor is at the end of the screen */
-    if(CursorY >= VgaHeight)
-    {
-        ScrollScreen();
-        CursorY = VgaHeight - 1;
-    }
-
-    /* Update the hardware cursor position */
-    UpdateCursor();
-
-    /* Return success */
-    return STATUS_EFI_SUCCESS;
-}
-
-/**
- * Scrolls the entire screen content up by one line and clears the last line.
- *
- * @return This routine does not return any value.
- *
- * @since XT 1.0
- */
-XTCDECL
-VOID
-BiosUtils::ScrollScreen()
-{
-    VOLATILE PUSHORT VgaBuffer = (PUSHORT)0xB8000;
-    USHORT Blank;
-    UINT Index;
-
-    /* Set blank character */
-    Blank = (0x0F << 8) | L' ';
-
-    /* Move every line up by one */
-    for(Index = 0; Index < (VgaHeight - 1) * VgaWidth; Index++)
-    {
-        VgaBuffer[Index] = VgaBuffer[Index + VgaWidth];
-    }
-
-    /* Clear the last line */
-    for(Index = (VgaHeight - 1) * VgaWidth; Index < VgaHeight * VgaWidth; Index++)
-    {
-        VgaBuffer[Index] = Blank;
-    }
-}
-
-/**
- * Updates the hardware cursor position on the screen.
- *
- * @return This routine does not return any value.
- *
- * @since XT 1.0
- */
-XTCDECL
-VOID
-BiosUtils::UpdateCursor()
-{
-    USHORT Position;
-
-    /* Calculate cursor position */
-    Position = CursorY * VgaWidth + CursorX;
-
-    /* Send command to set the high byte of the cursor position */
-    HL::IoPort::WritePort8(0x3D4, 0x0E);
-    HL::IoPort::WritePort8(0x3D5, (UCHAR)((Position >> 8) & 0xFF));
-
-    /* Send command to set the low byte of the cursor position */
-    HL::IoPort::WritePort8(0x3D4, 0x0F);
-    HL::IoPort::WritePort8(0x3D5, (UCHAR)(Position & 0xFF));
-}
--- a/boot/bootdata/CMakeLists.txt
+++ b/boot/bootdata/CMakeLists.txt
--- a/boot/bootdata/xtldr/CMakeLists.txt
+++ b/boot/bootdata/xtldr/CMakeLists.txt
--- a/boot/bootdata/xtldr/xtldr.ini
+++ b/boot/bootdata/xtldr/xtldr.ini
--- a/configure.ps1
+++ b/configure.ps1
@@ -4,41 +4,48 @@
 # DESCRIPTION: Project configuration script for preparing the build environment
 # DEVELOPERS:  Aiken Harris <harraiken91@gmail.com>

+
 # Check XTchain
 if (-not $env:XTCVER) {
-    Write-Error "XTChain not detected or corrupted!"
+    Write-Host "XTChain not detected or corrupted!"
    exit 1
 }

-# Set target architecture defaulting to amd64
-$ARCH = if ($env:TARGET) { $env:TARGET } else { "amd64" }
-
-# Set target build type defaulting to Debug
-$env:BUILD_TYPE = if ($env:BUILD_TYPE -in @("Debug", "Release")) { $env:BUILD_TYPE } else { "Debug" }
-
-# Set variables
-$EXECTOS_SOURCE_DIR = $PSScriptRoot
-$EXECTOS_BINARY_DIR = Join-Path $EXECTOS_SOURCE_DIR "build-$ARCH-$($env:BUILD_TYPE.ToLower())"
-
-# Create build directory
-if (-not (Test-Path $EXECTOS_BINARY_DIR)) {
-    Write-Host "Creating build directory: $EXECTOS_BINARY_DIR"
-    New-Item -ItemType Directory -Path $EXECTOS_BINARY_DIR -Force | Out-Null
+# Set target architecture
+if ($env:TARGET) {
+    $ARCH = $env:TARGET
+} else {
+    $ARCH = "amd64"
 }

-Set-Location $EXECTOS_BINARY_DIR
+# Set target build type
+if (-not $env:BUILD_TYPE) {
+    $env:BUILD_TYPE = "DEBUG"
+}
+
+# Set variables
+$EXECTOS_SOURCE_DIR = (Get-Location).Path
+$EXECTOS_BINARY_DIR = "build-$($ARCH)-$($env:BUILD_TYPE.ToLower())"
+
+# Create directories if needed
+if ($EXECTOS_SOURCE_DIR -eq (Get-Location).Path) {
+    Write-Host "Creating directories in $EXECTOS_BINARY_DIR"
+    New-Item -ItemType Directory -Path $EXECTOS_BINARY_DIR -Force | Out-Null
+    Set-Location -Path $EXECTOS_BINARY_DIR
+}

 # Delete old cache
-Remove-Item "CMakeCache.txt", "host-tools/CMakeCache.txt" -ErrorAction SilentlyContinue
+Remove-Item -Path "CMakeCache.txt" -ErrorAction SilentlyContinue
+Remove-Item -Path "host-tools/CMakeCache.txt" -ErrorAction SilentlyContinue

 # Configure project using CMake
-& cmake -G Ninja "-DARCH:STRING=$ARCH" "-DBUILD_TYPE:STRING=$($env:BUILD_TYPE)" $EXECTOS_SOURCE_DIR
+& cmake -G Ninja -DARCH:STRING=$($ARCH) -DBUILD_TYPE:STRING=$($env:BUILD_TYPE) $EXECTOS_SOURCE_DIR

 # Check if configuration succeeded
 if ($LASTEXITCODE -ne 0) {
-    Write-Error "Configure script failed."
+    Write-Host "Configure script failed."
    exit 1
+} else {
+    "$($ARCH)" | Out-File -Encoding ASCII -NoNewline build.arch
+    Write-Host "Configure script completed. Enter '$EXECTOS_BINARY_DIR' directory and execute 'xbuild' to build ExectOS."
 }
-
-$ARCH | Out-File -Encoding ASCII -NoNewline "build.arch"
-Write-Host "Configure completed. Run 'xbuild' to build ExectOS."
--- a/sdk/cmake/baseaddress/amd64.cmake
+++ b/sdk/cmake/baseaddress/amd64.cmake
@@ -1,3 +1,2 @@
 # Set base addresses for all modules
-set(BASEADDRESS_XTLDR    0x000000000000F800)
 set(BASEADDRESS_XTOSKRNL 0x0000000140000000)
--- a/sdk/cmake/baseaddress/i686.cmake
+++ b/sdk/cmake/baseaddress/i686.cmake
@@ -1,3 +1,2 @@
 # Set base addresses for all modules
-set(BASEADDRESS_XTLDR    0x0000F800)
 set(BASEADDRESS_XTOSKRNL 0x00400000)
--- a/sdk/cmake/emulation.cmake
+++ b/sdk/cmake/emulation.cmake
@@ -23,57 +23,49 @@ endif()

 find_program(QEMU_EMULATOR ${QEMU_COMMAND})
 if(QEMU_EMULATOR)
-    if(CMAKE_HOST_LINUX)
-        # This target starts up a QEMU+OVMF virtual machine using KVM accelerator
-        add_custom_target(testefikvm
-                          DEPENDS install
-                          COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-EFI-KVM" -machine type=q35,kernel_irqchip=on,accel=kvm,mem-merge=off,vmport=off -enable-kvm -cpu host,-hypervisor,+topoext
-                                                  -smp 2,sockets=1,cores=1,threads=2 -m 4G -overcommit mem-lock=off -rtc clock=host,base=localtime,driftfix=none
-                                                  -bios ${EXECTOS_SOURCE_DIR}/sdk/firmware/ovmf_${ARCH}.fd
-                                                  -hda fat:rw:${EXECTOS_BINARY_DIR}/output/binaries
-                                                  -boot menu=on -d int -M smm=off -no-reboot -no-shutdown -serial stdio
-                          VERBATIM USES_TERMINAL)
-    elseif(CMAKE_HOST_WIN32)
-        # This target starts up a QEMU+OVMF virtual machine using WHPX accelerator
-        add_custom_target(testefiwhpx
-                          DEPENDS install
-                          COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-EFI-WHPX" -machine type=q35,kernel_irqchip=off,accel=whpx,mem-merge=off,vmport=off
-                                                  -m 4G -overcommit mem-lock=off -rtc clock=host,base=localtime,driftfix=none
-                                                  -bios ${EXECTOS_SOURCE_DIR}/sdk/firmware/ovmf_${ARCH}.fd
-                                                  -hda fat:rw:${EXECTOS_BINARY_DIR}/output/binaries
-                                                  -boot menu=on -d int -M smm=off -no-reboot -no-shutdown -serial stdio
-                          VERBATIM USES_TERMINAL)
-    endif()
+    # This target starts up a QEMU+OVMF virtual machine using KVM accelerator
+    add_custom_target(testefikvm
+                      DEPENDS install
+                      COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-EFI-KVM" -machine type=q35,kernel_irqchip=on,accel="kvm:whpx",mem-merge=off,vmport=off -enable-kvm -cpu host,-hypervisor,+topoext
+                                              -smp 2,sockets=1,cores=1,threads=2 -m 4G -overcommit mem-lock=off -rtc clock=host,base=localtime,driftfix=none
+                                              -drive file=${EXECTOS_SOURCE_DIR}/sdk/firmware/ovmf_code_${ARCH}.fd,if=pflash,format=raw,unit=0,readonly=on
+                                              -drive file=${EXECTOS_SOURCE_DIR}/sdk/firmware/ovmf_vars_${ARCH}.fd,if=pflash,format=raw,unit=1
+                                              -hda fat:rw:${EXECTOS_BINARY_DIR}/output/binaries
+                                              -boot menu=on -d int -M smm=off -no-reboot -no-shutdown -serial stdio
+                      VERBATIM USES_TERMINAL)

    # This target starts up a QEMU+OVMF virtual machine using TCG accelerator
    add_custom_target(testefitcg
                      DEPENDS install
                      COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-EFI-TCG" -machine type=q35,accel=tcg -cpu max,-hypervisor
                                              -smp 2,sockets=1,cores=1,threads=2 -m 4G -overcommit mem-lock=off -rtc clock=host,base=localtime,driftfix=none
-                                              -bios ${EXECTOS_SOURCE_DIR}/sdk/firmware/ovmf_${ARCH}.fd
+                                              -drive file=${EXECTOS_SOURCE_DIR}/sdk/firmware/ovmf_code_${ARCH}.fd,if=pflash,format=raw,unit=0,readonly=on
+                                              -drive file=${EXECTOS_SOURCE_DIR}/sdk/firmware/ovmf_vars_${ARCH}.fd,if=pflash,format=raw,unit=1
                                              -hda fat:rw:${EXECTOS_BINARY_DIR}/output/binaries
                                              -boot menu=on -d int -no-reboot -no-shutdown -serial stdio
                      VERBATIM USES_TERMINAL)

-    if(CMAKE_HOST_LINUX)
+if(WIN32)
+        # This target starts up a QEMU+OVMF virtual machine using WHPX accelerator on Windows
+        add_custom_target(testkvm
+                        DEPENDS install
+                        COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-WHPX" -machine accel=whpx,kernel-irqchip=off 
+                            -bios ${EXECTOS_SOURCE_DIR}/sdk/firmware/OVMF-pure-efi.fd
+                            -hda fat:rw:${EXECTOS_BINARY_DIR}/output/binaries 
+                            -no-reboot -no-shutdown -serial stdio
+                        COMMENT "Using WHPX acceleration on Windows"
+                        VERBATIM USES_TERMINAL)
+
+else()
        # This target starts up a QEMU+SEABIOS virtual machine using KVM accelerator
        add_custom_target(testkvm
-                          DEPENDS diskimg
-                          COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-BIOS-KVM" -machine type=q35,kernel_irqchip=on,accel=kvm,mem-merge=off,vmport=off -enable-kvm -cpu host,-hypervisor,+topoext
-                                                  -smp 2,sockets=1,cores=1,threads=2 -m 4G -overcommit mem-lock=off -rtc clock=host,base=localtime,driftfix=none
-                                                  -hda ${EXECTOS_BINARY_DIR}/output/disk.img
-                                                  -boot menu=on -d int -no-reboot -no-shutdown -serial stdio
-                          VERBATIM USES_TERMINAL)
-    elseif(CMAKE_HOST_WIN32)
-        # This target starts up a QEMU+SEABIOS virtual machine using WHPX accelerator
-        add_custom_target(testwhpx
-                          DEPENDS diskimg
-                          COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-BIOS-WHPX" -machine type=q35,kernel_irqchip=off,accel=whpx,mem-merge=off,vmport=off
-                                                  -m 4G -overcommit mem-lock=off -rtc clock=host,base=localtime,driftfix=none
-                                                  -hda ${EXECTOS_BINARY_DIR}/output/disk.img
-                                                  -boot menu=on -d int -no-reboot -no-shutdown -serial stdio
-                          VERBATIM USES_TERMINAL)
-    endif()
+                        DEPENDS diskimg
+                        COMMAND ${QEMU_COMMAND} -name "ExectOS-${ARCH}-BIOS-KVM" -machine type=q35,kernel_irqchip=on,accel="kvm:whpx",mem-merge=off,vmport=off -enable-kvm -cpu host,-hypervisor,+topoext
+                                                -smp 2,sockets=1,cores=1,threads=2 -m 4G -overcommit mem-lock=off -rtc clock=host,base=localtime,driftfix=none
+                                                -hda ${EXECTOS_BINARY_DIR}/output/disk.img
+                                                -boot menu=on -d int -no-reboot -no-shutdown -serial stdio
+                        VERBATIM USES_TERMINAL)
+endif()

    # This target starts up a QEMU+SEABIOS virtual machine using TCG accelerator
    add_custom_target(testtcg
--- a/sdk/cmake/functions.cmake
+++ b/sdk/cmake/functions.cmake
@@ -64,18 +64,11 @@ function(compile_bootsector NAME SOURCE BASEADDR ENTRYPOINT)
    set(BINARY_NAME "${NAME}.bin")
    set(OBJECT_NAME "${NAME}.obj")

-    get_directory_property(DEFS COMPILE_DEFINITIONS)
-    foreach(def ${DEFS})
-        list(APPEND ASM_DEFS "-D${def}")
-    endforeach()
-
    add_custom_command(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${BINARY_NAME}
        COMMAND ${CMAKE_ASM_COMPILER}
            /nologo
            --target=i386-none-elf
-            ${ASM_DEFS}
-            -I${CMAKE_CURRENT_SOURCE_DIR}
            /Fo${CMAKE_CURRENT_BINARY_DIR}/${OBJECT_NAME}
            -c -- ${SOURCE}
        COMMAND ${CMAKE_ASM_LINKER}
--- a/sdk/firmware/OVMF-pure-efi.fd
+++ b/sdk/firmware/OVMF-pure-efi.fd
--- a/sdk/firmware/ovmf_code_amd64.fd
+++ b/sdk/firmware/ovmf_code_amd64.fd
--- a/sdk/firmware/ovmf_code_i686.fd
+++ b/sdk/firmware/ovmf_code_i686.fd
--- a/sdk/firmware/ovmf_vars_amd64.fd
+++ b/sdk/firmware/ovmf_vars_amd64.fd
--- a/sdk/firmware/ovmf_vars_i686.fd
+++ b/sdk/firmware/ovmf_vars_i686.fd
--- a/sdk/xtdk/amd64/ketypes.h
+++ b/sdk/xtdk/amd64/ketypes.h
@@ -108,6 +108,9 @@
 /* Static Kernel-Mode address start */
 #define KSEG0_BASE                        0xFFFFF80000000000

+/* XTOS Kernel address base */
+#define KSEG0_KERNEL_BASE                 0x0000000800000000
+
 /* XTOS Kernel stack size */
 #define KERNEL_STACK_SIZE                 0x8000

@@ -269,18 +272,11 @@ typedef struct _KIDTENTRY
 {
    USHORT OffsetLow;
    USHORT Selector;
-    union
-    {
-        struct
-        {
-            USHORT IstIndex:3;
-            USHORT Reserved0:5;
-            USHORT Type:5;
-            USHORT Dpl:2;
-            USHORT Present:1;
-        };
-        USHORT Access;
-    };
+    USHORT IstIndex:3;
+    USHORT Reserved0:5;
+    USHORT Type:5;
+    USHORT Dpl:2;
+    USHORT Present:1;
    USHORT OffsetMiddle;
    ULONG OffsetHigh;
    ULONG Reserved1;
--- a/sdk/xtdk/amd64/mmtypes.h
+++ b/sdk/xtdk/amd64/mmtypes.h
@@ -25,11 +25,11 @@
 #define MM_PXE_BASE                                0xFFFFF6FB7DBED000ULL

 /* Page directory and page base addresses for 5-level paging */
-#define MM_PTE_LA57_BASE                           0xFFED000000000000ULL
-#define MM_PDE_LA57_BASE                           0xFFEDF68000000000ULL
-#define MM_PPE_LA57_BASE                           0xFFEDF6FB40000000ULL
-#define MM_PXE_LA57_BASE                           0xFFEDF6FB7DA00000ULL
-#define MM_P5E_LA57_BASE                           0xFFEDF6FB7DBED000ULL
+#define MM_PTE_LA57_BASE                           0xFFFF000000000000ULL
+#define MM_PDE_LA57_BASE                           0xFFFF010000000000ULL
+#define MM_PPE_LA57_BASE                           0xFFFF010800000000ULL
+#define MM_PXE_LA57_BASE                           0xFFFF010840000000ULL
+#define MM_P5E_LA57_BASE                           0xFFFF010840200000ULL

 /* PTE shift values */
 #define MM_PTE_SHIFT                               3
@@ -39,55 +39,15 @@
 #define MM_PXI_SHIFT                               39
 #define MM_P5I_SHIFT                               48

-/* PTE state flags */
-#define MM_PTE_VALID                               0x0000000000000001ULL
-#define MM_PTE_ACCESSED                            0x0000000000000020ULL
-#define MM_PTE_DIRTY                               0x0000000000000040ULL
-
-/* PTE scope flags */
-#define MM_PTE_LARGE_PAGE                          0x0000000000000080ULL
-#define MM_PTE_GLOBAL                              0x0000000000000100ULL
-
-/* PTE access flags */
-#define MM_PTE_NOACCESS                            0x0000000000000000ULL
-#define MM_PTE_READONLY                            0x0000000000000000ULL
-#define MM_PTE_EXECUTE                             0x0000000000000000ULL
-#define MM_PTE_EXECUTE_READ                        0x0000000000000000ULL
-#define MM_PTE_READWRITE                           0x8000000000000002ULL
-#define MM_PTE_WRITECOPY                           0x8000000000000200ULL
-#define MM_PTE_EXECUTE_READWRITE                   0x0000000000000002ULL
-#define MM_PTE_EXECUTE_WRITECOPY                   0x0000000000000200ULL
-
-/* PTE protection flags */
-#define MM_PTE_NOEXECUTE                           0x8000000000000000ULL
-#define MM_PTE_PROTECT                             0x8000000000000612ULL
-
-/* PTE cache flags */
-#define MM_PTE_CACHE_ENABLE                        0x0000000000000000ULL
-#define MM_PTE_CACHE_DISABLE                       0x0000000000000010ULL
-#define MM_PTE_CACHE_WRITECOMBINED                 0x0000000000000010ULL
-#define MM_PTE_CACHE_WRITETHROUGH                  0x0000000000000008ULL
-
-/* PTE software flags */
-#define MM_PTE_COPY_ON_WRITE                       0x0000000000000200ULL
-#define MM_PTE_PROTOTYPE                           0x0000000000000400ULL
-#define MM_PTE_TRANSITION                          0x0000000000000800ULL
-
-/* PTE frame bits */
-#define MM_PTE_FRAME_BITS                          57
-
-/* PTE protection bits */
-#define MM_PTE_PROTECTION_BITS                     5
-
-/* Base address of the system page table */
-#define MM_SYSTEM_PTE_BASE                         KSEG0_BASE
+/* Number of PTEs per page */
+#define MM_PTE_PER_PAGE                            512
+#define MM_PDE_PER_PAGE                            512
+#define MM_PPE_PER_PAGE                            512
+#define MM_PXE_PER_PAGE                            512

 /* Minimum number of physical pages needed by the system */
 #define MM_MINIMUM_PHYSICAL_PAGES                  2048

-/* Number of system PTEs */
-#define MM_DEFAULT_NUMBER_SYSTEM_PTES              22000
-
 /* Default number of secondary colors */
 #define MM_DEFAULT_SECONDARY_COLORS                64

@@ -103,9 +63,6 @@
 /* Maximum physical address used by HAL allocations */
 #define MM_MAXIMUM_PHYSICAL_ADDRESS                0x00000000FFFFFFFFULL

-/* Highest system address */
-#define MM_HIGHEST_SYSTEM_ADDRESS                  0xFFFFFFFFFFFFFFFFULL
-
 /* Trampoline code address */
 #define MM_TRAMPOLINE_ADDRESS                      0x80000

@@ -295,7 +252,6 @@ typedef struct _MMPFN
            USHORT ReferenceCount;
        } e2;
    } u3;
-    ULONG UsedPageTableEntries;
    union
    {
        MMPTE OriginalPte;
@@ -306,11 +262,12 @@ typedef struct _MMPFN
        ULONG_PTR EntireFrame;
        struct
        {
-            ULONG_PTR PteFrame:57;
+            ULONG_PTR PteFrame:58;
            ULONG_PTR InPageError:1;
            ULONG_PTR VerifierAllocation:1;
            ULONG_PTR AweAllocation:1;
-            ULONG_PTR Priority:3;
+            ULONG_PTR LockCharged:1;
+            ULONG_PTR KernelStack:1;
            ULONG_PTR MustBeCached:1;
        };
    } u4;
--- a/sdk/xtdk/bltypes.h
+++ b/sdk/xtdk/bltypes.h
@@ -100,19 +100,21 @@ typedef VOID (XTCDECL *PBL_LLIST_INITIALIZE_HEAD)(IN PLIST_ENTRY ListHead);
 typedef VOID (XTCDECL *PBL_LLIST_INSERT_HEAD)(IN OUT PLIST_ENTRY ListHead, IN PLIST_ENTRY Entry);
 typedef VOID (XTCDECL *PBL_LLIST_INSERT_TAIL)(IN OUT PLIST_ENTRY ListHead, IN PLIST_ENTRY Entry);
 typedef VOID (XTCDECL *PBL_LLIST_REMOVE_ENTRY)(IN PLIST_ENTRY Entry);
-typedef EFI_STATUS (XTCDECL *PBL_MAP_EFI_MEMORY)(IN OUT PXTBL_PAGE_MAPPING PageMap, IN ULONG_PTR BaseAddress);
-typedef EFI_STATUS (XTCDECL *PBL_MAP_PAGE)(IN PXTBL_PAGE_MAPPING PageMap, IN ULONGLONG VirtualAddress, IN ULONGLONG PhysicalAddress, IN ULONGLONG NumberOfPages);
-typedef EFI_STATUS (XTCDECL *PBL_MAP_VIRTUAL_MEMORY)(IN OUT PXTBL_PAGE_MAPPING PageMap, IN ULONGLONG VirtualAddress, IN ULONGLONG PhysicalAddress, IN ULONGLONG NumberOfPages, IN LOADER_MEMORY_TYPE MemoryType);
+typedef EFI_STATUS (XTCDECL *PBL_MAP_EFI_MEMORY)(IN OUT PXTBL_PAGE_MAPPING PageMap, IN OUT PVOID *MemoryMapAddress, IN PBL_GET_MEMTYPE_ROUTINE GetMemoryTypeRoutine);
+typedef EFI_STATUS (XTCDECL *PBL_MAP_PAGE)(IN PXTBL_PAGE_MAPPING PageMap, IN ULONG_PTR VirtualAddress, IN ULONG_PTR PhysicalAddress, IN ULONG NumberOfPages);
+typedef EFI_STATUS (XTCDECL *PBL_MAP_VIRTUAL_MEMORY)(IN OUT PXTBL_PAGE_MAPPING PageMap, IN PVOID VirtualAddress, IN PVOID PhysicalAddress, IN ULONGLONG NumberOfPages, IN LOADER_MEMORY_TYPE MemoryType);
 typedef VOID (XTAPI *PBL_MOVE_MEMORY)(IN OUT PVOID Destination, IN PCVOID Source, IN SIZE_T Length);
 typedef EFI_STATUS (XTCDECL *PBL_OPEN_VOLUME)(IN PEFI_DEVICE_PATH_PROTOCOL DevicePath, OUT PEFI_HANDLE DiskHandle, OUT PEFI_FILE_HANDLE *FsHandle);
 typedef EFI_STATUS (XTCDECL *PBL_OPEN_PROTOCOL)(OUT PEFI_HANDLE Handle, OUT PVOID *ProtocolHandler, IN PEFI_GUID ProtocolGuid);
 typedef EFI_STATUS (XTCDECL *PBL_OPEN_PROTOCOL_HANDLE)(IN EFI_HANDLE Handle, OUT PVOID *ProtocolHandler, IN PEFI_GUID ProtocolGuid);
+typedef PVOID (XTCDECL *PBL_PHYSICAL_ADDRESS_TO_VIRTUAL)(IN PVOID PhysicalAddress, IN PVOID PhysicalBase, IN PVOID VirtualBase);
 typedef UCHAR (XTCDECL *PBL_IOPORT_READ_8)(IN USHORT Port);
 typedef USHORT (XTCDECL *PBL_IOPORT_READ_16)(IN USHORT Port);
 typedef ULONG (XTCDECL *PBL_IOPORT_READ_32)(IN USHORT Port);
 typedef VOID (XTCDECL *PBL_IOPORT_WRITE_8)(IN USHORT Port, IN UCHAR Value);
 typedef VOID (XTCDECL *PBL_IOPORT_WRITE_16)(IN USHORT Port, IN USHORT Value);
 typedef VOID (XTCDECL *PBL_IOPORT_WRITE_32)(IN USHORT Port, IN ULONG Value);
+typedef EFI_STATUS (XTCDECL *PBL_PHYSICAL_LIST_TO_VIRTUAL)(IN PXTBL_PAGE_MAPPING PageMap, IN OUT PLIST_ENTRY ListHead, IN PVOID PhysicalBase, IN PVOID VirtualBase);
 typedef EFI_STATUS (XTCDECL *PBL_POWER_SYSTEM)();
 typedef EFI_STATUS (XTCDECL *PBL_READ_FILE)(IN PEFI_FILE_HANDLE DirHandle, IN PCWSTR FileName, OUT PVOID *FileData, OUT PSIZE_T FileSize);
 typedef EFI_STATUS (XTCDECL *PBL_REGISTER_BOOT_PROTOCOL)(IN PCWSTR SystemType, IN PEFI_GUID BootProtocolGuid);
@@ -230,8 +232,8 @@ typedef struct _XTBL_KNOWN_BOOT_PROTOCOL
 typedef struct _XTBL_MEMORY_MAPPING
 {
    LIST_ENTRY ListEntry;
-    ULONGLONG VirtualAddress;
-    ULONGLONG PhysicalAddress;
+    PVOID VirtualAddress;
+    PVOID PhysicalAddress;
    ULONGLONG NumberOfPages;
    LOADER_MEMORY_TYPE MemoryType;
 } XTBL_MEMORY_MAPPING, *PXTBL_MEMORY_MAPPING;
@@ -459,6 +461,8 @@ typedef struct _XTBL_LOADER_PROTOCOL
        PBL_MAP_PAGE MapPage;
        PBL_MAP_VIRTUAL_MEMORY MapVirtualMemory;
        PBL_MOVE_MEMORY MoveMemory;
+        PBL_PHYSICAL_ADDRESS_TO_VIRTUAL PhysicalAddressToVirtual;
+        PBL_PHYSICAL_LIST_TO_VIRTUAL PhysicalListToVirtual;
        PBL_SET_MEMORY SetMemory;
        PBL_ZERO_MEMORY ZeroMemory;
    } Memory;
--- a/sdk/xtdk/i686/ketypes.h
+++ b/sdk/xtdk/i686/ketypes.h
@@ -58,6 +58,12 @@
 #define KIDT_ACCESS_RING0                 0x00
 #define KIDT_ACCESS_RING3                 0x60

+/* IDT gate types */
+#define KIDT_TASK                         0x05
+#define KIDT_CALL                         0x0C
+#define KIDT_INTERRUPT                    0x0E
+#define KIDT_TRAP                         0x0F
+
 /* TSS Offsets */
 #define KTSS_ESP0                         0x04
 #define KTSS_CR3                          0x1C
@@ -128,6 +134,9 @@
 /* Static Kernel-Mode address start */
 #define KSEG0_BASE                        0x80000000

+/* XTOS Kernel address base */
+#define KSEG0_KERNEL_BASE                 0x01800000
+
 /* XTOS Kernel stack size */
 #define KERNEL_STACK_SIZE                 0x4000

@@ -275,18 +284,7 @@ typedef struct _KIDTENTRY
 {
    USHORT Offset;
    USHORT Selector;
-    union
-    {
-        struct
-        {
-            UCHAR Reserved;
-            UCHAR Type:4;
-            UCHAR Flag:1;
-            UCHAR Dpl:2;
-            UCHAR Present:1;
-        };
-        USHORT Access;
-    };
+    USHORT Access;
    USHORT ExtendedOffset;
 } KIDTENTRY, *PKIDTENTRY;

--- a/sdk/xtdk/i686/mmtypes.h
+++ b/sdk/xtdk/i686/mmtypes.h
@@ -35,57 +35,9 @@
 #define MM_PTE_LEGACY_SHIFT                        2
 #define MM_PDI_LEGACY_SHIFT                        22

-/* PTE state flags */
-#define MM_PTE_VALID                               0x00000001
-#define MM_PTE_ACCESSED                            0x00000020
-#define MM_PTE_DIRTY                               0x00000040
-
-/* PTE scope flags */
-#define MM_PTE_LARGE_PAGE                          0x00000080
-#define MM_PTE_GLOBAL                              0x00000100
-
-/* PTE access flags */
-#define MM_PTE_NOACCESS                            0x00000000
-#define MM_PTE_READONLY                            0x00000000
-#define MM_PTE_EXECUTE                             0x00000000
-#define MM_PTE_EXECUTE_READ                        0x00000000
-#define MM_PTE_READWRITE                           0x00000002
-#define MM_PTE_WRITECOPY                           0x00000200
-#define MM_PTE_EXECUTE_READWRITE                   0x00000002
-#define MM_PTE_EXECUTE_WRITECOPY                   0x00000200
-
-/* PTE protection flags */
-#define MM_PTE_NOEXECUTE                           0x00000000
-#define MM_PTE_PROTECT                             0x00000612
-
-/* PTE cache flags */
-#define MM_PTE_CACHE_ENABLE                        0x00000000
-#define MM_PTE_CACHE_DISABLE                       0x00000010
-#define MM_PTE_CACHE_WRITECOMBINED                 0x00000010
-#define MM_PTE_CACHE_WRITETHROUGH                  0x00000008
-
-/* PTE software flags */
-#define MM_PTE_COPY_ON_WRITE                       0x00000200
-#define MM_PTE_PROTOTYPE                           0x00000400
-#define MM_PTE_TRANSITION                          0x00000800
-
-/* PTE frame bits */
-#define MM_PTE_FRAME_BITS                          25
-
-/* PTE protection bits */
-#define MM_PTE_PROTECTION_BITS                     5
-
-/* Base address of the system page table */
-#define MM_SYSTEM_PTE_BASE                         NULLPTR
-
 /* Minimum number of physical pages needed by the system */
 #define MM_MINIMUM_PHYSICAL_PAGES                  1100

-/* Number of system PTEs */
-#define MM_MINIMUM_NUMBER_SYSTEM_PTES              7000
-#define MM_DEFAULT_NUMBER_SYSTEM_PTES              11000
-#define MM_MAXIMUM_NUMBER_SYSTEM_PTES              22000
-
 /* Default number of secondary colors */
 #define MM_DEFAULT_SECONDARY_COLORS                64

@@ -101,9 +53,6 @@
 /* Maximum physical address used by HAL allocations */
 #define MM_MAXIMUM_PHYSICAL_ADDRESS                0xFFFFFFFF

-/* Highest system address */
-#define MM_HIGHEST_SYSTEM_ADDRESS                  0xFFFFFFFF
-
 /* Trampoline code address */
 #define MM_TRAMPOLINE_ADDRESS                      0x80000

@@ -157,6 +106,7 @@ typedef struct _HARDWARE_MODERN_PTE
 /* Generic Page Table entry union to abstract PML2 and PML3 formats */
 typedef union _HARDWARE_PTE
 {
+    ULONGLONG Long;
    HARDWARE_LEGACY_PTE Pml2;
    HARDWARE_MODERN_PTE Pml3;
 } HARDWARE_PTE, *PHARDWARE_PTE;
@@ -251,12 +201,12 @@ typedef struct _MMPML2_PTE_TRANSITION
 typedef union _MMPML2_PTE
 {
    ULONG Long;
-    HARDWARE_LEGACY_PTE Flush;
-    MMPML2_PTE_HARDWARE Hardware;
-    MMPML2_PTE_PROTOTYPE Prototype;
-    MMPML2_PTE_SOFTWARE Software;
-    MMPML2_PTE_TRANSITION Transition;
-    MMPML2_PTE_SUBSECTION Subsection;
+    HARDWARE_PTE Flush;
+    MMPML2_PTE_HARDWARE Hard;
+    MMPML2_PTE_PROTOTYPE Proto;
+    MMPML2_PTE_SOFTWARE Soft;
+    MMPML2_PTE_TRANSITION Trans;
+    MMPML2_PTE_SUBSECTION Subsect;
    MMPML2_PTE_LIST List;
 } MMPML2_PTE, *PMMPML2_PTE;

@@ -346,7 +296,7 @@ typedef struct _MMPML3_PTE_TRANSITION
 typedef union _MMPML3_PTE
 {
    ULONGLONG Long;
-    HARDWARE_MODERN_PTE Flush;
+    HARDWARE_PTE Flush;
    MMPML3_PTE_HARDWARE Hardware;
    MMPML3_PTE_PROTOTYPE Prototype;
    MMPML3_PTE_SOFTWARE Software;
@@ -358,6 +308,7 @@ typedef union _MMPML3_PTE
 /* Generic Page Table Entry union to abstract PML2 and PML3 formats */
 typedef union _MMPTE
 {
+    ULONGLONG Long;
    MMPML2_PTE Pml2;
    MMPML3_PTE Pml3;
 } MMPTE, *PMMPTE;
@@ -388,7 +339,6 @@ typedef struct _MMPFN
            USHORT ReferenceCount;
        } e2;
    } u3;
-    ULONG UsedPageTableEntries;
    union
    {
        MMPTE OriginalPte;
@@ -399,11 +349,12 @@ typedef struct _MMPFN
        ULONG_PTR EntireFrame;
        struct
        {
-            ULONG_PTR PteFrame:25;
+            ULONG_PTR PteFrame:26;
            ULONG_PTR InPageError:1;
            ULONG_PTR VerifierAllocation:1;
            ULONG_PTR AweAllocation:1;
-            ULONG_PTR Priority:3;
+            ULONG_PTR LockCharged:1;
+            ULONG_PTR KernelStack:1;
            ULONG_PTR MustBeCached:1;
        };
    } u4;
--- a/sdk/xtdk/ketypes.h
+++ b/sdk/xtdk/ketypes.h
@@ -150,23 +150,21 @@ typedef enum _KTHREAD_STATE
 typedef enum _KSPIN_LOCK_QUEUE_LEVEL
 {
    DispatcherLock,
-    ExpansionLock,
+    UnusedSpareLock,
    PfnLock,
    SystemSpaceLock,
    VacbLock,
    MasterLock,
-    NonPagedAllocPoolLock,
+    NonPagedPoolLock,
    IoCancelLock,
    WorkQueueLock,
    IoVpbLock,
    IoDatabaseLock,
    IoCompletionLock,
-    FileSystemLock,
+    FsStructLock,
    AfdWorkQueueLock,
    BcbLock,
-    NonPagedPoolLock,
-    ReservedSystemLock,
-    TimerTableLock,
+    MmNonPagedPoolLock,
    MaximumLock
 } KSPIN_LOCK_QUEUE_LEVEL, *PKSPIN_LOCK_QUEUE_LEVEL;

--- a/sdk/xtdk/mmtypes.h
+++ b/sdk/xtdk/mmtypes.h
@@ -4,7 +4,6 @@
 * FILE:            sdk/xtdk/mmtypes.h
 * DESCRIPTION:     Memory management data structures
 * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
- *                  Aiken Harris <harraiken91@gmail.com>
 */

 #ifndef __XTDK_MMTYPES_H
@@ -14,48 +13,6 @@
 #include ARCH_HEADER(xtstruct.h)


-/* Number of hyper space pages */
-#define MM_HYPERSPACE_PAGE_COUNT                   255
-
-/* Number of paging colors */
-#define MM_PAGING_COLORS                           64
-
-/* PTE frame mask definition */
-#define MM_PFN_PTE_FRAME                           (((ULONG_PTR)1 << MM_PTE_FRAME_BITS) - 1)
-
-/* Number of reserved zeroed PTEs */
-#define MM_RESERVED_ZERO_PTES                      32
-
-/* Memory manager page lists */
-typedef enum _MMPAGELISTS
-{
-   ZeroedPageList = 0,
-   FreePageList = 1,
-   StandbyPageList = 2,
-   ModifiedPageList = 3,
-   ModifiedReadOnlyPageList = 4,
-   BadPageList = 5,
-   ActiveAndValid = 6,
-   TransitionPage = 7
-} MMPAGELISTS, *PMMPAGELISTS;
-
-/* Page cache attributes */
-typedef enum _MMPFN_CACHE_ATTRIBUTE
-{
-    PfnNonCached,
-    PfnCached,
-    PfnWriteCombined,
-    PfnNotMapped
-} MMPFN_CACHE_ATTRIBUTE, *PMMPFN_CACHE_ATTRIBUTE;
-
-/* Page table pool types */
-typedef enum _MMSYSTEM_PTE_POOL_TYPE
-{
-    SystemPteSpace,
-    NonPagedPoolExpansion,
-    MaximumPtePoolTypes
-} MMSYSTEM_PTE_POOL_TYPE, *PMMSYSTEM_PTE_POOL_TYPE;
-
 /* Page map routines structure definition */
 typedef CONST STRUCT _CMMPAGEMAP_ROUTINES
 {
@@ -73,22 +30,6 @@ typedef struct _MMCOLOR_TABLES
    ULONG_PTR Count;
 } MMCOLOR_TABLES, *PMMCOLOR_TABLES;

-/* Memory layout structure definition */
-typedef struct _MMMEMORY_LAYOUT
-{
-    PMMPFN PfnDatabaseAddress;
-    PVOID SelfMapAddress;
-    PVOID HyperSpaceStart;
-    PVOID HyperSpaceEnd;
-    PVOID NonPagedPoolStart;
-    PVOID NonPagedPoolEnd;
-    PVOID PagedPoolStart;
-    PVOID PagedPoolEnd;
-    PVOID SystemSpaceStart;
-    PVOID SystemSpaceEnd;
-    PVOID UserSpaceEnd;
-} MMMEMORY_LAYOUT, *PMMMEMORY_LAYOUT;
-
 /* Page Frame Entry structure definition */
 typedef struct _MMPFNENTRY
 {
@@ -104,13 +45,4 @@ typedef struct _MMPFNENTRY
    USHORT ParityError:1;
 } MMPFNENTRY, *PMMPFNENTRY;

-/* Page Frame List structure definition */
-typedef struct _MMPFNLIST
-{
-    PFN_NUMBER Total;
-    MMPAGELISTS ListName;
-    PFN_NUMBER Flink;
-    PFN_NUMBER Blink;
-} MMPFNLIST, *PMMPFNLIST;
-
 #endif /* __XTDK_MMTYPES_H */
--- a/sdk/xtdk/xtbase.h
+++ b/sdk/xtdk/xtbase.h
@@ -29,9 +29,6 @@ typedef UCHAR KRUNLEVEL, *PKRUNLEVEL;
 /* Spin locks synchronization mechanism */
 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;

-/* Page Frame Number count */
-typedef ULONG PFN_COUNT;
-
 /* Page Frame Number */
 typedef ULONG_PTR PFN_NUMBER, *PPFN_NUMBER;

--- a/sdk/xtdk/xtcompat.h
+++ b/sdk/xtdk/xtcompat.h
@@ -12,9 +12,8 @@

 #ifdef __cplusplus
    /* C++ definitions */
-    #define NULLPTR         nullptr
-    #define VIRTUAL         virtual
    #define XTCLINK         extern "C"
+    #define NULLPTR         nullptr

    /* C++ boolean type */
    typedef bool BOOLEAN, *PBOOLEAN;
@@ -25,9 +24,8 @@
    typedef wchar_t wchar;
 #else
    /* C definitions */
-    #define NULLPTR         ((void *)0)
-    #define VIRTUAL
    #define XTCLINK
+    #define NULLPTR         ((void *)0)

    /* C boolean type */
    typedef enum _BOOLEAN
--- a/sdk/xtdk/xtstruct.h
+++ b/sdk/xtdk/xtstruct.h
@@ -48,9 +48,6 @@ typedef enum _KTHREAD_STATE KTHREAD_STATE, *PKTHREAD_STATE;
 typedef enum _KTIMER_TYPE KTIMER_TYPE, *PKTIMER_TYPE;
 typedef enum _KUBSAN_DATA_TYPE KUBSAN_DATA_TYPE, *PKUBSAN_DATA_TYPE;
 typedef enum _LOADER_MEMORY_TYPE LOADER_MEMORY_TYPE, *PLOADER_MEMORY_TYPE;
-typedef enum _MMPAGELISTS MMPAGELISTS, *PMMPAGELISTS;
-typedef enum _MMPFN_CACHE_ATTRIBUTE MMPFN_CACHE_ATTRIBUTE, *PMMPFN_CACHE_ATTRIBUTE;
-typedef enum _MMSYSTEM_PTE_POOL_TYPE MMSYSTEM_PTE_POOL_TYPE, *PMMSYSTEM_PTE_POOL_TYPE;
 typedef enum _MODE MODE, *PMODE;
 typedef enum _RTL_VARIABLE_TYPE RTL_VARIABLE_TYPE, *PRTL_VARIABLE_TYPE;
 typedef enum _SYSTEM_FIRMWARE_TYPE SYSTEM_FIRMWARE_TYPE, *PSYSTEM_FIRMWARE_TYPE;
@@ -277,9 +274,7 @@ typedef struct _LOADER_INFORMATION_BLOCK LOADER_INFORMATION_BLOCK, *PLOADER_INFO
 typedef struct _LOADER_MEMORY_DESCRIPTOR LOADER_MEMORY_DESCRIPTOR, *PLOADER_MEMORY_DESCRIPTOR;
 typedef struct _M128 M128, *PM128;
 typedef struct _MMCOLOR_TABLES MMCOLOR_TABLES, *PMMCOLOR_TABLES;
-typedef struct _MMMEMORY_LAYOUT MMMEMORY_LAYOUT, *PMMMEMORY_LAYOUT;
 typedef struct _MMPFNENTRY MMPFNENTRY, *PMMPFNENTRY;
-typedef struct _MMPFNLIST MMPFNLIST, *PMMPFNLIST;
 typedef struct _PCAT_FIRMWARE_INFORMATION PCAT_FIRMWARE_INFORMATION, *PPCAT_FIRMWARE_INFORMATION;
 typedef struct _PCI_BRIDGE_CONTROL_REGISTER PCI_BRIDGE_CONTROL_REGISTER, *PPCI_BRIDGE_CONTROL_REGISTER;
 typedef struct _PCI_COMMON_CONFIG PCI_COMMON_CONFIG, *PPCI_COMMON_CONFIG;
--- a/boot/xtldr/CMakeLists.txt
+++ b/boot/xtldr/CMakeLists.txt
@@ -16,7 +16,6 @@ list(APPEND LIBXTLDR_SOURCE
 # Specify list of source code files
 list(APPEND XTLDR_SOURCE
    ${XTLDR_SOURCE_DIR}/arch/${ARCH}/memory.cc
-    ${XTLDR_SOURCE_DIR}/biosutil.cc
    ${XTLDR_SOURCE_DIR}/bootutil.cc
    ${XTLDR_SOURCE_DIR}/config.cc
    ${XTLDR_SOURCE_DIR}/console.cc
@@ -39,9 +38,6 @@ add_executable(xtldr ${XTLDR_SOURCE})
 # Add linker libraries
 target_link_libraries(xtldr libxtos)

-# Add linker options
-target_link_options(xtldr PRIVATE /ALIGN:512)
-
 # Set proper binary name and install target
 if(ARCH STREQUAL "i686")
 	set(BINARY_NAME "bootia32")
@@ -53,6 +49,5 @@ set_install_target(xtldr efi/boot)

 # Set loader entrypoint and subsystem
 set_entrypoint(xtldr "BlStartXtLoader")
-set_imagebase(xtldr ${BASEADDRESS_XTLDR})
 set_linker_map(xtldr TRUE)
 set_subsystem(xtldr efi_application)
--- a/boot/xtldr/README.md
+++ b/boot/xtldr/README.md
--- a/boot/xtldr/arch/amd64/memory.cc
+++ b/boot/xtldr/arch/amd64/memory.cc
@@ -44,14 +44,6 @@ Memory::BuildPageMap(IN PXTBL_PAGE_MAPPING PageMap,
        return Status;
    }

-    /* Add new memory mapping for the page map itself */
-    Status = MapVirtualMemory(PageMap, Address, Address, 1, LoaderMemoryData);
-    if(Status != STATUS_EFI_SUCCESS)
-    {
-        /* Memory mapping failure */
-        return Status;
-    }
-
    /* Assign and zero-fill memory used by page mappings */
    PageMap->PtePointer = (PVOID)(UINT_PTR)Address;
    RTL::Memory::ZeroMemory(PageMap->PtePointer, EFI_PAGE_SIZE);
@@ -65,7 +57,7 @@ Memory::BuildPageMap(IN PXTBL_PAGE_MAPPING PageMap,
    }

    /* Map the trampoline code area */
-    Status = MapVirtualMemory(PageMap, MM_TRAMPOLINE_ADDRESS,MM_TRAMPOLINE_ADDRESS,
+    Status = MapVirtualMemory(PageMap, (PVOID)MM_TRAMPOLINE_ADDRESS,(PVOID)MM_TRAMPOLINE_ADDRESS,
                              1, LoaderFirmwareTemporary);
    if(Status != STATUS_EFI_SUCCESS)
    {
@@ -82,7 +74,7 @@ Memory::BuildPageMap(IN PXTBL_PAGE_MAPPING PageMap,
        ModuleInfo = CONTAIN_RECORD(ModulesListEntry, XTBL_MODULE_INFO, Flink);

        /* Map module code */
-        Status = MapVirtualMemory(PageMap, (ULONGLONG)ModuleInfo->ModuleBase, (ULONGLONG)ModuleInfo->ModuleBase,
+        Status = MapVirtualMemory(PageMap, ModuleInfo->ModuleBase, ModuleInfo->ModuleBase,
                                  EFI_SIZE_TO_PAGES(ModuleInfo->ModuleSize), LoaderFirmwareTemporary);

        /* Check if mapping succeeded */
@@ -103,7 +95,7 @@ Memory::BuildPageMap(IN PXTBL_PAGE_MAPPING PageMap,
    if(LoaderBase && LoaderSize)
    {
        /* Map boot loader code as well */
-        Status = MapVirtualMemory(PageMap, (ULONGLONG)LoaderBase, (ULONGLONG)LoaderBase,
+        Status = MapVirtualMemory(PageMap, LoaderBase, LoaderBase,
                                  EFI_SIZE_TO_PAGES(LoaderSize), LoaderFirmwareTemporary);
        if(Status != STATUS_EFI_SUCCESS)
        {
@@ -201,7 +193,7 @@ Memory::GetNextPageTable(IN PXTBL_PAGE_MAPPING PageMap,
        }

        /* Add new memory mapping */
-        Status = MapVirtualMemory(PageMap, Address, Address, 1, LoaderMemoryData);
+        Status = MapVirtualMemory(PageMap, NULLPTR, (PVOID)(UINT_PTR)Address, 1, LoaderMemoryData);
        if(Status != STATUS_EFI_SUCCESS)
        {
            /* Memory mapping failure */
@@ -247,9 +239,9 @@ Memory::GetNextPageTable(IN PXTBL_PAGE_MAPPING PageMap,
 XTCDECL
 EFI_STATUS
 Memory::MapPage(IN PXTBL_PAGE_MAPPING PageMap,
-                IN ULONGLONG VirtualAddress,
-                IN ULONGLONG PhysicalAddress,
-                IN ULONGLONG NumberOfPages)
+                IN ULONG_PTR VirtualAddress,
+                IN ULONG_PTR PhysicalAddress,
+                IN ULONG NumberOfPages)
 {
    PVOID Pml1, Pml2, Pml3, Pml4, Pml5;
    SIZE_T Pml1Entry, Pml2Entry, Pml3Entry, Pml4Entry, Pml5Entry;
--- a/boot/xtldr/arch/i686/memory.cc
+++ b/boot/xtldr/arch/i686/memory.cc
@@ -93,7 +93,7 @@ Memory::BuildPageMap(IN PXTBL_PAGE_MAPPING PageMap,
    }

    /* Map the trampoline code area */
-    Status = MapVirtualMemory(PageMap, MM_TRAMPOLINE_ADDRESS,MM_TRAMPOLINE_ADDRESS,
+    Status = MapVirtualMemory(PageMap, (PVOID)MM_TRAMPOLINE_ADDRESS,(PVOID)MM_TRAMPOLINE_ADDRESS,
                              1, LoaderFirmwareTemporary);
    if(Status != STATUS_EFI_SUCCESS)
    {
@@ -110,7 +110,7 @@ Memory::BuildPageMap(IN PXTBL_PAGE_MAPPING PageMap,
        ModuleInfo = CONTAIN_RECORD(ModulesListEntry, XTBL_MODULE_INFO, Flink);

        /* Map module code */
-        Status = MapVirtualMemory(PageMap, (ULONGLONG)ModuleInfo->ModuleBase, (ULONGLONG)ModuleInfo->ModuleBase,
+        Status = MapVirtualMemory(PageMap, ModuleInfo->ModuleBase, ModuleInfo->ModuleBase,
                                  EFI_SIZE_TO_PAGES(ModuleInfo->ModuleSize), LoaderFirmwareTemporary);

        /* Check if mapping succeeded */
@@ -131,7 +131,7 @@ Memory::BuildPageMap(IN PXTBL_PAGE_MAPPING PageMap,
    if(LoaderBase && LoaderSize)
    {
        /* Map boot loader code as well */
-        Status = MapVirtualMemory(PageMap, (ULONGLONG)LoaderBase, (ULONGLONG)LoaderBase,
+        Status = MapVirtualMemory(PageMap, LoaderBase, LoaderBase,
                                  EFI_SIZE_TO_PAGES(LoaderSize), LoaderFirmwareTemporary);
        if(Status != STATUS_EFI_SUCCESS)
        {
@@ -252,7 +252,7 @@ Memory::GetNextPageTable(IN PXTBL_PAGE_MAPPING PageMap,
        }

        /* Add new memory mapping */
-        Status = MapVirtualMemory(PageMap, (ULONGLONG)NULLPTR, Address, 1, LoaderMemoryData);
+        Status = MapVirtualMemory(PageMap, NULLPTR, (PVOID)(UINT_PTR)Address, 1, LoaderMemoryData);
        if(Status != STATUS_EFI_SUCCESS)
        {
            /* Memory mapping failure */
@@ -313,9 +313,9 @@ Memory::GetNextPageTable(IN PXTBL_PAGE_MAPPING PageMap,
 XTCDECL
 EFI_STATUS
 Memory::MapPage(IN PXTBL_PAGE_MAPPING PageMap,
-                IN ULONGLONG VirtualAddress,
-                IN ULONGLONG PhysicalAddress,
-                IN ULONGLONG NumberOfPages)
+                IN ULONG_PTR VirtualAddress,
+                IN ULONG_PTR PhysicalAddress,
+                IN ULONG NumberOfPages)
 {
    SIZE_T PageFrameNumber;
    PVOID Pml1, Pml2, Pml3;
--- a/boot/xtldr/bootutil.cc
+++ b/boot/xtldr/bootutil.cc
--- a/boot/xtldr/config.cc
+++ b/boot/xtldr/config.cc
--- a/boot/xtldr/console.cc
+++ b/boot/xtldr/console.cc
--- a/boot/xtldr/data.cc
+++ b/boot/xtldr/data.cc
@@ -10,18 +10,6 @@
 #include <xtldr.hh>


-/* Legacy BIOS cursor X position */
-USHORT BiosUtils::CursorX = 0;
-
-/* Legacy BIOS cursor Y position */
-USHORT BiosUtils::CursorY = 0;
-
-/* Legacy BIOS screen height */
-CONST USHORT BiosUtils::VgaHeight = 25;
-
-/* Legacy BIOS screen width */
-CONST USHORT BiosUtils::VgaWidth = 80;
-
 /* XT Boot Loader menu list */
 PLIST_ENTRY Configuration::BootMenuList = NULLPTR;

--- a/boot/xtldr/debug.cc
+++ b/boot/xtldr/debug.cc
--- a/boot/xtldr/efiutils.cc
+++ b/boot/xtldr/efiutils.cc
--- a/boot/xtldr/includes/libxtos.hh
+++ b/boot/xtldr/includes/libxtos.hh
--- a/boot/xtldr/includes/xtldr.hh
+++ b/boot/xtldr/includes/xtldr.hh
@@ -15,25 +15,6 @@
 #include <libxtos.hh>


-class BiosUtils
-{
-    private:
-        STATIC USHORT CursorX;
-        STATIC USHORT CursorY;
-        STATIC CONST USHORT VgaHeight;
-        STATIC CONST USHORT VgaWidth;
-
-    public:
-        STATIC XTCDECL VOID ClearScreen();
-        STATIC XTCDECL VOID Print(IN PCWSTR Format,
-                                  IN ...);
-        STATIC XTCDECL XTSTATUS PutChar(IN WCHAR Character);
-
-    private:
-        STATIC XTCDECL VOID ScrollScreen();
-        STATIC XTCDECL VOID UpdateCursor();
-};
-
 class BootUtils
 {
    public:
@@ -168,7 +149,6 @@ class Memory
        STATIC XTCDECL EFI_STATUS FreePages(IN ULONGLONG NumberOfPages,
                                            IN EFI_PHYSICAL_ADDRESS Memory);
        STATIC XTCDECL EFI_STATUS FreePool(IN PVOID Memory);
-        STATIC XTCDECL LOADER_MEMORY_TYPE GetLoaderMemoryType(IN EFI_MEMORY_TYPE EfiMemoryType);
        STATIC XTCDECL VOID GetMappingsCount(IN PXTBL_PAGE_MAPPING PageMap,
                                             OUT PULONG NumberOfMappings);
        STATIC XTCDECL EFI_STATUS GetMemoryMap(OUT PEFI_MEMORY_MAP MemoryMap);
@@ -178,25 +158,31 @@ class Memory
                                              IN SHORT PageMapLevel,
                                              IN PAGE_SIZE PageSize);
        STATIC XTCDECL EFI_STATUS MapEfiMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                                               IN ULONG_PTR BaseAddress);
+                                               IN OUT PVOID *MemoryMapAddress,
+                                               IN PBL_GET_MEMTYPE_ROUTINE GetMemoryTypeRoutine);
        STATIC XTCDECL EFI_STATUS MapPage(IN PXTBL_PAGE_MAPPING PageMap,
-                                          IN ULONGLONG VirtualAddress,
-                                          IN ULONGLONG PhysicalAddress,
-                                          IN ULONGLONG NumberOfPages);
+                                          IN ULONG_PTR VirtualAddress,
+                                          IN ULONG_PTR PhysicalAddress,
+                                          IN ULONG NumberOfPages);
        STATIC XTCDECL EFI_STATUS MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                                                   IN ULONGLONG VirtualAddress,
-                                                   IN ULONGLONG PhysicalAddress,
+                                                   IN PVOID VirtualAddress,
+                                                   IN PVOID PhysicalAddress,
                                                   IN ULONGLONG NumberOfPages,
                                                   IN LOADER_MEMORY_TYPE MemoryType);
+        STATIC XTCDECL PVOID PhysicalAddressToVirtual(IN PVOID PhysicalAddress,
+                                                      IN PVOID PhysicalBase,
+                                                      IN PVOID VirtualBase);
+        STATIC XTCDECL EFI_STATUS PhysicalListToVirtual(IN PXTBL_PAGE_MAPPING PageMap,
+                                                        IN OUT PLIST_ENTRY ListHead,
+                                                        IN PVOID PhysicalBase,
+                                                        IN PVOID VirtualBase);

    private:
+        STATIC XTCDECL LOADER_MEMORY_TYPE GetLoaderMemoryType(IN EFI_MEMORY_TYPE EfiMemoryType);
        STATIC XTCDECL EFI_STATUS GetNextPageTable(IN PXTBL_PAGE_MAPPING PageMap,
                                                   IN PVOID PageTable,
                                                   IN SIZE_T Entry,
                                                   OUT PVOID *NextPageTable);
-        STATIC XTCDECL EFI_STATUS MapDescriptor(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                                                IN PEFI_MEMORY_DESCRIPTOR Descriptor,
-                                                IN ULONG_PTR BaseAddress);
        STATIC XTCDECL EFI_STATUS SelfMapPml(IN PXTBL_PAGE_MAPPING PageMap,
                                             IN ULONG_PTR SelfMapAddress);
 };
--- a/boot/xtldr/library/modproto.cc
+++ b/boot/xtldr/library/modproto.cc
--- a/boot/xtldr/memory.cc
+++ b/boot/xtldr/memory.cc
@@ -4,7 +4,6 @@
 * FILE:            xtldr/memory.cc
 * DESCRIPTION:     XT Boot Loader memory management
 * DEVELOPERS:      Rafal Kupiec <belliash@codingworkshop.eu.org>
- *                  Aiken Harris <harraiken91@gmail.com>
 */

 #include <xtldr.hh>
@@ -309,69 +308,17 @@ Memory::InitializePageMap(OUT PXTBL_PAGE_MAPPING PageMap,
    PageMap->PageSize = PageSize;
 }

-/**
- * Maps memory descriptor to the page mapping structure.
- *
- * @param PageMap
- *        Supplies a pointer to the page mapping structure.
- *
- * @param Descriptor
- *        Supplies a pointer to EFI memory descriptor, which will be mapped.
- *
- * @param BaseAddress
- *        Supplies a base address, where EFI memory will be mapped.
- *
- * @return This routine returns a status code.
- *
- * @since XT 1.0
- */
-XTCDECL
-EFI_STATUS
-Memory::MapDescriptor(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                      IN PEFI_MEMORY_DESCRIPTOR Descriptor,
-                      IN ULONG_PTR BaseAddress)
-{
-    LOADER_MEMORY_TYPE MemoryType;
-
-    /* Skip EFI reserved memory */
-    if(Descriptor->Type == EfiReservedMemoryType)
-    {
-        /* Skip EFI reserved memory */
-        return STATUS_EFI_SUCCESS;
-    }
-
-    /* Convert EFI memory type into XTLDR memory type */
-    MemoryType = Memory::GetLoaderMemoryType((EFI_MEMORY_TYPE)Descriptor->Type);
-
-    /* Do memory mappings depending on memory type */
-    if(MemoryType == LoaderFirmwareTemporary)
-    {
-        /* Map EFI firmware code */
-        return Memory::MapVirtualMemory(PageMap, Descriptor->PhysicalStart,
-                                        Descriptor->PhysicalStart, Descriptor->NumberOfPages, MemoryType);
-    }
-    else if(MemoryType != LoaderFree)
-    {
-        /* Add any non-free memory mappings based on provided base address */
-        return Memory::MapVirtualMemory(PageMap, (BaseAddress | Descriptor->PhysicalStart), Descriptor->PhysicalStart,
-                                        Descriptor->NumberOfPages, MemoryType);
-    }
-    else
-    {
-        /* Map all other memory as loader free */
-        return Memory::MapVirtualMemory(PageMap, (ULONGLONG)NULLPTR, Descriptor->PhysicalStart,
-                                        Descriptor->NumberOfPages, LoaderFree);
-    }
-}
-
 /**
 * Adds EFI memory mapping to the page mapping structure.
 *
 * @param PageMap
 *        Supplies a pointer to the page mapping structure.
 *
- * @param BaseAddress
- *        Supplies a base address, where EFI memory will be mapped.
+ * @param MemoryMapAddress
+ *        Supplies a virtual address, where EFI memory will be mapped.
+ *
+ * @param GetMemoryTypeRoutine
+ *        Supplies a pointer to the routine which will be used to match EFI memory type to the OS memory type.
 *
 * @return This routine returns a status code.
 *
@@ -380,15 +327,27 @@ Memory::MapDescriptor(IN OUT PXTBL_PAGE_MAPPING PageMap,
 XTCDECL
 EFI_STATUS
 Memory::MapEfiMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                     IN ULONG_PTR BaseAddress)
+                     IN OUT PVOID *MemoryMapAddress,
+                     IN PBL_GET_MEMTYPE_ROUTINE GetMemoryTypeRoutine)
 {
    PEFI_MEMORY_DESCRIPTOR Descriptor;
+    LOADER_MEMORY_TYPE MemoryType;
    PEFI_MEMORY_MAP MemoryMap;
    SIZE_T DescriptorCount;
-    ULONGLONG MaxAddress;
+    PUCHAR VirtualAddress;
    EFI_STATUS Status;
    SIZE_T Index;

+    /* Set virtual address as specified in argument */
+    VirtualAddress = (PUCHAR)*MemoryMapAddress;
+
+    /* Check if custom memory type routine is specified */
+    if(GetMemoryTypeRoutine == NULLPTR)
+    {
+        /* Use default memory type routine */
+        GetMemoryTypeRoutine = GetLoaderMemoryType;
+    }
+
    /* Allocate and zero-fill buffer for EFI memory map */
    AllocatePool(sizeof(EFI_MEMORY_MAP), (PVOID*)&MemoryMap);
    RTL::Memory::ZeroMemory(MemoryMap, sizeof(EFI_MEMORY_MAP));
@@ -408,43 +367,68 @@ Memory::MapEfiMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
    /* Iterate through all descriptors from the memory map */
    for(Index = 0; Index < DescriptorCount; Index++)
    {
-        /* Check page map level */
-        if(PageMap->PageMapLevel == 2)
+        /* Make sure descriptor does not start beyond lowest physical page */
+        if(Descriptor->PhysicalStart <= MAXUINT_PTR)
        {
-            /* Limit physical address to 4GB in legacy mode */
-            MaxAddress = 0xFFFFFFFF;
-        }
-        else if(PageMap->PageMapLevel == 3)
-        {
-            /* Limit physical address to 64GB in PAE mode */
-            MaxAddress = 0xFFFFFFFFF;
-        }
-
-        /* Check page map level */
-        if(PageMap->PageMapLevel == 2 || PageMap->PageMapLevel == 3)
-        {
-            /* Check if physical address starts beyond limit */
-            if(Descriptor->PhysicalStart > MaxAddress)
+            /* Skip EFI reserved memory */
+            if(Descriptor->Type == EfiReservedMemoryType)
            {
                /* Go to the next descriptor */
                Descriptor = (PEFI_MEMORY_DESCRIPTOR)((PUCHAR)Descriptor + MemoryMap->DescriptorSize);
                continue;
            }

-            /* Check if memory descriptor exceeds the lowest physical page */
-            if(Descriptor->PhysicalStart + (Descriptor->NumberOfPages << EFI_PAGE_SHIFT) > MaxAddress)
+            /* Check if preparing page map level 2 (non-PAE i686) */
+            if(PageMap->PageMapLevel == 2)
            {
-                /* Truncate memory descriptor to maximum supported address */
-                Descriptor->NumberOfPages = (((ULONGLONG)MaxAddress) - Descriptor->PhysicalStart) >> EFI_PAGE_SHIFT;
-            }
-        }
+                /* Check if physical address starts beyond 4GB */
+                if(Descriptor->PhysicalStart > 0xFFFFFFFF)
+                {
+                    /* Go to the next descriptor */
+                    Descriptor = (PEFI_MEMORY_DESCRIPTOR)((PUCHAR)Descriptor + MemoryMap->DescriptorSize);
+                    continue;
+                }

-        /* Map this descriptor and make sure it succeeded */
-        Status = MapDescriptor(PageMap, Descriptor, BaseAddress);
-        if(Status != STATUS_EFI_SUCCESS)
-        {
-            /* Mapping failed */
-            return Status;
+                /* Check if memory descriptor exceeds the lowest physical page */
+                if(Descriptor->PhysicalStart + (Descriptor->NumberOfPages << EFI_PAGE_SHIFT) > MAXULONG)
+                {
+                    /* Truncate memory descriptor to the 4GB */
+                    Descriptor->NumberOfPages = (((ULONGLONG)MAXULONG + 1) - Descriptor->PhysicalStart) >> EFI_PAGE_SHIFT;
+                }
+            }
+
+            /* Convert EFI memory type into XTLDR memory type */
+            MemoryType = GetMemoryTypeRoutine((EFI_MEMORY_TYPE)Descriptor->Type);
+
+            /* Do memory mappings depending on memory type */
+            if(MemoryType == LoaderFirmwareTemporary)
+            {
+                /* Map EFI firmware code */
+                Status = MapVirtualMemory(PageMap, (PVOID)Descriptor->PhysicalStart,
+                                          (PVOID)Descriptor->PhysicalStart, Descriptor->NumberOfPages, MemoryType);
+            }
+            else if(MemoryType != LoaderFree)
+            {
+                /* Add any non-free memory mapping */
+                Status = MapVirtualMemory(PageMap, VirtualAddress, (PVOID)Descriptor->PhysicalStart,
+                                          Descriptor->NumberOfPages, MemoryType);
+
+                /* Calculate next valid virtual address */
+                VirtualAddress += Descriptor->NumberOfPages * EFI_PAGE_SIZE;
+            }
+            else
+            {
+                /* Map all other memory as loader free */
+                Status = MapVirtualMemory(PageMap, NULLPTR, (PVOID)Descriptor->PhysicalStart,
+                                          Descriptor->NumberOfPages, LoaderFree);
+            }
+
+            /* Make sure memory mapping succeeded */
+            if(Status != STATUS_EFI_SUCCESS)
+            {
+                /* Mapping failed */
+                return Status;
+            }
        }

        /* Grab next descriptor */
@@ -452,7 +436,7 @@ Memory::MapEfiMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
    }

    /* Always map first page */
-    Status = MapVirtualMemory(PageMap, (ULONGLONG)NULLPTR, 0, 1, LoaderFirmwarePermanent);
+    Status = MapVirtualMemory(PageMap, NULLPTR, (PVOID)0, 1, LoaderFirmwarePermanent);
    if(Status != STATUS_EFI_SUCCESS)
    {
        /* Mapping failed */
@@ -460,7 +444,7 @@ Memory::MapEfiMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
    }

    /* Map BIOS ROM and VRAM */
-    Status = MapVirtualMemory(PageMap, (ULONGLONG)NULLPTR, 0xA0000, 0x60, LoaderFirmwarePermanent);
+    Status = MapVirtualMemory(PageMap, NULLPTR, (PVOID)0xA0000, 0x60, LoaderFirmwarePermanent);
    if(Status != STATUS_EFI_SUCCESS)
    {
        /* Mapping failed */
@@ -468,6 +452,7 @@ Memory::MapEfiMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
    }

    /* Store next valid virtual address and return success */
+    *MemoryMapAddress = VirtualAddress;
    return STATUS_EFI_SUCCESS;
 }

@@ -496,13 +481,13 @@ Memory::MapEfiMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
 XTCDECL
 EFI_STATUS
 Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                         IN ULONGLONG VirtualAddress,
-                         IN ULONGLONG PhysicalAddress,
+                         IN PVOID VirtualAddress,
+                         IN PVOID PhysicalAddress,
                         IN ULONGLONG NumberOfPages,
                         IN LOADER_MEMORY_TYPE MemoryType)
 {
    PXTBL_MEMORY_MAPPING Mapping1, Mapping2, Mapping3;
-    ULONGLONG PhysicalAddressEnd, PhysicalAddress2End;
+    PVOID PhysicalAddressEnd, PhysicalAddress2End;
    PLIST_ENTRY ListEntry, MappingListEntry;
    SIZE_T NumberOfMappedPages;
    EFI_STATUS Status;
@@ -522,7 +507,7 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
    Mapping1->MemoryType = MemoryType;

    /* Calculate the end of the physical address */
-    PhysicalAddressEnd = PhysicalAddress + (NumberOfPages * EFI_PAGE_SIZE) - 1;
+    PhysicalAddressEnd = (PVOID)((ULONG_PTR)PhysicalAddress + (NumberOfPages * EFI_PAGE_SIZE) - 1);

    /* Iterate through all the mappings already set to insert new mapping at the correct place */
    ListEntry = PageMap->MemoryMap.Flink;
@@ -530,7 +515,7 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
    {
        /* Take a mapping from the list and calculate its end of physical address */
        Mapping2 = CONTAIN_RECORD(ListEntry, XTBL_MEMORY_MAPPING, ListEntry);
-        PhysicalAddress2End = Mapping2->PhysicalAddress + (Mapping2->NumberOfPages * EFI_PAGE_SIZE) - 1;
+        PhysicalAddress2End = (PVOID)((ULONG_PTR)Mapping2->PhysicalAddress + (Mapping2->NumberOfPages * EFI_PAGE_SIZE) - 1);

        /* Check if new mapping is a subset of an existing mapping */
        if(Mapping1->PhysicalAddress >= Mapping2->PhysicalAddress && PhysicalAddressEnd <= PhysicalAddress2End)
@@ -554,7 +539,7 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
            }

            /* Calculate number of pages for this mapping */
-            NumberOfMappedPages = (PhysicalAddress2End - PhysicalAddressEnd) / EFI_PAGE_SIZE;
+            NumberOfMappedPages = ((PUCHAR)PhysicalAddress2End - (PUCHAR)PhysicalAddressEnd) / EFI_PAGE_SIZE;
            if(NumberOfMappedPages > 0)
            {
                /* Pages associated to the mapping, allocate memory for it */
@@ -566,8 +551,8 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
                }

                /* Set mapping fields and insert it on the top */
-                Mapping3->PhysicalAddress = PhysicalAddressEnd + 1;
-                Mapping3->VirtualAddress = (ULONGLONG)NULLPTR;
+                Mapping3->PhysicalAddress = (PUCHAR)PhysicalAddressEnd + 1;
+                Mapping3->VirtualAddress = NULLPTR;
                Mapping3->NumberOfPages = NumberOfMappedPages;
                Mapping3->MemoryType = Mapping2->MemoryType;
                RTL::LinkedList::InsertHeadList(&Mapping2->ListEntry, &Mapping3->ListEntry);
@@ -576,7 +561,7 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
            /* Calculate number of pages and the end of the physical address */
            Mapping2->NumberOfPages = ((PUCHAR)PhysicalAddressEnd + 1 -
                                       (PUCHAR)Mapping2->PhysicalAddress) / EFI_PAGE_SIZE;
-            PhysicalAddress2End = Mapping2->PhysicalAddress + (Mapping2->NumberOfPages * EFI_PAGE_SIZE) - 1;
+            PhysicalAddress2End = (PVOID)((ULONG_PTR)Mapping2->PhysicalAddress + (Mapping2->NumberOfPages * EFI_PAGE_SIZE) - 1);
        }

        /* Check if they overlap */
@@ -603,7 +588,7 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,

                /* Set mapping fields and insert it on the top */
                Mapping3->PhysicalAddress = Mapping1->PhysicalAddress;
-                Mapping3->VirtualAddress = (ULONGLONG)NULLPTR;
+                Mapping3->VirtualAddress = NULLPTR;
                Mapping3->NumberOfPages = NumberOfMappedPages;
                Mapping3->MemoryType = Mapping2->MemoryType;
                RTL::LinkedList::InsertHeadList(&Mapping2->ListEntry, &Mapping3->ListEntry);
@@ -612,7 +597,7 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
            /* Calculate number of pages and the end of the physical address */
            Mapping2->NumberOfPages = ((PUCHAR)Mapping1->PhysicalAddress -
                                       (PUCHAR)Mapping2->PhysicalAddress) / EFI_PAGE_SIZE;
-            PhysicalAddress2End = Mapping2->PhysicalAddress + (Mapping2->NumberOfPages * EFI_PAGE_SIZE) - 1;
+            PhysicalAddress2End = (PVOID)((ULONG_PTR)Mapping2->PhysicalAddress + (Mapping2->NumberOfPages * EFI_PAGE_SIZE) - 1);
        }

        /* Check if mapping is really needed */
@@ -657,3 +642,105 @@ Memory::MapVirtualMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
    /* Return success */
    return STATUS_EFI_SUCCESS;
 }
+
+/**
+ * Converts physical address to virtual address based on physical base and virtual base.
+ *
+ * @param PhysicalAddress
+ *        Specifies physical address that will be converted to virtual address.
+ *
+ * @param PhysicalBase
+ *        Supplies a physical base address.
+ *
+ * @param VirtualBase
+ *        Supplies a virtual base address.
+ *
+ * @return This routine returns a mapped virtual address.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+PVOID
+Memory::PhysicalAddressToVirtual(IN PVOID PhysicalAddress,
+                                 IN PVOID PhysicalBase,
+                                 IN PVOID VirtualBase)
+{
+    /* Convert physical address to virtual address */
+    return (PUCHAR)VirtualBase + ((PUCHAR)PhysicalAddress - (PUCHAR)PhysicalBase);
+}
+
+/**
+ * Converts whole linked list addressing from physical to virtual for future use after enabling paging.
+ *
+ * @param PageMap
+ *        Supplies a pointer to the page mapping structure.
+ *
+ * @param ListHead
+ *        Supplies a pointer to a structure that serves as the list header.
+ *
+ * @param PhysicalBase
+ *        Supplies a physical base address.
+ *
+ * @param VirtualBase
+ *        Supplies a virtual base address.
+ *
+ * @return This routine returns a status code.
+ *
+ * @since XT 1.0
+ */
+XTCDECL
+EFI_STATUS
+Memory::PhysicalListToVirtual(IN PXTBL_PAGE_MAPPING PageMap,
+                              IN OUT PLIST_ENTRY ListHead,
+                              IN PVOID PhysicalBase,
+                              IN PVOID VirtualBase)
+{
+    PLIST_ENTRY ListEntry, NextEntry;
+
+    /* Make sure list is properly initialized */
+    if(ListHead->Flink == 0 || ListHead->Blink == 0)
+    {
+        /* List not initialized, return error code */
+        return STATUS_EFI_INVALID_PARAMETER;
+    }
+
+    /* Iterate through all elements */
+    ListEntry = ListHead->Flink;
+    while(ListEntry != ListHead)
+    {
+        /* Save physical address of the next element */
+        NextEntry = ListEntry->Flink;
+
+        /* Convert the address of this element to VirtualAddress */
+        if(ListEntry->Blink == ListHead)
+        {
+            /* Find virtual address of list head */
+            ListEntry->Blink = (PLIST_ENTRY)GetVirtualAddress(PageMap, ListEntry->Blink);
+        }
+        else
+        {
+            /* Convert list entry */
+            ListEntry->Blink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListEntry->Blink, (PVOID)PhysicalBase, VirtualBase);
+        }
+        if(ListEntry->Flink == ListHead)
+        {
+            /* Convert list head */
+            ListEntry->Flink = ListHead->Flink->Blink;
+        }
+        else
+        {
+            /* Convert list entry */
+            ListEntry->Flink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListEntry->Flink, (PVOID)PhysicalBase, VirtualBase);
+        }
+
+        /* Get to the next element*/
+        ListEntry = NextEntry;
+    }
+
+    /* Convert list head */
+    ListHead->Blink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListHead->Blink, (PVOID)PhysicalBase, VirtualBase);
+    ListHead->Flink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListHead->Flink, (PVOID)PhysicalBase, VirtualBase);
+
+    /* Return success */
+    return STATUS_EFI_SUCCESS;
+}
--- a/boot/xtldr/modules/CMakeLists.txt
+++ b/boot/xtldr/modules/CMakeLists.txt
--- a/boot/xtldr/modules/acpi/CMakeLists.txt
+++ b/boot/xtldr/modules/acpi/CMakeLists.txt
--- a/boot/xtldr/modules/acpi/acpi.cc
+++ b/boot/xtldr/modules/acpi/acpi.cc
--- a/boot/xtldr/modules/acpi/data.cc
+++ b/boot/xtldr/modules/acpi/data.cc
--- a/boot/xtldr/modules/acpi/includes/acpi.hh
+++ b/boot/xtldr/modules/acpi/includes/acpi.hh
--- a/boot/xtldr/modules/beep/CMakeLists.txt
+++ b/boot/xtldr/modules/beep/CMakeLists.txt
--- a/boot/xtldr/modules/beep/beep.cc
+++ b/boot/xtldr/modules/beep/beep.cc
--- a/boot/xtldr/modules/beep/data.cc
+++ b/boot/xtldr/modules/beep/data.cc
--- a/boot/xtldr/modules/beep/includes/beep.hh
+++ b/boot/xtldr/modules/beep/includes/beep.hh
--- a/boot/xtldr/modules/chainldr/CMakeLists.txt
+++ b/boot/xtldr/modules/chainldr/CMakeLists.txt
--- a/boot/xtldr/modules/chainldr/chainldr.cc
+++ b/boot/xtldr/modules/chainldr/chainldr.cc
--- a/boot/xtldr/modules/chainldr/data.cc
+++ b/boot/xtldr/modules/chainldr/data.cc
--- a/boot/xtldr/modules/chainldr/includes/chainldr.hh
+++ b/boot/xtldr/modules/chainldr/includes/chainldr.hh
--- a/boot/xtldr/modules/dummy/CMakeLists.txt
+++ b/boot/xtldr/modules/dummy/CMakeLists.txt
--- a/boot/xtldr/modules/dummy/data.cc
+++ b/boot/xtldr/modules/dummy/data.cc
--- a/boot/xtldr/modules/dummy/dummy.cc
+++ b/boot/xtldr/modules/dummy/dummy.cc
--- a/boot/xtldr/modules/dummy/includes/dummy.hh
+++ b/boot/xtldr/modules/dummy/includes/dummy.hh
--- a/boot/xtldr/modules/framebuf/CMakeLists.txt
+++ b/boot/xtldr/modules/framebuf/CMakeLists.txt
--- a/boot/xtldr/modules/framebuf/data.cc
+++ b/boot/xtldr/modules/framebuf/data.cc
--- a/boot/xtldr/modules/framebuf/framebuf.cc
+++ b/boot/xtldr/modules/framebuf/framebuf.cc
--- a/boot/xtldr/modules/framebuf/includes/framebuf.hh
+++ b/boot/xtldr/modules/framebuf/includes/framebuf.hh
--- a/boot/xtldr/modules/pecoff/CMakeLists.txt
+++ b/boot/xtldr/modules/pecoff/CMakeLists.txt
--- a/boot/xtldr/modules/pecoff/data.cc
+++ b/boot/xtldr/modules/pecoff/data.cc
--- a/boot/xtldr/modules/pecoff/includes/pecoff.hh
+++ b/boot/xtldr/modules/pecoff/includes/pecoff.hh
--- a/boot/xtldr/modules/pecoff/pecoff.cc
+++ b/boot/xtldr/modules/pecoff/pecoff.cc
@@ -729,11 +729,11 @@ PeCoff::RelocateLoadedImage(IN PPECOFF_IMAGE_CONTEXT Image)
    }
    else
    {
+        /* Check if loaded 32-bit PE32 image should be relocated */
        /* Set relocation data directory and image base address */
        DataDirectory = &Image->PeHeader->OptionalHeader32.DataDirectory[PECOFF_IMAGE_DIRECTORY_ENTRY_BASERELOC];
        ImageBase = Image->PeHeader->OptionalHeader32.ImageBase;

-        /* Check if loaded 32-bit PE32 image should be relocated */
        if(Image->PeHeader->OptionalHeader32.NumberOfRvaAndSizes <= PECOFF_IMAGE_DIRECTORY_ENTRY_BASERELOC ||
        DataDirectory->VirtualAddress == 0 || DataDirectory->Size < sizeof(PECOFF_IMAGE_BASE_RELOCATION))
        {
--- a/boot/xtldr/modules/xtos_o/CMakeLists.txt
+++ b/boot/xtldr/modules/xtos_o/CMakeLists.txt
--- a/boot/xtldr/modules/xtos_o/amd64/memory.cc
+++ b/boot/xtldr/modules/xtos_o/amd64/memory.cc
@@ -156,20 +156,6 @@ Xtos::EnablePaging(IN PXTBL_PAGE_MAPPING PageMap)
    return STATUS_EFI_SUCCESS;
 }

-/**
- * Returns the base address of the memory mapping.
- *
- * @return This routine returns the base address of the memory mapping.
- *
- * @since XT 1.0
- */
-XTCDECL
-ULONG_PTR
-Xtos::GetBaseMappingAddress(VOID)
-{
-    return KSEG0_BASE;
-}
-
 /**
 * Maps the page table for hardware layer addess space.
 *
--- a/boot/xtldr/modules/xtos_o/data.cc
+++ b/boot/xtldr/modules/xtos_o/data.cc
--- a/boot/xtldr/modules/xtos_o/i686/memory.cc
+++ b/boot/xtldr/modules/xtos_o/i686/memory.cc
@@ -44,20 +44,6 @@ Xtos::DeterminePagingLevel(IN CONST PWCHAR Parameters)
    return 2;
 }

-/**
- * Returns the base address of the memory mapping.
- *
- * @return This routine returns the base address of the memory mapping.
- *
- * @since XT 1.0
- */
-XTCDECL
-ULONG_PTR
-Xtos::GetBaseMappingAddress(VOID)
-{
-    return KSEG0_BASE;
-}
-
 /**
 * Builds the actual memory mapping page table and enables paging. This routine exits EFI boot services as well.
 *
@@ -73,22 +59,9 @@ EFI_STATUS
 Xtos::EnablePaging(IN PXTBL_PAGE_MAPPING PageMap)
 {
    EFI_STATUS Status;
-    ULONG_PTR SelfMapAddress;
-
-    /* Initialize self map address */
-    if(PageMap->PageMapLevel == 3)
-    {
-        /* For PML3 (PAE) use PTE base address */
-        SelfMapAddress = MM_PTE_BASE;
-    }
-    else
-    {
-        /* For PML2 (PAE disabled) use legacy PDE base address */
-        SelfMapAddress = MM_PDE_LEGACY_BASE;
-    }

    /* Build page map */
-    Status = XtLdrProtocol->Memory.BuildPageMap(PageMap, SelfMapAddress);
+    Status = XtLdrProtocol->Memory.BuildPageMap(PageMap, MM_PTE_BASE);
    if(Status != STATUS_EFI_SUCCESS)
    {
        /* Failed to build page map */
--- a/boot/xtldr/modules/xtos_o/includes/xtos.hh
+++ b/boot/xtldr/modules/xtos_o/includes/xtos.hh
@@ -33,34 +33,44 @@ class Xtos
                                                   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 ULONG_PTR GetBaseMappingAddress(VOID);
        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,
-                                                        OUT PKERNEL_INITIALIZATION_BLOCK *KernelParameters,
+                                                        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,
-                                             IN OUT PXTBL_PAGE_MAPPING PageMap,
                                             OUT PPECOFF_IMAGE_CONTEXT *ImageContext);
        STATIC XTCDECL EFI_STATUS MapHardwareMemoryPool(IN PXTBL_PAGE_MAPPING PageMap);
-        STATIC XTCDECL EFI_STATUS MapMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                                            IN ULONGLONG Address,
-                                            IN ULONG NumberOfPages,
-                                            IN LOADER_MEMORY_TYPE MemoryType,
-                                            IN BOOLEAN KernelMapping);
-        STATIC XTCDECL PVOID PhysicalAddressToVirtual(PVOID PhysicalAddress);
-        STATIC XTCDECL EFI_STATUS PhysicalListToVirtual(IN OUT PLIST_ENTRY ListHead);
+        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);
 };
--- a/boot/xtldr/modules/xtos_o/xtos.cc
+++ b/boot/xtldr/modules/xtos_o/xtos.cc
@@ -191,6 +191,7 @@ Xtos::GetDisplayInformation(OUT PSYSTEM_RESOURCE_FRAMEBUFFER FrameBufferResource
 XTCDECL
 EFI_STATUS
 Xtos::GetMemoryDescriptorList(IN PXTBL_PAGE_MAPPING PageMap,
+                              IN PVOID *VirtualAddress,
                              OUT PLIST_ENTRY MemoryDescriptorList)
 {
    EFI_PHYSICAL_ADDRESS Address;
@@ -205,7 +206,7 @@ Xtos::GetMemoryDescriptorList(IN PXTBL_PAGE_MAPPING PageMap,
        return Status;
    }

-    Status = MapMemory(PageMap, Address, Pages, LoaderMemoryData, TRUE);
+    Status = XtLdrProtocol->Memory.MapVirtualMemory(PageMap, *VirtualAddress, (PVOID)Address, Pages, LoaderMemoryData);
    if(Status != STATUS_EFI_SUCCESS)
    {
        XtLdrProtocol->Memory.FreePages(Address, Pages);
@@ -213,14 +214,13 @@ Xtos::GetMemoryDescriptorList(IN PXTBL_PAGE_MAPPING PageMap,
    }

    PVOID PhysicalBase = (PVOID)Address;
-    PVOID CurrentDescriptor = PhysicalBase;

    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)CurrentDescriptor;
+        PLOADER_MEMORY_DESCRIPTOR MemoryDescriptor = (PLOADER_MEMORY_DESCRIPTOR)Address;

        MemoryDescriptor->MemoryType = MemoryMapping->MemoryType;
        MemoryDescriptor->BasePage = (UINT_PTR)MemoryMapping->PhysicalAddress / EFI_PAGE_SIZE;
@@ -228,11 +228,11 @@ Xtos::GetMemoryDescriptorList(IN PXTBL_PAGE_MAPPING PageMap,

        XtLdrProtocol->LinkedList.InsertTail(MemoryDescriptorList, &MemoryDescriptor->ListEntry);

-        CurrentDescriptor = (PUINT8)CurrentDescriptor + sizeof(LOADER_MEMORY_DESCRIPTOR);
+        Address = Address + sizeof(LOADER_MEMORY_DESCRIPTOR);
        ListEntry = ListEntry->Flink;
    }

-    PhysicalListToVirtual(MemoryDescriptorList);
+    XtLdrProtocol->Memory.PhysicalListToVirtual(PageMap, MemoryDescriptorList, PhysicalBase, *VirtualAddress);

    return STATUS_EFI_SUCCESS;
 }
@@ -240,6 +240,7 @@ Xtos::GetMemoryDescriptorList(IN PXTBL_PAGE_MAPPING PageMap,
 XTCDECL
 EFI_STATUS
 Xtos::GetSystemResourcesList(IN PXTBL_PAGE_MAPPING PageMap,
+                             IN PVOID *VirtualAddress,
                             OUT PLIST_ENTRY SystemResourcesList)
 {
    XTSTATUS Status;
@@ -256,6 +257,7 @@ Xtos::GetSystemResourcesList(IN PXTBL_PAGE_MAPPING PageMap,
    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));

@@ -264,14 +266,19 @@ Xtos::GetSystemResourcesList(IN PXTBL_PAGE_MAPPING PageMap,
    {
        return Status;
    }
-
-    Status = MapMemory(PageMap, Address, Pages, LoaderFirmwarePermanent, TRUE);
+    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));
@@ -287,7 +294,7 @@ Xtos::GetSystemResourcesList(IN PXTBL_PAGE_MAPPING PageMap,
    AcpiResource->Header.ResourceSize = sizeof(SYSTEM_RESOURCE_ACPI);

    /* Get APIC and XSDP/RSDP addresses */
-    AcpiProtocol->GetApicBase((PVOID *)&AcpiResource->ApicBase);
+    AcpiProtocol->GetApicBase(&AcpiResource->ApicBase);
    AcpiProtocol->GetAcpiDescriptionPointer(&AcpiResource->Header.PhysicalAddress);

    /* No need to map ACPI */
@@ -326,19 +333,21 @@ Xtos::GetSystemResourcesList(IN PXTBL_PAGE_MAPPING PageMap,
    FrameBufferPages = EFI_SIZE_TO_PAGES(FbSize);

    /* Rewrite framebuffer address by using virtual address */
-    FrameBufferResource->Header.VirtualAddress = PhysicalAddressToVirtual(FrameBufferResource->Header.PhysicalAddress);
+    FrameBufferResource->Header.VirtualAddress = *VirtualAddress;

    /* Map frame buffer memory */
-    XtLdrProtocol->Memory.MapVirtualMemory(PageMap, (ULONGLONG)FrameBufferResource->Header.VirtualAddress,
-                                           (ULONGLONG)FrameBufferResource->Header.PhysicalAddress,
-                                           FrameBufferPages, LoaderHardwareCachedMemory);
+    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);

-    PhysicalListToVirtual(SystemResourcesList);
+    XtLdrProtocol->Memory.PhysicalListToVirtual(PageMap, SystemResourcesList, PhysicalBase, VirtualBase);

    return STATUS_EFI_SUCCESS;
 }
@@ -360,7 +369,7 @@ Xtos::InitializeApicBase(IN PXTBL_PAGE_MAPPING PageMap)
    EFI_GUID AcpiGuid = XT_ACPI_PROTOCOL_GUID;
    PXTBL_ACPI_PROTOCOL AcpiProtocol;
    EFI_HANDLE ProtocolHandle;
-    EFI_PHYSICAL_ADDRESS ApicBaseAddress;
+    PVOID ApicBaseAddress;
    EFI_STATUS Status;

    /* Open ACPI protocol */
@@ -372,7 +381,7 @@ Xtos::InitializeApicBase(IN PXTBL_PAGE_MAPPING PageMap)
    }

    /* Get APIC base address */
-    Status = AcpiProtocol->GetApicBase((PVOID *)&ApicBaseAddress);
+    Status = AcpiProtocol->GetApicBase(&ApicBaseAddress);
    if(Status != STATUS_EFI_SUCCESS)
    {
        /* Failed to get APIC base address */
@@ -380,21 +389,18 @@ Xtos::InitializeApicBase(IN PXTBL_PAGE_MAPPING PageMap)
    }

    /* Map APIC base address */
-    XtLdrProtocol->Memory.MapVirtualMemory(PageMap, APIC_BASE, ApicBaseAddress, 1, LoaderFirmwarePermanent);
+    XtLdrProtocol->Memory.MapVirtualMemory(PageMap, (PVOID)APIC_BASE, ApicBaseAddress, 1, LoaderFirmwarePermanent);
    return STATUS_EFI_SUCCESS;
 }

 /**
 * Initializes and maps the kernel initialization block.
 *
- * @param PageMap
- *        Supplies a pointer to the page map.
+ * @param MemoryMappings
+ *        Supplies a pointer to linked list containing all memory mappings.
 *
- * @param KernelParameters
- *        Returns a pointer to the kernel initialization block.
- *
- * @param Parameters
- *        Supplies a list of input parameters passed to the kernel.
+ * @param VirtualAddress
+ *        Supplies a pointer to the next valid, free and available virtual address.
 *
 * @return This routine returns a status code.
 *
@@ -403,7 +409,7 @@ Xtos::InitializeApicBase(IN PXTBL_PAGE_MAPPING PageMap)
 XTCDECL
 EFI_STATUS
 Xtos::InitializeLoaderBlock(IN PXTBL_PAGE_MAPPING PageMap,
-                            OUT PKERNEL_INITIALIZATION_BLOCK *KernelParameters,
+                            IN PVOID *VirtualAddress,
                            IN PXTBL_BOOT_PARAMETERS Parameters)
 {
    PKERNEL_INITIALIZATION_BLOCK LoaderBlock;
@@ -411,7 +417,6 @@ Xtos::InitializeLoaderBlock(IN PXTBL_PAGE_MAPPING PageMap,
    EFI_STATUS Status;
    UINT BlockPages;
    UINT ParametersSize;
-    ULONGLONG LoaderBlockVa;

    /* Calculate size of parameters */
    ParametersSize = (XtLdrProtocol->WideString.Length(Parameters->Parameters, 0) + 1) * sizeof(WCHAR);
@@ -444,29 +449,25 @@ Xtos::InitializeLoaderBlock(IN PXTBL_PAGE_MAPPING PageMap,
    // LoaderBlock->FirmwareInformation.EfiFirmware.EfiVersion = EfiSystemTable->Hdr.Revision;
    LoaderBlock->FirmwareInformation.EfiFirmware.EfiRuntimeServices = NULLPTR;

-    /* Get the KSEG0-based virtual address for the loader block */
-    LoaderBlockVa = (ULONGLONG)PhysicalAddressToVirtual(LoaderBlock);
-    *KernelParameters = (PKERNEL_INITIALIZATION_BLOCK)LoaderBlockVa;
-
    /* Copy parameters to kernel initialization block */
-    LoaderBlock->KernelParameters = (PWCHAR)(LoaderBlockVa + sizeof(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 */
-    Status = MapMemory(PageMap, (ULONGLONG)LoaderBlock, BlockPages, LoaderSystemBlock, TRUE);
-    if(Status != STATUS_EFI_SUCCESS)
-    {
-        return Status;
-    }
+    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, &LoaderBlock->SystemResourcesListHead);
+    GetSystemResourcesList(PageMap, VirtualAddress, &LoaderBlock->SystemResourcesListHead);

    /* Initialize memory descriptor list */
    XtLdrProtocol->LinkedList.InitializeHead(&LoaderBlock->MemoryDescriptorListHead);
-    GetMemoryDescriptorList(PageMap, &LoaderBlock->MemoryDescriptorListHead);
+    GetMemoryDescriptorList(PageMap, VirtualAddress, &LoaderBlock->MemoryDescriptorListHead);

    /* Return success */
    return STATUS_EFI_SUCCESS;
@@ -507,12 +508,12 @@ Xtos::InitializeModule(IN EFI_HANDLE ImageHandle,
 * @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 PageMap
- *        Supplies pointer to the memory area where memory mappings will be stored.
- *
 * @param ImageContext
 *        Supplies pointer to the memory area where loaded PE/COFF image context will be stored.
 *
@@ -524,8 +525,8 @@ XTCDECL
 EFI_STATUS
 Xtos::LoadModule(IN PEFI_FILE_HANDLE SystemDir,
                 IN PWCHAR FileName,
+                 IN PVOID VirtualAddress,
                 IN LOADER_MEMORY_TYPE MemoryType,
-                 IN OUT PXTBL_PAGE_MAPPING PageMap,
                 OUT PPECOFF_IMAGE_CONTEXT *ImageContext)
 {
    PEFI_FILE_HANDLE ModuleHandle;
@@ -544,8 +545,8 @@ Xtos::LoadModule(IN PEFI_FILE_HANDLE SystemDir,
        return Status;
    }

-    /* Load the PE/COFF image file into memory */
-    Status = PeCoffProtocol->LoadImage(ModuleHandle, MemoryType, NULLPTR, (PVOID*)ImageContext);
+    /* Load the PE/COFF image file */
+    Status = PeCoffProtocol->LoadImage(ModuleHandle, MemoryType, VirtualAddress, (PVOID*)ImageContext);
    if(Status != STATUS_EFI_SUCCESS)
    {
        /* Unable to load the file */
@@ -553,15 +554,6 @@ Xtos::LoadModule(IN PEFI_FILE_HANDLE SystemDir,
        return Status;
    }

-    /* Relocate the PE/COFF image file */
-    Status = PeCoffProtocol->RelocateImage(*ImageContext, GetBaseMappingAddress() | (ULONGLONG)(*ImageContext)->PhysicalAddress);
-    if(Status != STATUS_EFI_SUCCESS)
-    {
-        /* Unable to relocate the file */
-        XtLdrProtocol->Debug.Print(L"ERROR: Failed to relocate '%S'\n", FileName);
-        return Status;
-    }
-
    /* Close image file */
    ModuleHandle->Close(ModuleHandle);

@@ -583,133 +575,9 @@ Xtos::LoadModule(IN PEFI_FILE_HANDLE SystemDir,
        XtLdrProtocol->Debug.Print(L"WARNING: Loaded PE/COFF image with non-XT subsystem set\n");
    }

-    /* Ensure that page map is provided */
-    if(PageMap != NULLPTR)
-    {
-        /* Add kernel image memory mapping */
-        Status = MapMemory(PageMap, (ULONGLONG)(*ImageContext)->PhysicalAddress,
-                           (*ImageContext)->ImagePages, LoaderSystemCode, TRUE);
-        if(Status != STATUS_EFI_SUCCESS)
-        {
-            /* Failed to map kernel image memory */
-            return Status;
-        }
-    }
-
    /* Print debug message */
-    XtLdrProtocol->Debug.Print(L"Loaded '%S' at PA: %P, VA: %P\n", FileName, (*ImageContext)->PhysicalAddress,
-                               PhysicalAddressToVirtual((*ImageContext)->VirtualAddress));
-
-    /* Return success */
-    return STATUS_EFI_SUCCESS;
-}
-
-/**
- * Adds a physical to virtual address mapping.
- *
- * @param PageMap
- *        Supplies a pointer to the page mapping structure.
- *
- * @param PhysicalAddress
- *        Supplies a physical address which will be mapped.
- *
- * @param NumberOfPages
- *        Supplies a number of pages that will be mapped.
- *
- * @param MemoryType
- *        Supplies the type of mapped memory that will be assigned to the memory descriptor.
- *
- * @param KernelMapping
- *        Supplies a flag that indicates if mapping should be done in kernel mode or if identity mapping should be used.
- *
- * @return This routine returns a status code.
- *
- * @since XT 1.0
- */
-XTCDECL
-EFI_STATUS
-Xtos::MapMemory(IN OUT PXTBL_PAGE_MAPPING PageMap,
-                IN ULONGLONG Address,
-                IN ULONG NumberOfPages,
-                IN LOADER_MEMORY_TYPE MemoryType,
-                IN BOOLEAN KernelMapping)
-{
-    ULONGLONG BaseAddress;
-
-    /* Check if kernel mode mapping */
-    if(KernelMapping)
-    {
-        /* Map memory based on kernel base address */
-        BaseAddress = GetBaseMappingAddress();
-    }
-    else
-    {
-        /* Use identity mapping */
-        BaseAddress = (ULONGLONG)NULLPTR;
-    }
-
-    /* Map memory and return status code */
-    return XtLdrProtocol->Memory.MapVirtualMemory(PageMap, BaseAddress + Address, Address, NumberOfPages, MemoryType);
-}
-
-/**
- * Converts physical address to virtual address.
- *
- * @param PhysicalAddress
- *        Specifies physical address that will be converted to virtual address.
- *
- * @return This routine returns a mapped virtual address.
- *
- * @since XT 1.0
- */
-XTCDECL
-PVOID
-Xtos::PhysicalAddressToVirtual(PVOID PhysicalAddress)
-{
-    return (PVOID)((ULONG_PTR)PhysicalAddress | GetBaseMappingAddress());
-}
-
-/**
- * Converts whole linked list addressing from physical to virtual for future use after enabling paging.
- *
- * @param ListHead
- *        Supplies a pointer to a structure that serves as the list header.
- *
- * @return This routine returns a status code.
- *
- * @since XT 1.0
- */
-XTCDECL
-EFI_STATUS
-Xtos::PhysicalListToVirtual(IN OUT PLIST_ENTRY ListHead)
-{
-    PLIST_ENTRY ListEntry, NextEntry;
-
-    /* Make sure list is properly initialized */
-    if(ListHead->Flink == 0 || ListHead->Blink == 0)
-    {
-        /* List not initialized, return error code */
-        return STATUS_EFI_INVALID_PARAMETER;
-    }
-
-    /* Iterate through the list */
-    ListEntry = ListHead->Flink;
-    while(ListEntry != ListHead)
-    {
-        /* Store the next entry */
-        NextEntry = ListEntry->Flink;
-
-        /* Convert the list entry */
-        ListEntry->Flink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListEntry->Flink);
-        ListEntry->Blink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListEntry->Blink);
-
-        /* Get the next element */
-        ListEntry = NextEntry;
-    }
-
-    /* Convert the list head */
-    ListHead->Flink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListHead->Flink);
-    ListHead->Blink = (PLIST_ENTRY)PhysicalAddressToVirtual(ListHead->Blink);
+    XtLdrProtocol->Debug.Print(L"Loaded %S at PA: %P, VA: %P\n", FileName,
+                               (*ImageContext)->PhysicalAddress, (*ImageContext)->VirtualAddress);

    /* Return success */
    return STATUS_EFI_SUCCESS;
@@ -739,6 +607,7 @@ Xtos::RunBootSequence(IN PEFI_FILE_HANDLE BootDir,
    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;
@@ -759,23 +628,39 @@ Xtos::RunBootSequence(IN PEFI_FILE_HANDLE BootDir,
    /* 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, GetBaseMappingAddress());
+    Status = XtLdrProtocol->Memory.MapEfiMemory(&PageMap, &VirtualMemoryArea, NULLPTR);
    if(Status != STATUS_EFI_SUCCESS)
    {
        return Status;
    }

    /* Load the kernel */
-    Status = LoadModule(BootDir, Parameters->KernelFile, LoaderSystemCode, &PageMap, &ImageContext);
+    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)
@@ -785,8 +670,11 @@ Xtos::RunBootSequence(IN PEFI_FILE_HANDLE BootDir,
        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, &KernelParameters, Parameters);
+    Status = InitializeLoaderBlock(&PageMap, &VirtualAddress, Parameters);
    if(Status != STATUS_EFI_SUCCESS)
    {
        /* Failed to setup kernel initialization block */
--- a/boot/xtldr/protocol.cc
+++ b/boot/xtldr/protocol.cc
@@ -1066,6 +1066,8 @@ Protocol::InstallXtLoaderProtocol()
    LoaderProtocol.Memory.MapPage = Memory::MapPage;
    LoaderProtocol.Memory.MapVirtualMemory = Memory::MapVirtualMemory;
    LoaderProtocol.Memory.MoveMemory = RTL::Memory::MoveMemory;
+    LoaderProtocol.Memory.PhysicalAddressToVirtual = Memory::PhysicalAddressToVirtual;
+    LoaderProtocol.Memory.PhysicalListToVirtual = Memory::PhysicalListToVirtual;
    LoaderProtocol.Memory.SetMemory = RTL::Memory::SetMemory;
    LoaderProtocol.Memory.ZeroMemory = RTL::Memory::ZeroMemory;
    LoaderProtocol.Protocol.Close = CloseProtocol;
--- a/boot/xtldr/shell.cc
+++ b/boot/xtldr/shell.cc
--- a/boot/xtldr/textui.cc
+++ b/boot/xtldr/textui.cc
--- a/boot/xtldr/volume.cc
+++ b/boot/xtldr/volume.cc
--- a/boot/xtldr/xtldr.cc
+++ b/boot/xtldr/xtldr.cc
@@ -236,15 +236,6 @@ BlStartXtLoader(IN EFI_HANDLE ImageHandle,
    PWCHAR Modules;
    EFI_STATUS Status;

-    /* Check if system is EFI-based and provided parameters are valid */
-    if(ImageHandle == NULLPTR || SystemTable == NULLPTR)
-    {
-        /* Invalid parameters, print error message using BIOS calls and hang */
-        BiosUtils::ClearScreen();
-        BiosUtils::Print(L"XTLDR requires EFI-based system!");
-        for(;;);
-    }
-
    /* Initialize XTLDR and */
    XtLoader::InitializeBootLoader(ImageHandle, SystemTable);

--- a/xtoskrnl/CMakeLists.txt
+++ b/xtoskrnl/CMakeLists.txt
@@ -51,20 +51,14 @@ list(APPEND XTOSKRNL_SOURCE
    ${XTOSKRNL_SOURCE_DIR}/ke/spinlock.cc
    ${XTOSKRNL_SOURCE_DIR}/ke/sysres.cc
    ${XTOSKRNL_SOURCE_DIR}/ke/timer.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/mmgr.cc
+    ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/init.cc
    ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/pagemap.cc
    ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/paging.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/pfault.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/pfn.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/${ARCH}/pte.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/colors.cc
    ${XTOSKRNL_SOURCE_DIR}/mm/data.cc
    ${XTOSKRNL_SOURCE_DIR}/mm/hlpool.cc
+    ${XTOSKRNL_SOURCE_DIR}/mm/init.cc
    ${XTOSKRNL_SOURCE_DIR}/mm/kpool.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/mmgr.cc
    ${XTOSKRNL_SOURCE_DIR}/mm/paging.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/pfn.cc
-    ${XTOSKRNL_SOURCE_DIR}/mm/pte.cc
    ${XTOSKRNL_SOURCE_DIR}/po/idle.cc
    ${XTOSKRNL_SOURCE_DIR}/rtl/${ARCH}/dispatch.cc
    ${XTOSKRNL_SOURCE_DIR}/rtl/${ARCH}/exsup.cc
@@ -88,12 +82,11 @@ add_library(libxtos ${XTOSKRNL_SOURCE})

 # Link kernel executable
 add_executable(xtoskrnl
+               ${XTOSKRNL_SOURCE}
               ${CMAKE_CURRENT_BINARY_DIR}/xtoskrnl.def)

 # Add linker libraries
-target_link_libraries(xtoskrnl
-                      PRIVATE
-                      libxtos)
+target_link_libraries(xtoskrnl)

 # Set proper binary name and install target
 set_target_properties(xtoskrnl PROPERTIES SUFFIX .exe)
--- a/xtoskrnl/README.md
+++ b/xtoskrnl/README.md
@@ -4,18 +4,6 @@ within the XTOS kernel space. It is responsible for various core services, such
 management, and process scheduling. The kernel contains the scheduler (sometimes referred to as the Dispatcher), the
 cache, object, and memory managers, the security manager, and other executive components described below.

-
-## Kernel Parameters
-Kernel parameters are XTOS boot-time options used to ensure proper initialization and handling of hardware peripherals.
-These parameters can be configured either temporarily by editing the boot entry in the bootloader’s selection menu, or
-permanently by modifying the XTLDR configuration file.
-
-The following is a consolidated list of available kernel parameters:
- * **NOXPA**: Disables PAE or LA57 support, depending on the CPU architecture. This parameter is handled by the
-   bootloader, which configures paging and selects the appropriate Page Map Level (PML) before transferring control to
-   the kernel.
-
-## Source Code
 The source code of the kernel is organized into subsystem-specific directories. Each directory name also defines the
 corresponding C++ namespace in which the subsystem's classes and routines reside. These subsystems include:

@@ -80,8 +68,8 @@ routine:
 For all C++ code inside the kernel the naming model has evolved. Consider the **KE::KThread::InitializeThread()**
 routine:
 * **KE** - The namespace replaces the prefix and indicates the subsystem. Namespaces are written in uppercase and no
-   longer use the trailing p for private routines, because classes use C++ visibility to control access.
+            longer use the trailing p for private routines, because classes use C++ visibility to control access.
 * **KThread** - Within each namespace, related functionality is grouped into classes, which encapsulate variables and
-   methods.
+                 methods.
 * **InitializeThread** - Method names follow the `<Operation><Object>` pattern.
 
--- a/xtoskrnl/ar/amd64/procsup.cc
+++ b/xtoskrnl/ar/amd64/procsup.cc
@@ -249,34 +249,34 @@ AR::ProcSup::InitializeIdt(IN PKPROCESSOR_BLOCK ProcessorBlock)
    for(Vector = 0; Vector < IDT_ENTRIES; Vector++)
    {
        /* Set the IDT to handle unexpected interrupts */
-        SetIdtGate(ProcessorBlock->IdtBase, Vector, (PVOID)ArTrap0xFF, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_INTERRUPT_GATE);
+        SetIdtGate(ProcessorBlock->IdtBase, Vector, (PVOID)ArTrap0xFF, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
    }

    /* Setup IDT handlers for known interrupts and traps */
-    SetIdtGate(ProcessorBlock->IdtBase, 0x00, (PVOID)ArTrap0x00, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x01, (PVOID)ArTrap0x01, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x02, (PVOID)ArTrap0x02, KGDT_R0_CODE, KIDT_IST_PANIC, KIDT_ACCESS_RING0, AMD64_INTERRUPT_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x03, (PVOID)ArTrap0x03, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x04, (PVOID)ArTrap0x04, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x05, (PVOID)ArTrap0x05, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x06, (PVOID)ArTrap0x06, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x07, (PVOID)ArTrap0x07, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x08, (PVOID)ArTrap0x08, KGDT_R0_CODE, KIDT_IST_PANIC, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x09, (PVOID)ArTrap0x09, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0A, (PVOID)ArTrap0x0A, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0B, (PVOID)ArTrap0x0B, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0C, (PVOID)ArTrap0x0C, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0D, (PVOID)ArTrap0x0D, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0E, (PVOID)ArTrap0x0E, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x10, (PVOID)ArTrap0x10, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x11, (PVOID)ArTrap0x11, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x12, (PVOID)ArTrap0x12, KGDT_R0_CODE, KIDT_IST_MCA, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x13, (PVOID)ArTrap0x13, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x1F, (PVOID)ArTrap0x1F, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_INTERRUPT_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2C, (PVOID)ArTrap0x2C, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2D, (PVOID)ArTrap0x2D, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3, AMD64_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2F, (PVOID)ArTrap0x2F, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_INTERRUPT_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0xE1, (PVOID)ArTrap0xE1, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0, AMD64_INTERRUPT_GATE);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x00, (PVOID)ArTrap0x00, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x01, (PVOID)ArTrap0x01, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x02, (PVOID)ArTrap0x02, KGDT_R0_CODE, KIDT_IST_PANIC, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x03, (PVOID)ArTrap0x03, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x04, (PVOID)ArTrap0x04, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x05, (PVOID)ArTrap0x05, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x06, (PVOID)ArTrap0x06, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x07, (PVOID)ArTrap0x07, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x08, (PVOID)ArTrap0x08, KGDT_R0_CODE, KIDT_IST_PANIC, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x09, (PVOID)ArTrap0x09, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0A, (PVOID)ArTrap0x0A, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0B, (PVOID)ArTrap0x0B, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0C, (PVOID)ArTrap0x0C, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0D, (PVOID)ArTrap0x0D, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0E, (PVOID)ArTrap0x0E, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x10, (PVOID)ArTrap0x10, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x11, (PVOID)ArTrap0x11, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x12, (PVOID)ArTrap0x12, KGDT_R0_CODE, KIDT_IST_MCA, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x13, (PVOID)ArTrap0x13, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x1F, (PVOID)ArTrap0x1F, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2C, (PVOID)ArTrap0x2C, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2D, (PVOID)ArTrap0x2D, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2F, (PVOID)ArTrap0x2F, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0xE1, (PVOID)ArTrap0xE1, KGDT_R0_CODE, KIDT_IST_RESERVED, KIDT_ACCESS_RING0);
 }

 /**
@@ -636,9 +636,6 @@ AR::ProcSup::SetGdtEntryBase(IN PKGDTENTRY Gdt,
 * @param Access
 *        Supplies the gate access rights.
 *
- * @param Type
- *        Supplies the gate type.
- *
 * @return This routine does not return any value.
 *
 * @since XT 1.0
@@ -650,22 +647,15 @@ AR::ProcSup::SetIdtGate(IN PKIDTENTRY Idt,
                        IN PVOID Handler,
                        IN USHORT Selector,
                        IN USHORT Ist,
-                        IN USHORT Dpl,
-                        IN USHORT Type)
+                        IN USHORT Access)
 {
-    /* Set the handler's address */
+    /* Setup the gate */
    Idt[Vector].OffsetLow = ((ULONG_PTR)Handler & 0xFFFF);
    Idt[Vector].OffsetMiddle = (((ULONG_PTR)Handler >> 16) & 0xFFFF);
    Idt[Vector].OffsetHigh = (ULONG_PTR)Handler >> 32;
-
-    /* Set the code segment selector */
-    Idt[Vector].Selector = Selector;
-
-    /* Initialize the gate's attributes and flags */
-    Idt[Vector].Access = 0;
-    Idt[Vector].Dpl = Dpl;
+    Idt[Vector].Dpl = Access;
    Idt[Vector].IstIndex = Ist;
    Idt[Vector].Present = 1;
-    Idt[Vector].Reserved1 = 0;
-    Idt[Vector].Type = Type;
+    Idt[Vector].Selector = Selector;
+    Idt[Vector].Type = 0xE;
 }
--- a/xtoskrnl/ar/i686/procsup.cc
+++ b/xtoskrnl/ar/i686/procsup.cc
@@ -242,34 +242,34 @@ AR::ProcSup::InitializeIdt(IN PKPROCESSOR_BLOCK ProcessorBlock)
    for(Vector = 0; Vector < IDT_ENTRIES; Vector++)
    {
        /* Set the IDT to handle unexpected interrupts */
-        SetIdtGate(ProcessorBlock->IdtBase, Vector, (PVOID)ArTrap0xFF, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_INTERRUPT_GATE);
+        SetIdtGate(ProcessorBlock->IdtBase, Vector, (PVOID)ArTrap0xFF, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
    }

    /* Setup IDT handlers for known interrupts and traps */
-    SetIdtGate(ProcessorBlock->IdtBase, 0x00, (PVOID)ArTrap0x00, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x01, (PVOID)ArTrap0x01, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x02, (PVOID)ArTrap0x02, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_INTERRUPT_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x03, (PVOID)ArTrap0x03, KGDT_R0_CODE, 0, KIDT_ACCESS_RING3, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x04, (PVOID)ArTrap0x04, KGDT_R0_CODE, 0, KIDT_ACCESS_RING3, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x05, (PVOID)ArTrap0x05, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x06, (PVOID)ArTrap0x06, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x07, (PVOID)ArTrap0x07, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x08, (PVOID)ArTrap0x08, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x09, (PVOID)ArTrap0x09, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0A, (PVOID)ArTrap0x0A, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0B, (PVOID)ArTrap0x0B, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0C, (PVOID)ArTrap0x0C, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0D, (PVOID)ArTrap0x0D, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x0E, (PVOID)ArTrap0x0E, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x10, (PVOID)ArTrap0x10, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x11, (PVOID)ArTrap0x11, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x12, (PVOID)ArTrap0x12, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x13, (PVOID)ArTrap0x13, KGDT_R0_CODE, 0, KIDT_ACCESS_RING0, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2A, (PVOID)ArTrap0x2A, KGDT_R0_CODE, 0, KIDT_ACCESS_RING3, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2B, (PVOID)ArTrap0x2B, KGDT_R0_CODE, 0, KIDT_ACCESS_RING3, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2C, (PVOID)ArTrap0x2C, KGDT_R0_CODE, 0, KIDT_ACCESS_RING3, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2D, (PVOID)ArTrap0x2D, KGDT_R0_CODE, 0, KIDT_ACCESS_RING3, I686_TRAP_GATE);
-    SetIdtGate(ProcessorBlock->IdtBase, 0x2E, (PVOID)ArTrap0x2E, KGDT_R0_CODE, 0, KIDT_ACCESS_RING3, I686_TRAP_GATE);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x00, (PVOID)ArTrap0x00, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x01, (PVOID)ArTrap0x01, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x02, (PVOID)ArTrap0x02, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x03, (PVOID)ArTrap0x03, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x04, (PVOID)ArTrap0x04, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x05, (PVOID)ArTrap0x05, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x06, (PVOID)ArTrap0x06, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x07, (PVOID)ArTrap0x07, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x08, (PVOID)ArTrap0x08, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x09, (PVOID)ArTrap0x09, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0A, (PVOID)ArTrap0x0A, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0B, (PVOID)ArTrap0x0B, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0C, (PVOID)ArTrap0x0C, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0D, (PVOID)ArTrap0x0D, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x0E, (PVOID)ArTrap0x0E, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x10, (PVOID)ArTrap0x10, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x11, (PVOID)ArTrap0x11, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x12, (PVOID)ArTrap0x12, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x13, (PVOID)ArTrap0x13, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING0);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2A, (PVOID)ArTrap0x2A, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2B, (PVOID)ArTrap0x2B, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2C, (PVOID)ArTrap0x2C, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2D, (PVOID)ArTrap0x2D, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING3);
+    SetIdtGate(ProcessorBlock->IdtBase, 0x2E, (PVOID)ArTrap0x2E, KGDT_R0_CODE, 0, KIDT_INTERRUPT | KIDT_ACCESS_RING3);
 }

 /**
@@ -656,9 +656,6 @@ AR::ProcSup::SetGdtEntryBase(IN PKGDTENTRY Gdt,
 * @param Access
 *        Supplies the gate access rights.
 *
- * @param Type
- *        Supplies the gate type.
- *
 * @return This routine does not return any value.
 *
 * @since XT 1.0
@@ -670,21 +667,13 @@ AR::ProcSup::SetIdtGate(IN PKIDTENTRY Idt,
                        IN PVOID Handler,
                        IN USHORT Selector,
                        IN USHORT Ist,
-                        IN USHORT Dpl,
-                        IN USHORT Type)
+                        IN USHORT Access)
 {
-    /* Set the handler's address */
+    /* Setup the gate */
    Idt[Vector].Offset = (USHORT)((ULONG)Handler & 0xFFFF);
    Idt[Vector].ExtendedOffset = (USHORT)((ULONG)Handler >> 16);
-
-    /* Set the code segment selector */
+    Idt[Vector].Access = 0x8000 | (Access << 8);
    Idt[Vector].Selector = Selector;
-
-    /* Initialize the gate's attributes and flags */
-    Idt[Vector].Access = 0;
-    Idt[Vector].Dpl = Dpl;
-    Idt[Vector].Present = 1;
-    Idt[Vector].Type = Type;
 }

 /**
--- a/xtoskrnl/includes/ar/amd64/procsup.hh
+++ b/xtoskrnl/includes/ar/amd64/procsup.hh
@@ -67,8 +67,7 @@ namespace AR
                                         IN PVOID Handler,
                                         IN USHORT Selector,
                                         IN USHORT Ist,
-                                         IN USHORT Dpl,
-                                         IN USHORT Type);
+                                         IN USHORT Access);
    };
 }

--- a/xtoskrnl/includes/ar/i686/procsup.hh
+++ b/xtoskrnl/includes/ar/i686/procsup.hh
@@ -72,8 +72,7 @@ namespace AR
                                         IN PVOID Handler,
                                         IN USHORT Selector,
                                         IN USHORT Ist,
-                                         IN USHORT Dpl,
-                                         IN USHORT Type);
+                                         IN USHORT Access);
            STATIC XTAPI VOID SetNonMaskableInterruptTssEntry(IN PKPROCESSOR_BLOCK ProcessorBlock,
                                                              IN PVOID KernelFaultStack);

--- a/xtoskrnl/includes/ke/runlevel.hh
+++ b/xtoskrnl/includes/ke/runlevel.hh
@@ -22,48 +22,6 @@ namespace KE
            STATIC XTFASTCALL VOID LowerRunLevel(IN KRUNLEVEL RunLevel);
            STATIC XTFASTCALL KRUNLEVEL RaiseRunLevel(IN KRUNLEVEL RunLevel);
    };
-
-    class LowerRunLevel
-    {
-        private:
-            KRUNLEVEL PreviousRunLevel;
-
-        public:
-            LowerRunLevel(KRUNLEVEL RunLevel)
-            {
-                PreviousRunLevel = KE::RunLevel::GetCurrentRunLevel();
-                KE::RunLevel::LowerRunLevel(RunLevel);
-            }
-
-            ~LowerRunLevel()
-            {
-                KE::RunLevel::RaiseRunLevel(PreviousRunLevel);
-            }
-
-            LowerRunLevel(const LowerRunLevel&) = delete;
-            LowerRunLevel& operator=(const LowerRunLevel&) = delete;
-    };
-
-    class RaiseRunLevel
-    {
-        private:
-            KRUNLEVEL PreviousRunLevel;
-
-        public:
-            RaiseRunLevel(KRUNLEVEL RunLevel)
-            {
-                PreviousRunLevel = KE::RunLevel::GetCurrentRunLevel();
-                KE::RunLevel::RaiseRunLevel(RunLevel);
-            }
-
-            ~RaiseRunLevel()
-            {
-                KE::RunLevel::LowerRunLevel(PreviousRunLevel);
-            }
-
-            RaiseRunLevel(const RaiseRunLevel&) = delete;
-            RaiseRunLevel& operator=(const RaiseRunLevel&) = delete;
-    };
 }

 #endif /* __XTOSKRNL_KE_RUNLEVEL_HH */
--- a/xtoskrnl/includes/ke/spinlock.hh
+++ b/xtoskrnl/includes/ke/spinlock.hh
@@ -17,73 +17,12 @@ namespace KE
 {
    class SpinLock
    {
-        private:
-            STATIC KSPIN_LOCK DispatcherLockQueue;
-            STATIC KSPIN_LOCK ExpansionLockQueue;
-            STATIC KSPIN_LOCK FileSystemLockQueue;
-            STATIC KSPIN_LOCK IoCancelLockQueue;
-            STATIC KSPIN_LOCK IoCompletionLockQueue;
-            STATIC KSPIN_LOCK IoDatabaseLockQueue;
-            STATIC KSPIN_LOCK IoVpbLockQueue;
-            STATIC KSPIN_LOCK MasterLockQueue;
-            STATIC KSPIN_LOCK NonPagedAllocLockQueue;
-            STATIC KSPIN_LOCK NonPagedPoolLockQueue;
-            STATIC KSPIN_LOCK PfnLockQueue;
-            STATIC KSPIN_LOCK SystemSpaceLockQueue;
-            STATIC KSPIN_LOCK TimerTableLockQueue;
-            STATIC KSPIN_LOCK VacbLockQueue;
-            STATIC KSPIN_LOCK WorkLockQueue;
-
        public:
            STATIC XTFASTCALL VOID AcquireQueuedSpinLock(IN KSPIN_LOCK_QUEUE_LEVEL LockLevel);
            STATIC XTFASTCALL VOID AcquireSpinLock(IN OUT PKSPIN_LOCK SpinLock);
-            STATIC XTAPI VOID InitializeAllLocks();
-            STATIC XTAPI VOID InitializeLockQueues();
            STATIC XTAPI VOID InitializeSpinLock(IN PKSPIN_LOCK SpinLock);
            STATIC XTFASTCALL VOID ReleaseQueuedSpinLock(IN KSPIN_LOCK_QUEUE_LEVEL LockLevel);
            STATIC XTFASTCALL VOID ReleaseSpinLock(IN OUT PKSPIN_LOCK SpinLock);
-            STATIC XTFASTCALL BOOLEAN TestSpinLock(IN PKSPIN_LOCK SpinLock);
-    };
-
-    class QueuedSpinLockGuard
-    {
-        private:
-            KSPIN_LOCK_QUEUE_LEVEL QueuedLockLevel;
-
-        public:
-            QueuedSpinLockGuard(IN OUT KSPIN_LOCK_QUEUE_LEVEL LockLevel)
-            {
-                QueuedLockLevel = LockLevel;
-                KE::SpinLock::AcquireQueuedSpinLock(QueuedLockLevel);
-            }
-
-            ~QueuedSpinLockGuard()
-            {
-                KE::SpinLock::ReleaseQueuedSpinLock(QueuedLockLevel);
-            }
-
-            QueuedSpinLockGuard(const QueuedSpinLockGuard&) = delete;
-            QueuedSpinLockGuard& operator=(const QueuedSpinLockGuard&) = delete;
-    };
-
-    class SpinLockGuard
-    {
-        private:
-            PKSPIN_LOCK SpinLock;
-
-        public:
-            SpinLockGuard(IN OUT PKSPIN_LOCK SpinLock)
-            {
-                KE::SpinLock::AcquireSpinLock(SpinLock);
-            }
-
-            ~SpinLockGuard()
-            {
-                KE::SpinLock::ReleaseSpinLock(SpinLock);
-            }
-
-            SpinLockGuard(const SpinLockGuard&) = delete;
-            SpinLockGuard& operator=(const SpinLockGuard&) = delete;
    };
 }

--- a/xtoskrnl/includes/mm.hh
+++ b/xtoskrnl/includes/mm.hh
@@ -12,14 +12,10 @@
 #include <xtos.hh>

 #include XTOS_ARCH_HEADER(mm, pagemap.hh)
-#include XTOS_ARCH_HEADER(mm, paging.hh)
-#include XTOS_ARCH_HEADER(mm, pte.hh)

-#include <mm/colors.hh>
 #include <mm/hlpool.hh>
+#include <mm/init.hh>
 #include <mm/kpool.hh>
-#include <mm/mmgr.hh>
-#include <mm/pfault.hh>
-#include <mm/pfn.hh>
+#include <mm/paging.hh>

 #endif /* __XTOSKRNL_MM_HH */
--- a/xtoskrnl/includes/mm/amd64/pagemap.hh
+++ b/xtoskrnl/includes/mm/amd64/pagemap.hh
@@ -1,13 +1,13 @@
 /**
 * PROJECT:         ExectOS
 * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/includes/mm/amd64/pagemap.hh
+ * FILE:            xtoskrnl/includes/mm/pagemap.hh
 * DESCRIPTION:     Low-level support for page map manipulation
 * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
 */

-#ifndef __XTOSKRNL_MM_AMD64_PAGEMAP_HH
-#define __XTOSKRNL_MM_AMD64_PAGEMAP_HH
+#ifndef __XTOSKRNL_MM_PAGEMAP_HH
+#define __XTOSKRNL_MM_PAGEMAP_HH

 #include <xtos.hh>

@@ -21,75 +21,33 @@ namespace MM
            MMPAGEMAP_INFO PageMapInfo;

        public:
-            XTAPI PMMPTE AdvancePte(IN PMMPTE Pte,
-                                    IN LONG Count);
-            XTAPI VOID ClearPte(IN PMMPTE PtePointer);
-            XTAPI ULONG_PTR GetNextEntry(IN PMMPTE Pte);
-            XTAPI PMMPTE GetNextPte(IN PMMPTE Pte);
-            XTAPI BOOLEAN GetOneEntry(IN PMMPTE Pte);
-            XTAPI PMMP5E GetP5eAddress(IN PVOID Address);
-            XTAPI ULONG GetP5eOffset(IN PVOID Address);
-            XTAPI PVOID GetP5eVirtualAddress(IN PMMP5E P5ePointer);
-            XTAPI PFN_NUMBER GetPageFrameNumber(IN PMMPTE Pte);
-            XTAPI PMMPDE GetPdeAddress(IN PVOID Address);
-            XTAPI ULONG GetPdeOffset(IN PVOID Address);
-            VIRTUAL XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer) = 0;
-            XTAPI PMMPPE GetPpeAddress(IN PVOID Address);
-            XTAPI ULONG GetPpeOffset(IN PVOID Address);
-            VIRTUAL XTAPI PVOID GetPpeVirtualAddress(IN PMMPPE PpePointer) = 0;
-            XTAPI ULONG_PTR GetPte(IN PMMPTE PtePointer);
-            XTAPI PMMPTE GetPteAddress(IN PVOID Address);
-            XTAPI LONG GetPteDistance(PMMPTE EndPte,
-                                      PMMPTE StartPte);
-            XTAPI ULONG GetPteOffset(IN PVOID Address);
-            XTAPI ULONG GetPteSize(VOID);
-            XTAPI ULONG GetPteSoftwareProtection(IN PMMPTE PtePointer);
-            XTAPI ULONG GetPteSoftwarePrototype(IN PMMPTE PtePointer);
-            XTAPI ULONG GetPteSoftwareTransition(IN PMMPTE PtePointer);
-            VIRTUAL XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer) = 0;
-            XTAPI PMMPXE GetPxeAddress(IN PVOID Address);
-            XTAPI ULONG GetPxeOffset(IN PVOID Address);
-            VIRTUAL XTAPI PVOID GetPxeVirtualAddress(IN PMMPXE PxePointer) = 0;
-            XTAPI BOOLEAN GetXpaStatus();
-            VIRTUAL XTAPI VOID InitializePageMapInfo(VOID) = 0;
-            XTAPI BOOLEAN PteValid(IN PMMPTE PtePointer);
-            XTAPI VOID SetNextEntry(IN PMMPTE Pte,
-                                    IN ULONG_PTR Value);
-            XTAPI VOID SetOneEntry(IN PMMPTE Pte,
-                                   IN BOOLEAN Value);
-            XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                              IN PFN_NUMBER PageFrameNumber,
-                              IN ULONG_PTR AttributesMask);
-            XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                              IN ULONG_PTR Attributes);
-            XTAPI VOID SetPteCaching(IN PMMPTE PtePointer,
-                                     IN BOOLEAN CacheDisable,
-                                     IN BOOLEAN WriteThrough);
-            XTAPI VOID TransitionPte(IN PMMPTE PointerPte,
-                                     IN ULONG_PTR Protection);
-            XTAPI VOID WritePte(IN PMMPTE Pte,
-                                IN MMPTE Value);
+            XTAPI VOID ClearPte(PHARDWARE_PTE PtePointer);
+            XTAPI PMMP5E GetP5eAddress(PVOID Address);
+            XTAPI PMMPDE GetPdeAddress(PVOID Address);
+            XTAPI PMMPPE GetPpeAddress(PVOID Address);
+            XTAPI PMMPTE GetPteAddress(PVOID Address);
+            XTAPI PMMPXE GetPxeAddress(PVOID Address);
+            virtual XTAPI VOID InitializePageMapInfo(VOID) = 0;
+            XTAPI BOOLEAN PteValid(PHARDWARE_PTE PtePointer);
+            XTAPI VOID SetPte(PHARDWARE_PTE PtePointer,
+                              PFN_NUMBER PageFrameNumber,
+                              BOOLEAN Writable);
+            XTAPI VOID SetPteCaching(PHARDWARE_PTE PtePointer,
+                                     BOOLEAN CacheDisable,
+                                     BOOLEAN WriteThrough);
    } PAGEMAP, *PPAGEMAP;

    class PageMapBasic final : public PageMap
    {
        public:
-            XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer);
-            XTAPI PVOID GetPpeVirtualAddress(IN PMMPPE PpePointer);
-            XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer);
-            XTAPI PVOID GetPxeVirtualAddress(IN PMMPXE PxePointer);
            XTAPI VOID InitializePageMapInfo(VOID);
    };

    class PageMapXpa final : public PageMap
    {
        public:
-            XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer);
-            XTAPI PVOID GetPpeVirtualAddress(IN PMMPPE PpePointer);
-            XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer);
-            XTAPI PVOID GetPxeVirtualAddress(IN PMMPXE PxePointer);
            XTAPI VOID InitializePageMapInfo(VOID);
    };
 }

-#endif /* __XTOSKRNL_MM_AMD64_PAGEMAP_HH */
+#endif /* __XTOSKRNL_MM_PAGEMAP_HH */
--- a/xtoskrnl/includes/mm/amd64/paging.hh
+++ b/xtoskrnl/includes/mm/amd64/paging.hh
@@ -1,78 +0,0 @@
-/**
- * PROJECT:         ExectOS
- * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/includes/mm/amd64/paging.hh
- * DESCRIPTION:     Low level page management support for AMD64
- * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
- */
-
-#ifndef __XTOSKRNL_MM_AMD64_PAGING_HH
-#define __XTOSKRNL_MM_AMD64_PAGING_HH
-
-#include <xtos.hh>
-
-
-/* Memory Manager */
-namespace MM
-{
-    class Paging
-    {
-        private:
-            STATIC PPAGEMAP PmlRoutines;
-
-        public:
-            STATIC XTAPI PMMPTE AdvancePte(IN PMMPTE Pte,
-                                           IN LONG Count);
-            STATIC XTAPI VOID ClearPte(IN PMMPTE PtePointer);
-            STATIC XTAPI VOID FlushTlb(VOID);
-            STATIC XTAPI ULONG_PTR GetNextEntry(IN PMMPTE Pte);
-            STATIC XTAPI PMMPTE GetNextPte(IN PMMPTE Pte);
-            STATIC XTAPI BOOLEAN GetOneEntry(IN PMMPTE Pte);
-            STATIC XTAPI PMMP5E GetP5eAddress(IN PVOID Address);
-            STATIC XTAPI PVOID GetP5eVirtualAddress(IN PMMP5E P5ePointer);
-            STATIC XTAPI PFN_NUMBER GetPageFrameNumber(IN PMMPTE Pte);
-            STATIC XTAPI PMMPDE GetPdeAddress(IN PVOID Address);
-            STATIC XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer);
-            STATIC XTAPI PMMPPE GetPpeAddress(IN PVOID Address);
-            STATIC XTAPI PVOID GetPpeVirtualAddress(IN PMMPPE PpePointer);
-            STATIC XTAPI ULONG_PTR GetPte(IN PMMPTE PtePointer);
-            STATIC XTAPI PMMPTE GetPteAddress(IN PVOID Address);
-            STATIC XTAPI LONG GetPteDistance(PMMPTE EndPte,
-                                             PMMPTE StartPte);
-            STATIC XTAPI ULONG GetPteSize(VOID);
-            STATIC XTAPI ULONG GetPteSoftwareProtection(IN PMMPTE PtePointer);
-            STATIC XTAPI ULONG GetPteSoftwarePrototype(IN PMMPTE PtePointer);
-            STATIC XTAPI ULONG GetPteSoftwareTransition(IN PMMPTE PtePointer);
-            STATIC XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer);
-            STATIC XTAPI PMMPXE GetPxeAddress(IN PVOID Address);
-            STATIC XTAPI PVOID GetPxeVirtualAddress(IN PMMPXE PxePointer);
-            STATIC XTAPI BOOLEAN GetXpaStatus(VOID);
-            STATIC XTAPI VOID InitializePageMapSupport(VOID);
-            STATIC XTAPI BOOLEAN PteValid(IN PMMPTE PtePointer);
-            STATIC XTAPI VOID SetNextEntry(IN PMMPTE Pte,
-                                           IN ULONG_PTR Value);
-            STATIC XTAPI VOID SetOneEntry(IN PMMPTE Pte,
-                                          IN BOOLEAN Value);
-            STATIC XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                                     IN PFN_NUMBER PageFrameNumber,
-                                     IN ULONG_PTR AttributesMask);
-            STATIC XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                                     IN ULONG_PTR Attributes);
-            STATIC XTAPI VOID SetPteCaching(IN PMMPTE PtePointer,
-                                            IN BOOLEAN CacheDisable,
-                                            IN BOOLEAN WriteThrough);
-            STATIC XTAPI VOID WritePte(IN PMMPTE Pte,
-                                       IN MMPTE Value);
-            STATIC XTAPI VOID TransitionPte(IN PMMPTE PointerPte,
-                                            IN ULONG_PTR Protection);
-            STATIC XTFASTCALL VOID ZeroPages(IN PVOID Address,
-                                             IN ULONG Size);
-
-        private:
-            STATIC XTAPI BOOLEAN GetExtendedPhysicalAddressingStatus(VOID);
-            STATIC XTAPI PPAGEMAP GetPageMapBasicRoutines(VOID);
-            STATIC XTAPI PPAGEMAP GetPageMapXpaRoutines(VOID);
-    };
-}
-
-#endif /* __XTOSKRNL_MM_AMD64_PAGING_HH */
--- a/xtoskrnl/includes/mm/amd64/pte.hh
+++ b/xtoskrnl/includes/mm/amd64/pte.hh
@@ -1,69 +0,0 @@
-/**
- * PROJECT:         ExectOS
- * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/includes/mm/amd64/pte.hh
- * DESCRIPTION:     Page Table Entry (PTE) for AMD64 support
- * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
- */
-
-#ifndef __XTOSKRNL_MM_AMD64_PTE_HH
-#define __XTOSKRNL_MM_AMD64_PTE_HH
-
-#include <xtos.hh>
-
-
-/* Memory Manager */
-namespace MM
-{
-    class Pte
-    {
-        private:
-            STATIC MMPTE FirstSystemFreePte[MaximumPtePoolTypes];
-            STATIC PMMPTE SystemPteBase;
-            STATIC PMMPTE SystemPtesEnd[MaximumPtePoolTypes];
-            STATIC PMMPTE SystemPtesStart[MaximumPtePoolTypes];
-            STATIC PFN_COUNT TotalSystemFreePtes[MaximumPtePoolTypes];
-            STATIC MMPTE ValidPte;
-
-        public:
-            STATIC XTAPI BOOLEAN AddressValid(IN PVOID VirtualAddress);
-            STATIC XTAPI PFN_COUNT GetPtesPerPage(VOID);
-            STATIC XTAPI PMMPTE GetSystemPteBaseAddress(VOID);
-            STATIC XTAPI PMMPTE GetValidPte(VOID);
-            STATIC XTAPI VOID InitializePageTable(VOID);
-            STATIC XTAPI VOID InitializeSystemPte(VOID);
-            STATIC XTAPI VOID InitializeSystemPteSpace(VOID);
-            STATIC XTAPI VOID MapP5E(IN PVOID StartAddress,
-                                     IN PVOID EndAddress,
-                                     IN PMMP5E TemplateP5e);
-            STATIC XTAPI VOID MapPDE(IN PVOID StartAddress,
-                                     IN PVOID EndAddress,
-                                     IN PMMPDE TemplatePde);
-            STATIC XTAPI VOID MapPPE(IN PVOID StartAddress,
-                                     IN PVOID EndAddress,
-                                     IN PMMPPE TemplatePpe);
-            STATIC XTAPI VOID MapPTE(IN PVOID StartAddress,
-                                     IN PVOID EndAddress,
-                                     IN PMMPTE TemplatePte);
-            STATIC XTAPI VOID MapPXE(IN PVOID StartAddress,
-                                     IN PVOID EndAddress,
-                                     IN PMMPXE TemplatePxe);
-            STATIC XTAPI VOID ReleaseSystemPtes(IN PMMPTE StartingPte,
-                                                IN PFN_COUNT NumberOfPtes,
-                                                IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType);
-            STATIC XTAPI PMMPTE ReserveSystemPtes(IN PFN_COUNT NumberOfPtes,
-                                                  IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType);
-
-        private:
-            STATIC XTAPI BOOLEAN FindFreeCluster(IN PFN_COUNT NumberOfPtes,
-                                                 IN MMSYSTEM_PTE_POOL_TYPE SystemPtePoolType,
-                                                 OUT PMMPTE *FoundCluster,
-                                                 OUT PMMPTE *PreviousClusterNode);
-            STATIC XTAPI ULONG GetClusterSize(IN PMMPTE Pte);
-            STATIC XTAPI VOID InitializeSystemPtePool(IN PMMPTE StartingPte,
-                                                      IN PFN_COUNT NumberOfPtes,
-                                                      IN MMSYSTEM_PTE_POOL_TYPE PoolType);
-    };
-}
-
-#endif /* __XTOSKRNL_MM_AMD64_PTE_HH */
--- a/xtoskrnl/includes/mm/colors.hh
+++ b/xtoskrnl/includes/mm/colors.hh
@@ -1,38 +0,0 @@
-/**
- * PROJECT:         ExectOS
- * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/includes/mm/colors.hh
- * DESCRIPTION:     Memory manager page coloring subsystem
- * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
- */
-
-#ifndef __XTOSKRNL_MM_COLORS_HH
-#define __XTOSKRNL_MM_COLORS_HH
-
-#include <xtos.hh>
-
-
-/* Memory Manager */
-namespace MM
-{
-    class Colors
-    {
-        private:
-            STATIC PMMCOLOR_TABLES FreePages[FreePageList + 1];
-            STATIC MMPFNLIST ModifiedPages[MM_PAGING_COLORS];
-            STATIC ULONG PagingColors;
-            STATIC ULONG PagingColorsMask;
-
-        public:
-            STATIC XTAPI VOID ComputePageColoring(VOID);
-            STATIC XTAPI PMMCOLOR_TABLES GetFreePages(IN MMPAGELISTS PageList,
-                                                      IN ULONG Color);
-            STATIC XTAPI PMMPFNLIST GetModifiedPages(IN ULONG Color);
-            STATIC XTAPI ULONG GetNextColor(VOID);
-            STATIC XTAPI ULONG GetPagingColors(VOID);
-            STATIC XTAPI ULONG GetPagingColorsMask(VOID);
-            STATIC XTAPI VOID InitializeColorTables(VOID);
-    };
-}
-
-#endif /* __XTOSKRNL_MM_PFN_HH */
--- a/xtoskrnl/includes/mm/i686/pagemap.hh
+++ b/xtoskrnl/includes/mm/i686/pagemap.hh
@@ -1,13 +1,13 @@
 /**
 * PROJECT:         ExectOS
 * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/includes/mm/i686/pagemap.hh
+ * FILE:            xtoskrnl/includes/mm/pagemap.hh
 * DESCRIPTION:     Low-level support for page map manipulation
 * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
 */

-#ifndef __XTOSKRNL_MM_I686_PAGEMAP_HH
-#define __XTOSKRNL_MM_I686_PAGEMAP_HH
+#ifndef __XTOSKRNL_MM_PAGEMAP_HH
+#define __XTOSKRNL_MM_PAGEMAP_HH

 #include <xtos.hh>

@@ -21,128 +21,45 @@ namespace MM
            MMPAGEMAP_INFO PageMapInfo;

        public:
-            VIRTUAL XTAPI PMMPTE AdvancePte(IN PMMPTE Pte,
-                                            IN ULONG Count) = 0;
-            VIRTUAL XTAPI VOID ClearPte(IN PMMPTE PtePointer) = 0;
-            VIRTUAL XTAPI ULONG_PTR GetNextEntry(IN PMMPTE Pte) = 0;
-            VIRTUAL XTAPI PMMPTE GetNextPte(IN PMMPTE Pte) = 0;
-            VIRTUAL XTAPI BOOLEAN GetOneEntry(IN PMMPTE Pte) = 0;
-            VIRTUAL XTAPI PFN_NUMBER GetPageFrameNumber(IN PMMPTE Pte) = 0;
-            XTAPI PMMPDE GetPdeAddress(IN PVOID Address);
-            XTAPI ULONG GetPdeOffset(IN PVOID Address);
-            VIRTUAL XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer) = 0;
-            XTAPI PMMPPE GetPpeAddress(IN PVOID Address);
-            XTAPI ULONG GetPpeOffset(IN PVOID Address);
-            XTAPI PVOID GetPpeVirtualAddress(IN PMMPPE PpePointer);
-            VIRTUAL XTAPI ULONG_PTR GetPte(IN PMMPTE PtePointer) = 0;
-            XTAPI PMMPTE GetPteAddress(IN PVOID Address);
-            XTAPI ULONG GetPteOffset(IN PVOID Address);
-            VIRTUAL XTAPI LONG GetPteDistance(PMMPTE EndPte,
-                                              PMMPTE StartPte) = 0;
-            VIRTUAL XTAPI ULONG GetPteSize(VOID) = 0;
-            VIRTUAL XTAPI ULONG GetPteSoftwareProtection(IN PMMPTE PtePointer) = 0;
-            VIRTUAL XTAPI ULONG GetPteSoftwarePrototype(IN PMMPTE PtePointer) = 0;
-            VIRTUAL XTAPI ULONG GetPteSoftwareTransition(IN PMMPTE PtePointer) = 0;
-            VIRTUAL XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer) = 0;
-            XTAPI BOOLEAN GetXpaStatus();
-            VIRTUAL XTAPI VOID InitializePageMapInfo(VOID) = 0;
-            VIRTUAL XTAPI BOOLEAN PteValid(IN PMMPTE PtePointer) = 0;
-            VIRTUAL XTAPI VOID SetNextEntry(IN PMMPTE Pte,
-                                            IN ULONG_PTR Value) = 0;
-            VIRTUAL XTAPI VOID SetOneEntry(IN PMMPTE Pte,
-                                           IN BOOLEAN Value) = 0;
-            VIRTUAL XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                                      IN PFN_NUMBER PageFrameNumber,
-                                      IN ULONG_PTR AttributesMask) = 0;
-            VIRTUAL XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                                      IN ULONG_PTR Attributes) = 0;
-            VIRTUAL XTAPI VOID SetPteCaching(IN PMMPTE PtePointer,
-                                             IN BOOLEAN CacheDisable,
-                                             IN BOOLEAN WriteThrough) = 0;
-            VIRTUAL XTAPI VOID TransitionPte(IN PMMPTE PointerPte,
-                                             IN ULONG_PTR Protection) = 0;
-            VIRTUAL XTAPI VOID WritePte(IN PMMPTE Pte,
-                                        IN MMPTE Value) = 0;
-
+            XTAPI VOID ClearPte(PHARDWARE_PTE PtePointer);
+            XTAPI PMMPDE GetPdeAddress(PVOID Address);
+            XTAPI PMMPPE GetPpeAddress(PVOID Address);
+            XTAPI PMMPTE GetPteAddress(PVOID Address);
+            virtual XTAPI VOID InitializePageMapInfo(VOID) = 0;
+            virtual XTAPI BOOLEAN PteValid(PHARDWARE_PTE PtePointer) = 0;
+            virtual XTAPI VOID SetPte(PHARDWARE_PTE PtePointer,
+                                      PFN_NUMBER PageFrameNumber,
+                                      BOOLEAN Writable) = 0;
+            virtual XTAPI VOID SetPteCaching(PHARDWARE_PTE PtePointer,
+                                             BOOLEAN CacheDisable,
+                                             BOOLEAN WriteThrough) = 0;
    } PAGEMAP, *PPAGEMAP;

    class PageMapBasic final : public PageMap
    {
        public:
-            XTAPI PMMPTE AdvancePte(IN PMMPTE Pte,
-                                    IN ULONG Count);
-            XTAPI VOID ClearPte(IN PMMPTE PtePointer);
-            XTAPI ULONG_PTR GetNextEntry(IN PMMPTE Pte);
-            XTAPI PMMPTE GetNextPte(IN PMMPTE Pte);
-            XTAPI BOOLEAN GetOneEntry(IN PMMPTE Pte);
-            XTAPI PFN_NUMBER GetPageFrameNumber(IN PMMPTE Pte);
-            XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer);
-            XTAPI ULONG_PTR GetPte(IN PMMPTE PtePointer);
-            XTAPI LONG GetPteDistance(PMMPTE EndPte,
-                                      PMMPTE StartPte);
-            XTAPI ULONG GetPteSize(VOID);
-            XTAPI ULONG GetPteSoftwareProtection(IN PMMPTE PtePointer);
-            XTAPI ULONG GetPteSoftwarePrototype(IN PMMPTE PtePointer);
-            XTAPI ULONG GetPteSoftwareTransition(IN PMMPTE PtePointer);
-            XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer);
            XTAPI VOID InitializePageMapInfo(VOID);
-            XTAPI BOOLEAN PteValid(IN PMMPTE PtePointer);
-            XTAPI VOID SetNextEntry(IN PMMPTE Pte,
-                                    IN ULONG_PTR Value);
-            XTAPI VOID SetOneEntry(IN PMMPTE Pte,
-                                   IN BOOLEAN Value);
-            XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                              IN PFN_NUMBER PageFrameNumber,
-                              IN ULONG_PTR AttributesMask);
-            XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                              IN ULONG_PTR Attributes);
-            XTAPI VOID SetPteCaching(IN PMMPTE PtePointer,
-                                     IN BOOLEAN CacheDisable,
-                                     IN BOOLEAN WriteThrough);
-            XTAPI VOID TransitionPte(IN PMMPTE PointerPte,
-                                     IN ULONG_PTR Protection);
-            XTAPI VOID WritePte(IN PMMPTE Pte,
-                                IN MMPTE Value);
+            XTAPI BOOLEAN PteValid(PHARDWARE_PTE PtePointer);
+            XTAPI VOID SetPte(PHARDWARE_PTE PtePointer,
+                              PFN_NUMBER PageFrameNumber,
+                              BOOLEAN Writable);
+            XTAPI VOID SetPteCaching(PHARDWARE_PTE PtePointer,
+                                     BOOLEAN CacheDisable,
+                                     BOOLEAN WriteThrough);
    };

    class PageMapXpa final : public PageMap
    {
        public:
-            XTAPI PMMPTE AdvancePte(IN PMMPTE Pte,
-                                    IN ULONG Count);
-            XTAPI VOID ClearPte(IN PMMPTE PtePointer);
-            XTAPI ULONG_PTR GetNextEntry(IN PMMPTE Pte);
-            XTAPI PMMPTE GetNextPte(IN PMMPTE Pte);
-            XTAPI BOOLEAN GetOneEntry(IN PMMPTE Pte);
-            XTAPI PFN_NUMBER GetPageFrameNumber(IN PMMPTE Pte);
-            XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer);
-            XTAPI ULONG_PTR GetPte(IN PMMPTE PtePointer);
-            XTAPI LONG GetPteDistance(PMMPTE EndPte,
-                                      PMMPTE StartPte);
-            XTAPI ULONG GetPteSize(VOID);
-            XTAPI ULONG GetPteSoftwareProtection(IN PMMPTE PtePointer);
-            XTAPI ULONG GetPteSoftwarePrototype(IN PMMPTE PtePointer);
-            XTAPI ULONG GetPteSoftwareTransition(IN PMMPTE PtePointer);
-            XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer);
            XTAPI VOID InitializePageMapInfo(VOID);
-            XTAPI BOOLEAN PteValid(IN PMMPTE PtePointer);
-            XTAPI VOID SetNextEntry(IN PMMPTE Pte,
-                                    IN ULONG_PTR Value);
-            XTAPI VOID SetOneEntry(IN PMMPTE Pte,
-                                   IN BOOLEAN Value);
-            XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                              IN PFN_NUMBER PageFrameNumber,
-                              IN ULONG_PTR AttributesMask);
-            XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                              IN ULONG_PTR Attributes);
-            XTAPI VOID SetPteCaching(IN PMMPTE PtePointer,
-                                     IN BOOLEAN CacheDisable,
-                                     IN BOOLEAN WriteThrough);
-            XTAPI VOID TransitionPte(IN PMMPTE PointerPte,
-                                     IN ULONG_PTR Protection);
-            XTAPI VOID WritePte(IN PMMPTE Pte,
-                                IN MMPTE Value);
+            XTAPI BOOLEAN PteValid(PHARDWARE_PTE PtePointer);
+            XTAPI VOID SetPte(PHARDWARE_PTE PtePointer,
+                              PFN_NUMBER PageFrameNumber,
+                              BOOLEAN Writable);
+            XTAPI VOID SetPteCaching(PHARDWARE_PTE PtePointer,
+                                     BOOLEAN CacheDisable,
+                                     BOOLEAN WriteThrough);
    };
 }

-#endif /* __XTOSKRNL_MM_I686_PAGEMAP_HH */
+#endif /* __XTOSKRNL_MM_PAGEMAP_HH */
--- a/xtoskrnl/includes/mm/i686/paging.hh
+++ b/xtoskrnl/includes/mm/i686/paging.hh
@@ -1,74 +0,0 @@
-/**
- * PROJECT:         ExectOS
- * COPYRIGHT:       See COPYING.md in the top level directory
- * FILE:            xtoskrnl/includes/mm/i686/paging.hh
- * DESCRIPTION:     Low level page management support for i686
- * DEVELOPERS:      Aiken Harris <harraiken91@gmail.com>
- */
-
-#ifndef __XTOSKRNL_MM_I686_PAGING_HH
-#define __XTOSKRNL_MM_I686_PAGING_HH
-
-#include <xtos.hh>
-
-
-/* Memory Manager */
-namespace MM
-{
-    class Paging
-    {
-        private:
-            STATIC PPAGEMAP PmlRoutines;
-
-        public:
-            STATIC XTAPI PMMPTE AdvancePte(IN PMMPTE Pte,
-                                           IN LONG Count);
-            STATIC XTAPI VOID ClearPte(IN PMMPTE PtePointer);
-            STATIC XTAPI VOID FlushTlb(VOID);
-            STATIC XTAPI ULONG_PTR GetNextEntry(IN PMMPTE Pte);
-            STATIC XTAPI PMMPTE GetNextPte(IN PMMPTE Pte);
-            STATIC XTAPI BOOLEAN GetOneEntry(IN PMMPTE Pte);
-            STATIC XTAPI PFN_NUMBER GetPageFrameNumber(IN PMMPTE Pte);
-            STATIC XTAPI PMMPDE GetPdeAddress(IN PVOID Address);
-            STATIC XTAPI PVOID GetPdeVirtualAddress(IN PMMPDE PdePointer);
-            STATIC XTAPI PMMPPE GetPpeAddress(IN PVOID Address);
-            STATIC XTAPI PVOID GetPpeVirtualAddress(IN PMMPPE PpePointer);
-            STATIC XTAPI ULONG_PTR GetPte(IN PMMPTE PtePointer);
-            STATIC XTAPI PMMPTE GetPteAddress(IN PVOID Address);
-            STATIC XTAPI LONG GetPteDistance(PMMPTE EndPte,
-                                             PMMPTE StartPte);
-            STATIC XTAPI ULONG GetPteSize(VOID);
-            STATIC XTAPI ULONG GetPteSoftwareProtection(IN PMMPTE PtePointer);
-            STATIC XTAPI ULONG GetPteSoftwarePrototype(IN PMMPTE PtePointer);
-            STATIC XTAPI ULONG GetPteSoftwareTransition(IN PMMPTE PtePointer);
-            STATIC XTAPI PVOID GetPteVirtualAddress(IN PMMPTE PtePointer);
-            STATIC XTAPI BOOLEAN GetXpaStatus(VOID);
-            STATIC XTAPI VOID InitializePageMapSupport(VOID);
-            STATIC XTAPI BOOLEAN PteValid(IN PMMPTE PtePointer);
-            STATIC XTAPI VOID SetNextEntry(IN PMMPTE Pte,
-                                           IN ULONG_PTR Value);
-            STATIC XTAPI VOID SetOneEntry(IN PMMPTE Pte,
-                                          IN BOOLEAN Value);
-            STATIC XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                                     IN PFN_NUMBER PageFrameNumber,
-                                     IN ULONG_PTR AttributesMask);
-            STATIC XTAPI VOID SetPte(IN PMMPTE PtePointer,
-                                     IN ULONG_PTR Attributes);
-            STATIC XTAPI VOID SetPteCaching(IN PMMPTE PtePointer,
-                                            IN BOOLEAN CacheDisable,
-                                            IN BOOLEAN WriteThrough);
-            STATIC XTAPI VOID WritePte(IN PMMPTE Pte,
-                                       IN MMPTE Value);
-            STATIC XTAPI VOID TransitionPte(IN PMMPTE PointerPte,
-                                            IN ULONG_PTR Protection);
-            STATIC XTFASTCALL VOID ZeroPages(IN PVOID Address,
-                                             IN ULONG Size);
-
-        private:
-            STATIC XTAPI BOOLEAN GetExtendedPhysicalAddressingStatus(VOID);
-            STATIC XTAPI PPAGEMAP GetPageMapBasicRoutines(VOID);
-            STATIC XTAPI PPAGEMAP GetPageMapXpaRoutines(VOID);
-    };
-}
-
-#endif /* __XTOSKRNL_MM_I686_PAGING_HH */
--- a/Show More
+++ b/Show More