Merge branch 'feat_memory_manager' into 'develop_sa'

Finish inital draft of Memory Manager

See merge request teachos/kernel!3

26 files changed, 1265 insertions, 57 deletions

diff --git a/arch/x86_64/src/boot/boot.s b/arch/x86_64/src/boot/boot.s
index 7b4e193..8d27ea1 100644
--- a/arch/x86_64/src/boot/boot.s
+++ b/arch/x86_64/src/boot/boot.s
@@ -7,38 +7,38 @@
  * Uninitialized data for the bootstrapping process.
  */
 .section .boot_bss, "aw", @nobits
+
+/**
+ * Reserve some space for the Multiboot 2 information pointer.
+ */
+.global multiboot_information_pointer
+multiboot_information_pointer: .skip 4
+
+/**
+ * Align page maps to 4 KiB or the assembler code, will cause crashes when attempting to enable paging.
+ */
 .align 4096
 
 /**
- * Reserve space for the page maps we are going to used during startup.
+ * Reserve space for the page maps we are going to use during startup.
  *
  * Note: We are going to use large pages to make the initial mapping code
  * simpler.
  *
  * We need:
  *   - A single PML 4 (since we will only use 4-level paging)
- *   - 2 PML 3s (since we need to map high (-2GiB) and low (1+MiB) memory)
- *   - 2 PML 2s (since we need to map high (-2GiB) and low (1+MiB) memory)
+ *   - 1 PML 3
+ *   - 1 PML 2
  */
 
 .global page_map_level_4
 page_map_level_4: .skip 512 * 8
 
-.global page_map_level_3_low
-page_map_level_3_low: .skip 512 * 8
-.global page_map_level_3_high
-page_map_level_3_high: .skip 512 * 8
-
-.global page_map_level_2_low
-page_map_level_2_low: .skip 512 * 8
-.global page_map_level_2_high
-page_map_level_2_high: .skip 512 * 8
+.global page_map_level_3
+page_map_level_3: .skip 512 * 8
 
-/**
- * Reserve some space for the Multiboot 2 information pointer.
- */
-.global multiboot_information_pointer
-multiboot_information_pointer: .skip 4
+.global page_map_level_2
+page_map_level_2: .skip 512 * 8
 
 /**
  * Stack space for the bootstrapping process.
@@ -86,6 +86,7 @@ global_descriptor_table_pointer:
  * We are going to print some messages in case we panic during boot, so we are
  * going to store them here as well
  */
+.global message_prefix_panic
 message_prefix_panic:
 .string "TeachOS Panic: "
 message_not_loaded_by_multiboot2:
@@ -113,6 +114,12 @@ vga_buffer_pointer: .long 0xb8000
 .align 16
 .code32
 
+.global halt
+halt:
+1:
+    hlt
+    jmp 1b
+
 /**
  * Print a given panic message and then halt the machine.
  *
@@ -133,7 +140,7 @@ _panic:
     call _print
     add $8, %esp
 
-    hlt
+    call halt
 
 /**
  * Print a message via the VGA buffer.
@@ -193,7 +200,7 @@ _start:
     lgdt (global_descriptor_table_pointer)
     jmp $global_descriptor_table_code,$_transition_to_long_mode
 
-    hlt
+    call halt
 
 /**
  * Assert that the CPU supports going into long mode.
@@ -306,31 +313,23 @@ enable_sse:
  *
  * We map all physical memory we were loaded in plus one additional page. The
  * mapping is done in terms of huge pages (2 MiB per page) to save on required
- * page map entries. Note that we also map memory both in the low and high
- * virtual address ranges, giving us two ways of accessing it. We need to do
- * this, because the bootstrapping code lives in low memory, while the rest of
- * the kernel will reside on the high end.
+ * page map entries.
  */
 prepare_page_maps:
-    /* Add an entry to the PML4, pointing to the low PML3 */
-    mov $page_map_level_3_low, %eax
-    or $0x3, %eax
-    mov %eax, (page_map_level_4 + ((0x0000000000100000 >> 39) & 0x1ff) * 8)
-
-    /* Add an entry to the PML4, pointing to the high PML3 */
-    mov $page_map_level_3_high, %eax
-    or $0x3, %eax
-    mov %eax, (page_map_level_4 + ((0xffffffff80100000 >> 39) & 0x1ff) * 8)
+    /* Map the P4 table recursively */
+    mov $page_map_level_4, %eax
+    or $0b11, %eax /* Write present + writable flags into eax register */
+    mov %eax, (page_map_level_4 + 511 * 8)
 
-    /* Add an entry to the low PML3, pointing to the low PML2 */
-    mov $page_map_level_2_low, %eax
+    /* Add an entry to the PML4, pointing to the PML3 */
+    mov $page_map_level_3, %eax
     or $0x3, %eax
-    mov %eax, (page_map_level_3_low + ((0x0000000000100000 >> 30) & 0x1ff) * 8)
+    mov %eax, (page_map_level_4 + ((0x0000000000100000 >> 39) & 0x1ff) * 8)
 
-    /* Add an entry to the high PML3, pointing to the high PML2 */
-    mov $page_map_level_2_high, %eax
+    /* Add an entry to the PML3, pointing to the PML2 */
+    mov $page_map_level_2, %eax
     or $0x3, %eax
-    mov %eax, (page_map_level_3_high + ((0xffffffff80100000 >> 30) & 0x1ff) * 8)
+    mov %eax, (page_map_level_3 + ((0x0000000000100000 >> 30) & 0x1ff) * 8)
 
     xor %ecx, %ecx
 
@@ -342,8 +341,7 @@ prepare_page_maps:
     mov $(1 << 21), %eax
     mul %ecx
     or $((1 << 0) | (1 << 1) | (1 << 7)), %eax
-    mov %eax, page_map_level_2_low(,%ecx,8)
-    mov %eax, page_map_level_2_high(,%ecx,8)
+    mov %eax, page_map_level_2(,%ecx,8)
 
     inc %ecx
     cmp %esi, %ecx
@@ -367,4 +365,4 @@ _transition_to_long_mode:
     call _init
 
     call kernel_main
-    hlt
+    call halt
diff --git a/arch/x86_64/src/exception_handling/abort.cpp b/arch/x86_64/src/exception_handling/abort.cpp
new file mode 100644
index 0000000..e12e4cb
--- /dev/null
+++ b/arch/x86_64/src/exception_handling/abort.cpp
@@ -0,0 +1,15 @@
+#include "arch/exception_handling/panic.hpp"
+
+#include <cstdlib>
+
+namespace teachos::arch::exception_handling
+{
+  /**
+   * @brief Override for the newlib abort function.
+   *
+   * @note newlib defines @p ::abort as a weak symbol, thus allowing implementations to override it by simply providing
+   * a matching implementation. Since the default implemenatation calls a number of functions the kernel does not
+   * currently implement, @p ::abort gets overridden to simply panic.
+   */
+  extern "C" auto abort() -> void { panic("Terminate was called, possibly due to an unhandled exception"); }
+}  // namespace teachos::arch::exception_handling
diff --git a/arch/x86_64/src/exception_handling/assert.cpp b/arch/x86_64/src/exception_handling/assert.cpp
new file mode 100644
index 0000000..b2963de
--- /dev/null
+++ b/arch/x86_64/src/exception_handling/assert.cpp
@@ -0,0 +1,15 @@
+#include "arch/exception_handling/assert.hpp"
+
+#include "arch/exception_handling/panic.hpp"
+
+namespace teachos::arch::exception_handling
+{
+  auto assert(bool condition, char const * message) -> void
+  {
+    if (condition)
+    {
+      return;
+    }
+    panic("Assertion Violation: ", message);
+  }
+}  // namespace teachos::arch::exception_handling
diff --git a/arch/x86_64/src/exception_handling/panic.cpp b/arch/x86_64/src/exception_handling/panic.cpp
new file mode 100644
index 0000000..8e3802a
--- /dev/null
+++ b/arch/x86_64/src/exception_handling/panic.cpp
@@ -0,0 +1,22 @@
+#include "arch/exception_handling/panic.hpp"
+
+#include "arch/kernel/halt.hpp"
+#include "arch/video/vga/text.hpp"
+
+namespace teachos::arch::exception_handling
+{
+  extern "C" char const message_prefix_panic[];
+
+  auto panic(char const * reason) -> void { panic(message_prefix_panic, reason); }
+
+  auto panic(char const * prefix, char const * reason) -> void
+  {
+    using video::vga::text::common_attributes::white_on_red;
+
+    video::vga::text::newline();
+    video::vga::text::write(prefix, white_on_red);
+    video::vga::text::write(reason, white_on_red);
+
+    kernel::halt();
+  };
+}  // namespace teachos::arch::exception_handling
diff --git a/arch/x86_64/src/exception_handling/pure_virtual.cpp b/arch/x86_64/src/exception_handling/pure_virtual.cpp
new file mode 100644
index 0000000..67772f7
--- /dev/null
+++ b/arch/x86_64/src/exception_handling/pure_virtual.cpp
@@ -0,0 +1,6 @@
+#include "arch/exception_handling/panic.hpp"
+
+extern "C" auto __cxa_pure_virtual() -> void
+{
+  teachos::arch::exception_handling::panic("Runtime", "Tried to call a pure virtual function!");
+}
diff --git a/arch/x86_64/src/kernel/main.cpp b/arch/x86_64/src/kernel/main.cpp
index 0e90264..681f960 100644
--- a/arch/x86_64/src/kernel/main.cpp
+++ b/arch/x86_64/src/kernel/main.cpp
@@ -1,15 +1,71 @@
 #include "arch/kernel/main.hpp"
 
+#include "arch/memory/heap/bump_allocator.hpp"
+#include "arch/memory/heap/concept.hpp"
+#include "arch/memory/heap/linked_list_allocator.hpp"
+#include "arch/memory/main.hpp"
+#include "arch/memory/multiboot/reader.hpp"
 #include "arch/video/vga/text.hpp"
 
 namespace teachos::arch::kernel
 {
+  auto stack_overflow_test(int count) -> int
+  {
+    int test[5000] = {};
+    if (test[0] == 0xFFFF)
+    {
+      return count;
+    }
+    count = stack_overflow_test(count);
+    return count++;
+  }
+
+  auto heap_test() -> void
+  {
+    memory::heap::linked_list_allocator heap_allocator{memory::heap::HEAP_START,
+                                                       memory::heap::HEAP_START + memory::heap::HEAP_SIZE};
+    auto test = heap_allocator.allocate(1024);
+    auto test2 = new (test) memory::multiboot::memory_information{};
+    auto test3 = new (static_cast<void *>(static_cast<memory::multiboot::memory_information *>(test) + 1))
+        memory::multiboot::memory_information{};
+    auto test4 = *test2;
+    auto test5 = *test3;
+    test4.kernel_end = 5000;
+    test5.kernel_end = 3000;
+    auto test6 = test4.kernel_end;
+    auto test7 = test5.kernel_end;
+    auto test8 = memory::multiboot::read_multiboot2();
+    if (test6 && test7 && test8.kernel_end)
+    {
+      video::vga::text::write("Heap test successful", video::vga::text::common_attributes::green_on_black);
+    }
+    test2->kernel_end = 2000;
+    test2->kernel_start = 1000;
+    test2->multiboot_start = 2000;
+    heap_allocator.deallocate(test, 1024);
+
+    auto test9 = heap_allocator.allocate(1024);
+    auto test10 = heap_allocator.allocate(1024);
+    auto test11 = heap_allocator.allocate(1024);
+    heap_allocator.deallocate(test9, 1024);
+    auto test12 = heap_allocator.allocate(1024);
+    auto test13 = heap_allocator.allocate(1024);
+    heap_allocator.deallocate(test11, 1024);
+    heap_allocator.deallocate(test10, 1024);
+    heap_allocator.deallocate(test13, 1024);
+    heap_allocator.deallocate(test12, 1024);
+  }
+
   auto main() -> void
   {
-    using namespace video::vga;
+    video::vga::text::clear();
+    video::vga::text::cursor(false);
+    video::vga::text::write("TeachOS is starting up...", video::vga::text::common_attributes::green_on_black);
+    video::vga::text::newline();
+
+    memory::initialize_memory_management();
 
-    text::clear();
-    text::cursor(false);
-    text::write("TeachOS is starting up...", text::common_attributes::green_on_black);
+    // stack_overflow_test(0);
+    heap_test();
   }
 }  // namespace teachos::arch::kernel
diff --git a/arch/x86_64/src/memory/allocator/area_frame_allocator.cpp b/arch/x86_64/src/memory/allocator/area_frame_allocator.cpp
new file mode 100644
index 0000000..cb4fefa
--- /dev/null
+++ b/arch/x86_64/src/memory/allocator/area_frame_allocator.cpp
@@ -0,0 +1,85 @@
+#include "arch/memory/allocator/area_frame_allocator.hpp"
+
+#include "arch/exception_handling/assert.hpp"
+
+#include <algorithm>
+#include <array>
+#include <ranges>
+
+namespace teachos::arch::memory::allocator
+{
+  area_frame_allocator::area_frame_allocator(multiboot::memory_information const & mem_info)
+      : next_free_frame(0U)
+      , current_area(std::nullopt)
+      , memory_areas(mem_info.areas)
+      , kernel_start(physical_frame::containing_address(mem_info.kernel_start))
+      , kernel_end(physical_frame::containing_address(mem_info.kernel_end))
+      , multiboot_start(physical_frame::containing_address(mem_info.multiboot_start))
+      , multiboot_end(physical_frame::containing_address(mem_info.multiboot_end))
+  {
+    choose_next_area();
+  }
+
+  auto area_frame_allocator::choose_next_area() -> void
+  {
+    current_area = std::nullopt;
+    auto next_area_with_free_frames = memory_areas | std::views::filter([this](auto const & area) {
+                                        auto address = area.base_address + area.area_length - 1;
+                                        return physical_frame::containing_address(address) >= next_free_frame;
+                                      });
+
+    auto const lowest_area_with_free_frames = std::ranges::min_element(
+        next_area_with_free_frames, [](auto const & a, auto const & b) { return a.base_address < b.base_address; });
+
+    if (lowest_area_with_free_frames != next_area_with_free_frames.end())
+    {
+      current_area = *lowest_area_with_free_frames;
+      // Update the `next_free_frame` according to the new memory area
+      auto const start_frame = physical_frame::containing_address(current_area.value().base_address);
+      if (next_free_frame < start_frame)
+      {
+        next_free_frame = start_frame;
+      }
+    }
+  }
+
+  auto area_frame_allocator::allocate_frame() -> std::optional<physical_frame>
+  {
+    // Only try to allocate memory if current_area is not null, because
+    // the current_area is null if there is no more available memory.
+    if (!current_area.has_value())
+    {
+      return std::nullopt;
+    }
+
+    auto const address = current_area.value().base_address + current_area.value().area_length - 1;
+    physical_frame current_area_last_frame = physical_frame::containing_address(address);
+
+    if (next_free_frame > current_area_last_frame)
+    {
+      // All frames of current area are used, switch to next area.
+      choose_next_area();
+    }
+    else if (next_free_frame >= kernel_start && next_free_frame <= kernel_end)
+    {
+      // `physical_frame` is used by the kernel or multiboot information structure.
+      next_free_frame = allocator::physical_frame{kernel_end.frame_number + 1};
+    }
+    else if (next_free_frame >= multiboot_start && next_free_frame <= multiboot_end)
+    {
+      // `physical_frame` is used by the kernel or multiboot information structure.
+      next_free_frame = allocator::physical_frame{multiboot_end.frame_number + 1};
+    }
+    else
+    {
+      // Frame is unused, increment `next_free_frame` and return it.
+      next_free_frame.frame_number += 1;
+      return next_free_frame;
+    }
+
+    // `physical_frame` was not valid, try it again with the updated `next_free_frame`.
+    return allocate_frame();
+  }
+
+  auto area_frame_allocator::deallocate_frame(physical_frame const & physical_frame) -> void { (void)physical_frame; }
+}  // namespace teachos::arch::memory::allocator
diff --git a/arch/x86_64/src/memory/allocator/physical_frame.cpp b/arch/x86_64/src/memory/allocator/physical_frame.cpp
new file mode 100644
index 0000000..ec387a1
--- /dev/null
+++ b/arch/x86_64/src/memory/allocator/physical_frame.cpp
@@ -0,0 +1,24 @@
+#include "arch/memory/allocator/physical_frame.hpp"
+
+namespace teachos::arch::memory::allocator
+{
+  auto physical_frame::containing_address(physical_address address) -> physical_frame
+  {
+    return physical_frame{address / PAGE_FRAME_SIZE};
+  }
+
+  auto physical_frame::start_address() const -> physical_address { return frame_number * PAGE_FRAME_SIZE; }
+
+  auto physical_frame::operator++(int) -> physical_frame
+  {
+    physical_frame const old_value = *this;
+    ++frame_number;
+    return old_value;
+  }
+
+  auto physical_frame::operator++() -> physical_frame &
+  {
+    ++frame_number;
+    return *this;
+  }
+}  // namespace teachos::arch::memory::allocator
diff --git a/arch/x86_64/src/memory/allocator/tiny_frame_allocator.cpp b/arch/x86_64/src/memory/allocator/tiny_frame_allocator.cpp
new file mode 100644
index 0000000..3cdf9c7
--- /dev/null
+++ b/arch/x86_64/src/memory/allocator/tiny_frame_allocator.cpp
@@ -0,0 +1,34 @@
+#include "arch/memory/allocator/tiny_frame_allocator.hpp"
+
+#include "arch/exception_handling/panic.hpp"
+
+namespace teachos::arch::memory::allocator
+{
+  auto tiny_frame_allocator::allocate_frame() -> std::optional<physical_frame>
+  {
+    for (auto & frame_option : frames)
+    {
+      if (frame_option.has_value())
+      {
+        auto value = frame_option;
+        frame_option.reset();
+        return value;
+      }
+    }
+    return std::nullopt;
+  }
+
+  auto tiny_frame_allocator::deallocate_frame(physical_frame const & physical_frame) -> void
+  {
+    for (auto & frame_option : frames)
+    {
+      if (!frame_option.has_value())
+      {
+        frame_option.emplace(physical_frame);
+        return;
+      }
+    }
+    exception_handling::panic(
+        "[Tiny Frame Allocator] Attempted to deallocate more than the 3 frames, that can be held");
+  }
+}  // namespace teachos::arch::memory::allocator
diff --git a/arch/x86_64/src/memory/cpu/control_register.cpp b/arch/x86_64/src/memory/cpu/control_register.cpp
new file mode 100644
index 0000000..298874f
--- /dev/null
+++ b/arch/x86_64/src/memory/cpu/control_register.cpp
@@ -0,0 +1,74 @@
+#include "arch/memory/cpu/control_register.hpp"
+
+#include "arch/exception_handling/assert.hpp"
+
+#include <type_traits>
+
+namespace teachos::arch::memory::cpu
+{
+  auto read_control_register(control_register cr) -> uint64_t
+  {
+    uint64_t current_value;
+    switch (cr)
+    {
+      case control_register::CR0:
+        asm volatile("mov %%cr0, %[output]" : [output] "=r"(current_value));
+        break;
+      case control_register::CR2:
+        asm volatile("mov %%cr2, %[output]" : [output] "=r"(current_value));
+        break;
+      case control_register::CR3:
+        asm volatile("mov %%cr3, %[output]" : [output] "=r"(current_value));
+        break;
+      case control_register::CR4:
+        asm volatile("mov %%cr4, %[output]" : [output] "=r"(current_value));
+        break;
+      default:
+        exception_handling::assert(false,
+                                   "[Control Register] Attempted to read non-existent or reserved control register");
+        break;
+    }
+    return current_value;
+  }
+
+  auto write_control_register(control_register cr, uint64_t new_value) -> void
+  {
+    switch (cr)
+    {
+      case control_register::CR0:
+        asm volatile("mov %[input], %%cr0"
+                     : /* no output from call */
+                     : [input] "r"(new_value)
+                     : "memory");
+        break;
+      case control_register::CR2:
+        asm volatile("mov %[input], %%cr2"
+                     : /* no output from call */
+                     : [input] "r"(new_value)
+                     : "memory");
+        break;
+      case control_register::CR3:
+        asm volatile("mov %[input], %%cr3"
+                     : /* no output from call */
+                     : [input] "r"(new_value)
+                     : "memory");
+        break;
+      case control_register::CR4:
+        asm volatile("mov %[input], %%cr4"
+                     : /* no output from call */
+                     : [input] "r"(new_value)
+                     : "memory");
+        break;
+      default:
+        exception_handling::assert(false,
+                                   "[Control Register] Attempted to write non-existent or reserved control register");
+        break;
+    }
+  }
+
+  auto set_cr0_bit(cr0_flags flag) -> void
+  {
+    auto const cr0 = read_control_register(control_register::CR0);
+    write_control_register(control_register::CR0, static_cast<std::underlying_type<cr0_flags>::type>(flag) | cr0);
+  }
+}  // namespace teachos::arch::memory::cpu
diff --git a/arch/x86_64/src/memory/cpu/msr.cpp b/arch/x86_64/src/memory/cpu/msr.cpp
new file mode 100644
index 0000000..b83f902
--- /dev/null
+++ b/arch/x86_64/src/memory/cpu/msr.cpp
@@ -0,0 +1,31 @@
+#include "arch/memory/cpu/msr.hpp"
+
+namespace teachos::arch::memory::cpu
+{
+  namespace
+  {
+    auto constexpr IA32_EFER_ADDRESS = 0xC0000080;
+  }
+
+  auto read_msr(uint32_t msr) -> uint64_t
+  {
+    uint32_t low, high;
+    asm volatile("rdmsr" : "=a"(low), "=d"(high) : "c"(msr));
+    return (static_cast<uint64_t>(high) << 32) | low;
+  }
+
+  auto write_msr(uint32_t msr, uint64_t value) -> void
+  {
+    uint32_t low = value & 0xFFFFFFFF;
+    uint32_t high = value >> 32;
+    asm volatile("wrmsr"
+                 : /* no output from call */
+                 : "c"(msr), "a"(low), "d"(high));
+  }
+
+  auto set_efer_bit(efer_flags flag) -> void
+  {
+    auto const efer = read_msr(IA32_EFER_ADDRESS);
+    write_msr(IA32_EFER_ADDRESS, static_cast<std::underlying_type<efer_flags>::type>(flag) | efer);
+  }
+}  // namespace teachos::arch::memory::cpu
diff --git a/arch/x86_64/src/memory/cpu/tlb.cpp b/arch/x86_64/src/memory/cpu/tlb.cpp
new file mode 100644
index 0000000..591d9fc
--- /dev/null
+++ b/arch/x86_64/src/memory/cpu/tlb.cpp
@@ -0,0 +1,16 @@
+#include "arch/memory/cpu/tlb.hpp"
+
+#include "arch/memory/cpu/control_register.hpp"
+
+namespace teachos::arch::memory::cpu
+{
+  auto tlb_flush(paging::virtual_address address) -> void
+  {
+    asm volatile("invlpg (%[input])" : /* no output from call */ : [input] "r"(address) : "memory");
+  }
+
+  auto tlb_flush_all() -> void
+  {
+    write_control_register(cpu::control_register::CR3, read_control_register(cpu::control_register::CR3));
+  }
+}  // namespace teachos::arch::memory::cpu
diff --git a/arch/x86_64/src/memory/heap/bump_allocator.cpp b/arch/x86_64/src/memory/heap/bump_allocator.cpp
new file mode 100644
index 0000000..bbf2021
--- /dev/null
+++ b/arch/x86_64/src/memory/heap/bump_allocator.cpp
@@ -0,0 +1,52 @@
+#include "arch/memory/heap/bump_allocator.hpp"
+
+#include "arch/exception_handling/assert.hpp"
+
+#include <limits>
+#include <type_traits>
+
+namespace teachos::arch::memory::heap
+{
+  namespace
+  {
+    template<typename T>
+    auto saturating_add(T x, T y) -> T
+      requires std::is_unsigned_v<T>
+    {
+      if (x > std::numeric_limits<T>::max() - y)
+      {
+        return std::numeric_limits<T>::max();
+      }
+      T result = x + y;
+      return result;
+    }
+  }  // namespace
+
+  auto bump_allocator::allocate(std::size_t size) -> void *
+  {
+    // Repeat allocation until it succeeds, has to be done, because another allocator could overtake it at any time
+    // causing the value to differ and the calculation to have to be redone.
+    for (;;)
+    {
+      auto alloc_start = next.load(std::memory_order::relaxed);
+      auto const alloc_end = saturating_add(alloc_start, size);
+      arch::exception_handling::assert(alloc_end <= heap_end, "[Heap Allocator] Out of memory");
+      // Check if the atomic value is still the one initally loaded, if it isn't we have been overtaken by another
+      // thread and need to redo the calculation. Spurious failure by weak can be ignored, because the whole allocation
+      // is wrapped in an infinite for loop so a failure that wasn't actually one will simply be retried until it works.
+      auto const updated = next.compare_exchange_weak(alloc_start, alloc_end, std::memory_order::relaxed);
+      if (updated)
+      {
+        return reinterpret_cast<void *>(alloc_start);
+      }
+    }
+  }
+
+  auto bump_allocator::deallocate(void * pointer, std::size_t size) -> void
+  {
+    if (pointer || size)
+    {
+    }
+  }
+
+}  // namespace teachos::arch::memory::heap
diff --git a/arch/x86_64/src/memory/heap/linked_list_allocator.cpp b/arch/x86_64/src/memory/heap/linked_list_allocator.cpp
new file mode 100644
index 0000000..e5bae21
--- /dev/null
+++ b/arch/x86_64/src/memory/heap/linked_list_allocator.cpp
@@ -0,0 +1,168 @@
+#include "arch/memory/heap/linked_list_allocator.hpp"
+
+#include "arch/exception_handling/assert.hpp"
+#include "arch/exception_handling/panic.hpp"
+
+namespace teachos::arch::memory::heap
+{
+  linked_list_allocator::linked_list_allocator(std::size_t heap_start, std::size_t heap_end)
+      : heap_start(heap_start)
+      , heap_end(heap_end)
+      , first(nullptr)
+      , mutex{shared::mutex{}}
+  {
+    auto const heap_size = heap_end - heap_start;
+    exception_handling::assert(
+        heap_size > min_allocatable_size(),
+        "[Linked List Allocator] Total heap size can not be smaller than minimum of 16 bytes to hold "
+        "atleast one memory hole entry");
+    first = new (reinterpret_cast<void *>(heap_start)) memory_block(heap_size, nullptr);
+  }
+
+  auto linked_list_allocator::allocate(std::size_t size) -> void *
+  {
+    exception_handling::assert(size > min_allocatable_size(),
+                               "[Linked List Allocator] Allocated memory cannot be smaller than 16 bytes");
+    mutex.lock();
+
+    memory_block * previous = nullptr;
+    auto current = first;
+
+    while (current != nullptr)
+    {
+      if (current->size == size)
+      {
+        auto const memory_address = remove_free_memory_block(previous, current);
+        mutex.unlock();
+        return memory_address;
+      }
+      else if (current->size >= size + min_allocatable_size())
+      {
+        auto const memory_address = split_free_memory_block(previous, current, size);
+        mutex.unlock();
+        return memory_address;
+      }
+
+      previous = current;
+      current = current->next;
+    }
+
+    exception_handling::panic("[Linked List Allocator] Out of memory");
+  }
+
+  auto linked_list_allocator::deallocate(void * pointer, std::size_t size) -> void
+  {
+    exception_handling::assert(size > min_allocatable_size(),
+                               "[Linked List Allocator] Allocated memory cannot be smaller than 16 bytes");
+    mutex.lock();
+
+    auto const start_address = reinterpret_cast<std::size_t>(pointer);
+    auto const end_address = start_address + size;
+
+    memory_block * previous = nullptr;
+    auto current = first;
+
+    while (current != nullptr)
+    {
+      // Current address of the free memory block now points to an address that is after our block to deallocate in heap
+      // memory space.
+      if (reinterpret_cast<std::size_t>(current) >= end_address)
+      {
+        break;
+      }
+
+      previous = current;
+      current = current->next;
+    }
+
+    coalesce_free_memory_block(previous, current, pointer, size);
+    mutex.unlock();
+  }
+
+  auto linked_list_allocator::remove_free_memory_block(memory_block * previous_block,
+                                                       memory_block * current_block) -> void *
+  {
+    return replace_free_memory_block(previous_block, current_block, current_block->next);
+  }
+
+  auto linked_list_allocator::split_free_memory_block(memory_block * previous_block, memory_block * current_block,
+                                                      std::size_t size) -> void *
+  {
+    auto const end_address = reinterpret_cast<std::size_t>(current_block) + size;
+    auto const new_block =
+        new (reinterpret_cast<void *>(end_address)) memory_block(current_block->size - size, current_block->next);
+    return replace_free_memory_block(previous_block, current_block, new_block);
+  }
+
+  auto linked_list_allocator::replace_free_memory_block(memory_block * previous_block, memory_block * current_block,
+                                                        memory_block * new_block) -> void *
+  {
+    auto const start_address = reinterpret_cast<std::size_t>(current_block);
+    // If we want to allocate into the first block that is before any other free block, then there exists no previous
+    // free block (nullptr). Therefore we have to overwrite the first block instead of overwriting its next value.
+    if (previous_block == nullptr)
+    {
+      first = new_block;
+    }
+    else
+    {
+      previous_block->next = new_block;
+    }
+    current_block->~memory_block();
+    return reinterpret_cast<void *>(start_address);
+  }
+
+  auto linked_list_allocator::coalesce_free_memory_block(memory_block * previous_block, memory_block * current_block,
+                                                         void * pointer, std::size_t size) -> void
+  {
+    auto const start_address = reinterpret_cast<std::size_t>(pointer);
+    auto const end_address = start_address + size;
+
+    // Inital values if there are no adjacent blocks either before or after, meaning we have to simply create a free
+    // memory block that is placed in between the previous and next block.
+    auto block_size = size;
+    auto next_block = current_block;
+
+    // If the block we want to deallocate is before another free block and we can therefore combine both into one.
+    // This is done by deleting the current free block and creating a new block at the start address of the block to
+    // deallocate with both the size of the block to deallcoate and the free block next to it.
+    if (end_address == reinterpret_cast<std::size_t>(current_block))
+    {
+      block_size += current_block->size;
+      next_block = current_block->next;
+      current_block->~memory_block();
+    }
+
+    // If the block we want to deallocate is behind another free block and we can therefore combine both into one.
+    // This is done by simply changin the size of the previous block to include the size of the block to deallocate.
+    // This is done, because the previous block might still be referencered by the next field of other memory blocks.
+    if (previous_block != nullptr &&
+        start_address == (reinterpret_cast<std::size_t>(previous_block) + previous_block->size))
+    {
+      block_size += previous_block->size;
+
+      previous_block->size = block_size;
+      previous_block->next = next_block;
+      return;
+    }
+
+    // Check if the block we want to deallocate is contained in the previous block, because if it is it can only mean
+    // that the block has already been deallocated and we therefore attempted a double free.
+    exception_handling::assert(previous_block == nullptr ||
+                                   start_address >=
+                                       (reinterpret_cast<std::size_t>(previous_block) + previous_block->size),
+                               "[Linked List Allocator] Attempted double free detected");
+
+    auto const new_block = new (pointer) memory_block(block_size, next_block);
+    // If we want to deallocate the first block that is before any other free block, then there exists no previous free
+    // block (nullptr). Therefore we have to overwrite the first block instead of overwriting its
+    // next value.
+    if (previous_block == nullptr)
+    {
+      first = new_block;
+      return;
+    }
+    previous_block->next = new_block;
+  }
+
+}  // namespace teachos::arch::memory::heap
diff --git a/arch/x86_64/src/memory/heap/memory_block.cpp b/arch/x86_64/src/memory/heap/memory_block.cpp
new file mode 100644
index 0000000..446cd96
--- /dev/null
+++ b/arch/x86_64/src/memory/heap/memory_block.cpp
@@ -0,0 +1,15 @@
+#include "arch/memory/heap/memory_block.hpp"
+
+#include <string.h>
+
+namespace teachos::arch::memory::heap
+{
+  memory_block::memory_block(std::size_t size, memory_block * next)
+  {
+    memset(static_cast<void *>(this), 0, size);
+    this->size = size;
+    this->next = next;
+  }
+
+  memory_block::~memory_block() { memset(static_cast<void *>(this), 0, sizeof(memory_block)); }
+}  // namespace teachos::arch::memory::heap
diff --git a/arch/x86_64/src/memory/main.cpp b/arch/x86_64/src/memory/main.cpp
new file mode 100644
index 0000000..b978319
--- /dev/null
+++ b/arch/x86_64/src/memory/main.cpp
@@ -0,0 +1,53 @@
+#include "arch/memory/main.hpp"
+
+#include "arch/exception_handling/assert.hpp"
+#include "arch/memory/allocator/area_frame_allocator.hpp"
+#include "arch/memory/cpu/control_register.hpp"
+#include "arch/memory/cpu/msr.hpp"
+#include "arch/memory/heap/concept.hpp"
+#include "arch/memory/paging/active_page_table.hpp"
+#include "arch/memory/paging/kernel_mapper.hpp"
+
+namespace teachos::arch::memory
+{
+  namespace
+  {
+    auto remap_heap(allocator::area_frame_allocator allocator, paging::active_page_table & active_table) -> void
+    {
+      auto const start_page = paging::virtual_page::containing_address(memory::heap::HEAP_START);
+      auto const end_page =
+          ++(paging::virtual_page::containing_address(memory::heap::HEAP_START + memory::heap::HEAP_SIZE - 1));
+      paging::page_container::iterator const begin{start_page};
+      paging::page_container::iterator const end{end_page};
+      paging::page_container const pages{begin, end};
+
+      for (auto const & page : pages)
+      {
+        active_table.map_page_to_next_free_frame(allocator, page, paging::entry::WRITABLE);
+      }
+    }
+  }  // namespace
+
+  auto initialize_memory_management() -> void
+  {
+    static bool has_been_called = false;
+    arch::exception_handling::assert(!has_been_called,
+                                     "[Initialization] Memory management has already been initialized");
+    has_been_called = true;
+
+    auto const memory_information = multiboot::read_multiboot2();
+    allocator::area_frame_allocator allocator(memory_information);
+
+    cpu::set_cr0_bit(memory::cpu::cr0_flags::WRITE_PROTECT);
+    cpu::set_efer_bit(memory::cpu::efer_flags::NXE);
+
+    paging::kernel_mapper kernel(allocator, memory_information);
+    auto & active_table = kernel.remap_kernel();
+    video::vga::text::write("Kernel remapping successful", video::vga::text::common_attributes::green_on_black);
+    video::vga::text::newline();
+
+    remap_heap(allocator, active_table);
+    video::vga::text::write("Heap remapping successful", video::vga::text::common_attributes::green_on_black);
+    video::vga::text::newline();
+  }
+}  // namespace teachos::arch::memory
diff --git a/arch/x86_64/src/memory/multiboot/elf_symbols_section.cpp b/arch/x86_64/src/memory/multiboot/elf_symbols_section.cpp
new file mode 100644
index 0000000..f5d126b
--- /dev/null
+++ b/arch/x86_64/src/memory/multiboot/elf_symbols_section.cpp
@@ -0,0 +1,13 @@
+#include "arch/memory/multiboot/elf_symbols_section.hpp"
+
+namespace teachos::arch::memory::multiboot
+{
+  auto elf_section_flags::contains_flags(std::bitset<64U> other) const -> bool { return (flags & other) == other; }
+
+  auto elf_section_header::is_null() const -> bool
+  {
+    return name_table_index == 0U && type == elf_section_type::INACTIVE && flags == elf_section_flags(0U) &&
+           physical_address == 0U && file_offset == 0U && additional_information == 0U && address_alignment == 0U &&
+           fixed_table_entry_size == 0U;
+  }
+}  // namespace teachos::arch::memory::multiboot
diff --git a/arch/x86_64/src/memory/multiboot/reader.cpp b/arch/x86_64/src/memory/multiboot/reader.cpp
new file mode 100644
index 0000000..2bf5b25
--- /dev/null
+++ b/arch/x86_64/src/memory/multiboot/reader.cpp
@@ -0,0 +1,131 @@
+#include "arch/memory/multiboot/reader.hpp"
+
+#include "arch/boot/pointers.hpp"
+#include "arch/exception_handling/assert.hpp"
+#include "arch/memory/multiboot/elf_symbols_section.hpp"
+#include "arch/memory/multiboot/info.hpp"
+
+#include <algorithm>
+#include <ranges>
+
+namespace teachos::arch::memory::multiboot
+{
+  namespace
+  {
+    template<typename T>
+      requires std::is_pointer<T>::value
+    auto align_to_8_byte_boundary(T ptr, uint32_t size) -> T
+    {
+      return reinterpret_cast<T>(reinterpret_cast<uint8_t *>(ptr) + ((size + 7) & ~7));
+    }
+
+    auto process_memory_map(memory_map_header * mminfo) -> memory_area_container
+    {
+      auto const expected_entry_size = mminfo->entry_size;
+      auto constexpr actual_entry_size = sizeof(memory_area);
+      exception_handling::assert(expected_entry_size == actual_entry_size,
+                                 "[Multiboot Reader] Unexpected memory area entry size");
+
+      auto const total_size = mminfo->info.size;
+      auto const total_entries_size = total_size - sizeof(memory_map_header) + actual_entry_size;
+      auto const number_of_entries = total_entries_size / actual_entry_size;
+
+      auto const begin = memory_area_container::iterator{&mminfo->entries};
+      auto const end = begin + number_of_entries;
+      return memory_area_container{begin, end};
+    }
+
+    auto process_elf_sections(elf_symbols_section_header * symbol, std::size_t & kernel_start,
+                              std::size_t & kernel_end) -> elf_section_header_container
+    {
+      auto const expected_entry_size = symbol->entry_size;
+      auto constexpr actual_entry_size = sizeof(elf_section_header);
+      exception_handling::assert(expected_entry_size == actual_entry_size,
+                                 "[Multiboot Reader] Unexpected elf section header entry size");
+
+      auto const expected_total_size = symbol->info.size;
+      auto const actual_total_entry_size = actual_entry_size * symbol->number_of_sections;
+      auto constexpr actual_total_section_size = sizeof(elf_symbols_section_header) - sizeof(uint32_t);
+      auto const actual_total_size = actual_total_entry_size + actual_total_section_size;
+      exception_handling::assert(expected_total_size == actual_total_size,
+                                 "[Multiboot Reader] Unexpected elf symbols section header total size");
+
+      auto const begin = elf_section_header_container::iterator{reinterpret_cast<elf_section_header *>(&symbol->end)};
+      auto const end = begin + symbol->number_of_sections;
+      exception_handling::assert(begin->is_null(),
+                                 "[Multiboot Reader] Elf symbols section not starting with SHT_NULL section");
+
+      elf_section_header_container sections{begin, end};
+
+      auto allocated_sections = sections | std::views::filter([](auto const & section) {
+                                  return section.flags.contains_flags(elf_section_flags::OCCUPIES_MEMORY);
+                                });
+
+      auto const elf_section_with_lowest_physical_address = std::ranges::min_element(
+          allocated_sections, [](auto const & a, auto const & b) { return a.physical_address < b.physical_address; });
+
+      auto const elf_section_with_highest_physical_address =
+          std::ranges::max_element(allocated_sections, [](auto const & a, auto const & b) {
+            auto a_physical_address_end = a.physical_address + a.section_size;
+            auto b_physical_address_end = b.physical_address + b.section_size;
+            return a_physical_address_end < b_physical_address_end;
+          });
+
+      auto const symbol_table_section_count = std::ranges::count_if(sections, [](auto const & section) {
+        return section.type == elf_section_type::DYNAMIC_SYMBOL_TABLE || section.type == elf_section_type::SYMBOL_TABLE;
+      });
+      auto const dynamic_section_count = std::ranges::count_if(
+          sections, [](auto const & section) { return section.type == elf_section_type::DYNAMIC; });
+
+      exception_handling::assert(
+          symbol_table_section_count == 1U,
+          "[Multiboot Reader] ELF Specifications allows only (1) symbol table section, but got more");
+      exception_handling::assert(
+          dynamic_section_count <= 1U,
+          "[Multiboot Reader] ELF Specifications allows only (1) or less dynamic sections, but got more");
+
+      auto const lowest_elf_section = *elf_section_with_lowest_physical_address;
+      kernel_start = lowest_elf_section.physical_address;
+
+      auto const highest_elf_section = *elf_section_with_highest_physical_address;
+      kernel_end = highest_elf_section.physical_address + highest_elf_section.section_size;
+
+      return sections;
+    }
+  }  // namespace
+
+  auto read_multiboot2() -> memory_information
+  {
+    memory_information mem_info{UINT64_MAX,
+                                0U,
+                                elf_section_header_container{},
+                                boot::multiboot_information_pointer,
+                                0U,
+                                memory_area_container{}};
+
+    auto const multiboot_information_pointer = reinterpret_cast<info_header *>(boot::multiboot_information_pointer);
+    auto const multiboot_tag = &multiboot_information_pointer->tags;
+    mem_info.multiboot_end = mem_info.multiboot_start + multiboot_information_pointer->total_size;
+
+    for (auto tag = multiboot_tag; tag->type != tag_type::END; tag = align_to_8_byte_boundary(tag, tag->size))
+    {
+      switch (tag->type)
+      {
+        case tag_type::ELF_SECTIONS: {
+          auto const symbol = reinterpret_cast<elf_symbols_section_header *>(tag);
+          mem_info.sections = process_elf_sections(symbol, mem_info.kernel_start, mem_info.kernel_end);
+          break;
+        }
+        case tag_type::MEMORY_MAP: {
+          auto const mminfo = reinterpret_cast<memory_map_header *>(tag);
+          mem_info.areas = process_memory_map(mminfo);
+          break;
+        }
+        default:
+          // All other cases are not important and can be ignored.
+          break;
+      }
+    }
+    return mem_info;
+  }
+}  // namespace teachos::arch::memory::multiboot
diff --git a/arch/x86_64/src/memory/paging/active_page_table.cpp b/arch/x86_64/src/memory/paging/active_page_table.cpp
new file mode 100644
index 0000000..0113869
--- /dev/null
+++ b/arch/x86_64/src/memory/paging/active_page_table.cpp
@@ -0,0 +1,98 @@
+#include "arch/memory/paging/active_page_table.hpp"
+
+namespace teachos::arch::memory::paging
+{
+  namespace
+  {
+    paging::virtual_address constexpr PAGE_TABLE_LEVEL_4_ADDRESS = 0xffffffff'fffff000;
+  }
+
+  auto active_page_table::create_or_get() -> active_page_table &
+  {
+    static page_table_handle active_handle{reinterpret_cast<page_table *>(PAGE_TABLE_LEVEL_4_ADDRESS),
+                                           page_table_handle::LEVEL4};
+    static active_page_table active_page{active_handle};
+    return active_page;
+  }
+
+  auto active_page_table::operator[](std::size_t index) -> entry & { return active_handle[index]; }
+
+  auto active_page_table::translate_address(virtual_address address) -> std::optional<allocator::physical_address>
+  {
+    auto const offset = address % allocator::PAGE_FRAME_SIZE;
+    auto const page = virtual_page::containing_address(address);
+    auto const frame = translate_page(page);
+
+    if (frame.has_value())
+    {
+      return frame.value().frame_number * allocator::PAGE_FRAME_SIZE + offset;
+    }
+
+    return std::nullopt;
+  }
+
+  auto active_page_table::translate_page(virtual_page page) -> std::optional<allocator::physical_frame>
+  {
+    auto current_handle = active_handle;
+
+    for (auto level = page_table_handle::LEVEL4; level != page_table_handle::LEVEL1; --level)
+    {
+      auto const next_handle = current_handle.next_table(page.get_level_index(level));
+      // If the next table method failed then it is highly likely that it was a huge page and we therefore have to
+      // parse the table differently. Therefore, we attempt to parse it using the method required by huge pages.
+      if (!next_handle.has_value())
+      {
+        return translate_huge_page(page);
+      }
+      current_handle = next_handle.value();
+    }
+
+    auto const level1_index = page.get_level_index(page_table_handle::LEVEL1);
+    auto const level1_entry = current_handle[level1_index];
+    return level1_entry.calculate_pointed_to_frame();
+  }
+
+  auto active_page_table::translate_huge_page(virtual_page page) -> std::optional<allocator::physical_frame>
+  {
+    auto current_handle = active_handle;
+    auto level3_handle = current_handle.next_table(page.get_level_index(page_table_handle::LEVEL4));
+
+    if (!level3_handle.has_value())
+    {
+      return std::nullopt;
+    }
+
+    auto const level3_entry = level3_handle.value()[page.get_level_index(page_table_handle::LEVEL3)];
+    auto const level3_frame = level3_entry.calculate_pointed_to_frame();
+    if (level3_frame.has_value() && level3_entry.contains_flags(entry::HUGE_PAGE))
+    {
+      exception_handling::assert(
+          level3_frame.value().frame_number % (PAGE_TABLE_ENTRY_COUNT * PAGE_TABLE_ENTRY_COUNT) == 0U,
+          "[Page Mapper] Physical address must be 1 GiB aligned");
+      return allocator::physical_frame{level3_frame.value().frame_number +
+                                       page.get_level_index(page_table_handle::LEVEL2) * PAGE_TABLE_ENTRY_COUNT +
+                                       page.get_level_index(page_table_handle::LEVEL1)};
+    }
+
+    auto level2_handle = level3_handle.value().next_table(page.get_level_index(page_table_handle::LEVEL3));
+    if (level2_handle.has_value())
+    {
+      auto const level2_entry = level2_handle.value()[page.get_level_index(page_table_handle::LEVEL2)];
+      auto const level2_frame = level2_entry.calculate_pointed_to_frame();
+      if (level2_frame.has_value() && level2_entry.contains_flags(entry::HUGE_PAGE))
+      {
+        exception_handling::assert(level2_frame.value().frame_number % PAGE_TABLE_ENTRY_COUNT == 0U,
+                                   "[Page Mapper] Physical address must be 2 MiB aligned");
+        return allocator::physical_frame{level2_frame.value().frame_number +
+                                         page.get_level_index(page_table_handle::LEVEL1)};
+      }
+    }
+    return std::nullopt;
+  }
+
+  active_page_table::active_page_table(page_table_handle active_handle)
+      : active_handle(active_handle)
+  {
+    // Nothing to do
+  }
+}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/src/memory/paging/inactive_page_table.cpp b/arch/x86_64/src/memory/paging/inactive_page_table.cpp
new file mode 100644
index 0000000..4e0610e
--- /dev/null
+++ b/arch/x86_64/src/memory/paging/inactive_page_table.cpp
@@ -0,0 +1,20 @@
+#include "arch/memory/paging/inactive_page_table.hpp"
+
+namespace teachos::arch::memory::paging
+{
+  inactive_page_table::inactive_page_table(allocator::physical_frame frame)
+      : page_table_level_4_frame{frame}
+  {
+    // Nothing to do
+  }
+
+  inactive_page_table::inactive_page_table(allocator::physical_frame frame, active_page_table & active_page_table,
+                                           temporary_page & temporary_page)
+      : page_table_level_4_frame{frame}
+  {
+    auto table = temporary_page.map_table_frame(page_table_level_4_frame, active_page_table);
+    table.zero_entries();
+    table[511].set_entry(page_table_level_4_frame, entry::PRESENT | entry::WRITABLE);
+    temporary_page.unmap_page(active_page_table);
+  }
+}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/src/memory/paging/page_entry.cpp b/arch/x86_64/src/memory/paging/page_entry.cpp
new file mode 100644
index 0000000..5aa0982
--- /dev/null
+++ b/arch/x86_64/src/memory/paging/page_entry.cpp
@@ -0,0 +1,58 @@
+#include "arch/memory/paging/page_entry.hpp"
+
+#include "arch/exception_handling/assert.hpp"
+
+namespace teachos::arch::memory::paging
+{
+  namespace
+  {
+    std::size_t constexpr PHYSICAL_ADDRESS_MASK = 0x000fffff'fffff000;
+  }  // namespace
+
+  entry::entry(uint64_t flags)
+      : flags(flags)
+  {
+    // Nothing to do.
+  }
+
+  entry::entry(multiboot::elf_section_flags elf_flags)
+  {
+    if (elf_flags.contains_flags(multiboot::elf_section_flags::OCCUPIES_MEMORY))
+    {
+      flags |= entry::PRESENT;
+    }
+    if (elf_flags.contains_flags(multiboot::elf_section_flags::WRITABLE))
+    {
+      flags |= entry::WRITABLE;
+    }
+    if (!elf_flags.contains_flags(multiboot::elf_section_flags::EXECUTABLE_CODE))
+    {
+      flags |= entry::EXECUTING_CODE_FORBIDDEN;
+    }
+  }
+
+  auto entry::is_unused() const -> bool { return flags == 0U; }
+
+  auto entry::set_unused() -> void { flags = 0U; }
+
+  auto entry::calculate_pointed_to_frame() const -> std::optional<allocator::physical_frame>
+  {
+    if (contains_flags(PRESENT))
+    {
+      auto const address = flags.to_ulong() & PHYSICAL_ADDRESS_MASK;
+      return allocator::physical_frame::containing_address(address);
+    }
+    return std::nullopt;
+  }
+
+  auto entry::contains_flags(std::bitset<64U> other) const -> bool { return (flags & other) == other; }
+
+  auto entry::set_entry(allocator::physical_frame frame, std::bitset<64U> additional_flags) -> void
+  {
+    exception_handling::assert((frame.start_address() & ~PHYSICAL_ADDRESS_MASK) == 0,
+                               "[Paging Entry] Start address is not aligned with page");
+    flags = frame.start_address() | additional_flags.to_ulong();
+  }
+
+  auto entry::get_flags() const -> std::bitset<64U> { return flags.to_ulong() & ~PHYSICAL_ADDRESS_MASK; }
+}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/src/memory/paging/page_table.cpp b/arch/x86_64/src/memory/paging/page_table.cpp
new file mode 100644
index 0000000..eb11810
--- /dev/null
+++ b/arch/x86_64/src/memory/paging/page_table.cpp
@@ -0,0 +1,128 @@
+#include "arch/memory/paging/page_table.hpp"
+
+#include <algorithm>
+#include <array>
+#include <memory>
+
+/*
+ * This is a linker variable reference. This referenc cannot reside inside a namespace, because in
+ * that case the compiler would try to find arch::memory::paging::_end_of_image inside the ELF file.
+ */
+extern char _end_of_image;
+
+namespace teachos::arch::memory::paging
+{
+  /**
+   * @brief A Page table containing 512 entries.
+   */
+  struct page_table
+  {
+    auto zero_entries() -> void;
+
+    auto is_empty() const -> bool;
+
+    auto next_table(std::size_t table_index) const -> std::optional<page_table *>;
+
+    auto operator[](std::size_t index) -> entry &;
+
+    auto operator[](std::size_t index) const -> entry const &;
+
+  private:
+    /**
+     * @brief Calculates the address of the next page table level for the given table index.
+     *
+     * @note The next page table address is only valid if the corresponding entry is present and not a huge page.
+     * Meaning we use an index into a Level 4 page table to get the according Level 3 page table address.
+     *
+     * @param table_index Index of this page table in the page table one level higher.
+     * @return An optional of the address of the next page table or null.
+     */
+    auto next_table_address(std::size_t table_index) const -> std::optional<std::size_t>;
+
+    std::array<entry, PAGE_TABLE_ENTRY_COUNT> entries =
+        {};  ///< Entries containing addresses to page tables of a level below or
+             ///< actual virtual addresses for the level 1 page table.
+  };
+
+  auto page_table::zero_entries() -> void
+  {
+    std::ranges::for_each(entries, [](auto & entry) { entry.set_unused(); });
+  }
+
+  auto page_table::is_empty() const -> bool
+  {
+    return std::all_of(entries.begin(), entries.end(), [](entry const & entry) { return entry.is_unused(); });
+  }
+
+  auto page_table::next_table(std::size_t table_index) const -> std::optional<page_table *>
+  {
+    auto const address = next_table_address(table_index);
+    if (address.has_value())
+    {
+      return reinterpret_cast<page_table *>(address.value());
+    }
+    return std::nullopt;
+  }
+
+  auto page_table::operator[](std::size_t index) -> entry &
+  {
+    exception_handling::assert(index < PAGE_TABLE_ENTRY_COUNT, "[Page Table] Index out of bounds");
+    return entries[index];
+  }
+
+  auto page_table::operator[](std::size_t index) const -> entry const &
+  {
+    exception_handling::assert(index < PAGE_TABLE_ENTRY_COUNT, "[Page Table] Index out of bounds");
+    return entries[index];
+  }
+
+  auto page_table::next_table_address(std::size_t table_index) const -> std::optional<std::size_t>
+  {
+    auto const entry = this->operator[](table_index);
+
+    if (entry.contains_flags(entry::PRESENT) && !entry.contains_flags(entry::HUGE_PAGE))
+    {
+      auto const table_address = reinterpret_cast<std::size_t>(this);
+      return ((table_address << 9) | (table_index << 12));
+    }
+    return std::nullopt;
+  }
+
+  page_table_handle::page_table_handle(page_table * table, page_table_handle::level table_level)
+      : table(table)
+      , table_level(table_level)
+  {
+    exception_handling::assert(table != nullptr,
+                               "[Page Table] Attempted to pass nullptr as table to page table table method");
+  }
+
+  auto page_table_handle::zero_entries() -> void { table->zero_entries(); }
+
+  auto page_table_handle::is_empty() const -> bool { return table->is_empty(); }
+
+  auto page_table_handle::next_table(std::size_t table_index) const -> std::optional<page_table_handle>
+  {
+    exception_handling::assert(table_level != page_table_handle::LEVEL1,
+                               "[Page Table] Attempted to call next_table on level 1 page table");
+    auto const next_table = table->next_table(table_index);
+    if (next_table.has_value())
+    {
+      auto const new_level = static_cast<page_table_handle::level>(table_level - 1);
+      return page_table_handle{next_table.value(), new_level};
+    }
+    return std::nullopt;
+  }
+
+  auto page_table_handle::get_level() const -> page_table_handle::level { return table_level; }
+
+  auto page_table_handle::operator[](std::size_t index) -> entry & { return table->operator[](index); }
+
+  auto operator--(page_table_handle::level & value) -> page_table_handle::level &
+  {
+    exception_handling::assert(value != page_table_handle::LEVEL1,
+                               "[Page table] Attempted to decrement enum to value outside of range");
+    auto new_value = static_cast<std::underlying_type<page_table_handle::level>::type>(value);
+    value = static_cast<page_table_handle::level>(--new_value);
+    return value;
+  }
+}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/src/memory/paging/temporary_page.cpp b/arch/x86_64/src/memory/paging/temporary_page.cpp
new file mode 100644
index 0000000..152241d
--- /dev/null
+++ b/arch/x86_64/src/memory/paging/temporary_page.cpp
@@ -0,0 +1,29 @@
+#include "arch/memory/paging/temporary_page.hpp"
+
+#include "arch/memory/paging/page_entry.hpp"
+
+namespace teachos::arch::memory::paging
+{
+  auto temporary_page::map_table_frame(allocator::physical_frame frame,
+                                       active_page_table & active_table) -> page_table_handle
+  {
+    page_table_handle handle{reinterpret_cast<page_table *>(map_to_frame(frame, active_table)),
+                             page_table_handle::LEVEL1};
+    return handle;
+  }
+
+  auto temporary_page::map_to_frame(allocator::physical_frame frame,
+                                    active_page_table & active_table) -> virtual_address
+  {
+    exception_handling::assert(!active_table.translate_page(page).has_value(),
+                               "[Temporary page] Page is already mapped");
+
+    active_table.map_page_to_frame(allocator, page, frame, entry::WRITABLE);
+    return page.start_address();
+  }
+
+  auto temporary_page::unmap_page(active_page_table & active_table) -> void
+  {
+    active_table.unmap_page(allocator, page);
+  }
+}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/src/memory/paging/virtual_page.cpp b/arch/x86_64/src/memory/paging/virtual_page.cpp
new file mode 100644
index 0000000..d374156
--- /dev/null
+++ b/arch/x86_64/src/memory/paging/virtual_page.cpp
@@ -0,0 +1,33 @@
+#include "arch/memory/paging/virtual_page.hpp"
+
+#include "arch/exception_handling/assert.hpp"
+
+namespace teachos::arch::memory::paging
+{
+  auto virtual_page::containing_address(virtual_address address) -> virtual_page
+  {
+    exception_handling::assert(address < 0x00008000'00000000 || address >= 0xffff8000'00000000,
+                               "[Virtual Page] Attempted to create virtual page from invalid address");
+    return virtual_page{address / allocator::PAGE_FRAME_SIZE};
+  }
+
+  auto virtual_page::start_address() const -> virtual_address { return page_number * allocator::PAGE_FRAME_SIZE; }
+
+  auto virtual_page::get_level_index(page_table_handle::level level) const -> size_t
+  {
+    return (page_number >> (level * 9U)) & 0x1FF;
+  }
+
+  auto virtual_page::operator++(int) -> virtual_page
+  {
+    virtual_page const old_value = *this;
+    ++page_number;
+    return old_value;
+  }
+
+  auto virtual_page::operator++() -> virtual_page &
+  {
+    ++page_number;
+    return *this;
+  }
+}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/src/shared/mutex.cpp b/arch/x86_64/src/shared/mutex.cpp
new file mode 100644
index 0000000..6598255
--- /dev/null
+++ b/arch/x86_64/src/shared/mutex.cpp
@@ -0,0 +1,16 @@
+#include "arch/shared/mutex.hpp"
+
+namespace teachos::arch::shared
+{
+  auto mutex::lock() -> void
+  {
+    while (!try_lock())
+    {
+      // Nothing to do
+    }
+  }
+
+  auto mutex::try_lock() -> bool { return !locked.exchange(true, std::memory_order_acquire); }
+
+  auto mutex::unlock() -> void { locked.store(false, std::memory_order_release); }
+}  // namespace teachos::arch::shared
diff --git a/arch/x86_64/src/video/vga/text.cpp b/arch/x86_64/src/video/vga/text.cpp
index f1e7412..0137ddb 100644
--- a/arch/x86_64/src/video/vga/text.cpp
+++ b/arch/x86_64/src/video/vga/text.cpp
@@ -1,6 +1,5 @@
 #include "arch/video/vga/text.hpp"
 
-#include "arch/boot/pointers.hpp"
 #include "arch/video/vga/io.hpp"
 #include "memory/asm_pointer.hpp"
 
@@ -10,24 +9,18 @@
 
 namespace teachos::arch::video::vga::text
 {
-
   namespace
   {
-    auto constexpr default_text_buffer_address = 0xb8000;
+    auto constexpr DEFAULT_TEXT_BUFFER_WIDTH = 80U;
+    auto constexpr DEFAULT_TEXT_BUFFER_HEIGHT = 25U;
 
     extern "C" std::pair<char, attribute> * vga_buffer_pointer;
     auto constinit text_buffer = teachos::memory::asm_pointer{vga_buffer_pointer};
-
-    auto write(char code_point, attribute attribute) -> void
-    {
-      auto & p = *text_buffer;
-      (*p++) = std::pair{code_point, attribute};
-    };
   }  // namespace
 
   auto clear(attribute attribute) -> void
   {
-    *text_buffer = reinterpret_cast<decltype(text_buffer)::pointer>(default_text_buffer_address);
+    *text_buffer = reinterpret_cast<decltype(text_buffer)::pointer>(DEFAULT_VGA_TEXT_BUFFER_ADDRESS);
     std::ranges::fill_n(*text_buffer, 2000, std::pair{' ', attribute});
   }
 
@@ -39,9 +32,34 @@ namespace teachos::arch::video::vga::text
     crtc::data_port::write(vga::crtc::data_port::read() | cursor_disable_byte);
   }
 
-  auto write(std::string_view code_points, attribute attribute) -> void
+  auto newline() -> void
   {
-    std::ranges::for_each(code_points, [&](auto code_point) { write(code_point, attribute); });
+    auto base = reinterpret_cast<decltype(text_buffer)::pointer>(DEFAULT_VGA_TEXT_BUFFER_ADDRESS);
+    auto & raw_buffer = *text_buffer;
+    auto current_line = (raw_buffer - base) / DEFAULT_TEXT_BUFFER_WIDTH;
+    auto next_line = current_line + 1;
+
+    if (next_line >= DEFAULT_TEXT_BUFFER_HEIGHT)
+    {
+      auto begin = base + DEFAULT_TEXT_BUFFER_WIDTH;
+      auto end = base + DEFAULT_TEXT_BUFFER_WIDTH * DEFAULT_TEXT_BUFFER_HEIGHT;
+      std::ranges::move(begin, end, base);
+      raw_buffer = base + current_line * DEFAULT_TEXT_BUFFER_WIDTH;
+    }
+    else
+    {
+      raw_buffer = base + next_line * DEFAULT_TEXT_BUFFER_WIDTH;
+    }
   }
 
+  auto write_char(char code_point, attribute attribute) -> void
+  {
+    auto & p = *text_buffer;
+    (*p++) = std::pair{code_point, attribute};
+  };
+
+  auto write(std::string_view code_points, attribute attribute) -> void
+  {
+    std::ranges::for_each(code_points, [&](auto code_point) { write_char(code_point, attribute); });
+  }
 }  // namespace teachos::arch::video::vga::text