support memory above 4G

The multiboot specification explicitly states that `mem_upper` is not
guaranteed to be the correct value for mem_upper. Additionally, placing
the heap in-between `mem_lower` and `mem_upper` only really makes sense
on 32-bit systems.

By using memory mapped pages we can pick the largest consecutive region
of memory available.

Selecting 1_000_000 as the minimum address is a temporary hack since
it's not immediately obvious how to get the correct address for virtual
mappings that are still not initialized (such as LiveUpdate and
SystemLog). The correct solution here would be to make these regions
dynamic in size, initialize them earlier so the regions are already
claimed, or re-initialize the heap. This is only necessary for systems
that have less than 4G of memory.

See-Also: https://www.gnu.org/software/grub/manual/multiboot/multiboot.html
See-Also: https://wiki.osdev.org/Multiboot

Author: mazunki

api/boot/multiboot.h

@@ -195,12 +195,19 @@ typedef struct multiboot_info multiboot_info_t;
 
      struct multiboot_mmap_entry
      {
-       multiboot_uint32_t size;
+       multiboot_uint32_t size;  // size of struct
        multiboot_uint64_t addr;
-       multiboot_uint64_t len;
+       multiboot_uint64_t len;  // bytes available
      #define MULTIBOOT_MEMORY_AVAILABLE              1
      #define MULTIBOOT_MEMORY_RESERVED               2
+     #define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE       3
+     #define MULTIBOOT_MEMORY_NVS                    4
+     #define MULTIBOOT_MEMORY_BADRAM                 5
        multiboot_uint32_t type;
+
+       [[nodiscard]] constexpr bool is_available() const noexcept {
+         return type == MULTIBOOT_MEMORY_AVAILABLE;
+       }
      } __attribute__((packed));
 typedef struct multiboot_mmap_entry multiboot_memory_map_t;
 

src/arch/x86_64/paging.cpp

@@ -376,6 +376,8 @@ uintptr_t mem::active_page_size(uintptr_t addr){
 
 void allow_executable()
 {
+  // FIXME: this seems weird. is this only used for tests?
+
   INFO2("* Allowing execute on %p -> %p",
         (void*) __exec_begin, (void*)__exec_end);
 
@@ -391,7 +393,7 @@ void allow_executable()
   m.page_sizes = os::mem::Map::any_size;
   m.flags      = os::mem::Access::execute | os::mem::Access::read;
 
-  os::mem::map(m, "ELF .text");
+  os::mem::map(m, "Executable");
 }
 
 /* TODO: Compiler warning unused

src/kernel/multiboot.cpp

@@ -22,6 +22,7 @@
 #include <boot/multiboot.h>
 #include <kernel/memory.hpp>
 #include <fmt/format.h>
+#include <ranges>
 
 template<class... Args>
 static inline void _kfmt(fmt::string_view prefix, fmt::format_string<Args...> fmtstr, Args&&... args) {
@@ -122,9 +123,41 @@ uintptr_t _multiboot_free_begin(uintptr_t boot_addr)
   return multi_end;
 }
 
+constexpr static inline const char* multiboot_memory_type_str(uint32_t type) noexcept {
+  // TODO: convert multiboot types to enum class
+  switch (type) {
+    case MULTIBOOT_MEMORY_AVAILABLE:
+      return "Available";
+    case MULTIBOOT_MEMORY_ACPI_RECLAIMABLE:
+      return "ACPI Reclaimable";
+    case MULTIBOOT_MEMORY_NVS:
+      return "ACPI Non-volatile Storage";
+    case MULTIBOOT_MEMORY_BADRAM:
+      return "Bad RAM";
+    case MULTIBOOT_MEMORY_RESERVED:
+      return "Reserved";
+    default:
+        return "UNKNOWN";
+  }
+}
+
+
+std::span<multiboot_memory_map_t> _multiboot_memory_maps() {
+  auto* info = kernel::bootinfo();
+
+  auto* hardware_map = reinterpret_cast<multiboot_memory_map_t*>(info->mmap_addr);
+  const size_t entry_count = static_cast<size_t>(info->mmap_length / sizeof(multiboot_memory_map_t));
+
+  return std::span<multiboot_memory_map_t> { hardware_map, entry_count };
+}
+
 void kernel::multiboot(uint32_t boot_addr)
 {
-  MYINFO("Booted with multiboot");
+#if defined(__x86_64)
+  MYINFO("Booted with multiboot x86_64");
+#else
+  MYINFO("Booted with multiboot x86");
+#endif
   auto* info = ::bootinfo(boot_addr);
   INFO2("* Boot flags: {:#x}", info->flags);
 
@@ -152,36 +185,50 @@ void kernel::multiboot(uint32_t boot_addr)
   }
 
   if (info->flags & MULTIBOOT_INFO_MEM_MAP) {
-    INFO2("* Multiboot provided memory map  ({} entries @ {})",
-          info->mmap_length / sizeof(multiboot_memory_map_t),
-          (const void*)(uintptr_t)info->mmap_addr);
-    std::span<multiboot_memory_map_t> mmap {
-        reinterpret_cast<multiboot_memory_map_t*>(info->mmap_addr),
-        static_cast<size_t>(info->mmap_length / sizeof(multiboot_memory_map_t))
-      };
-
-    for (auto map : mmap)
+    auto* hardware_map = reinterpret_cast<multiboot_memory_map_t*>(info->mmap_addr);
+    const size_t entry_count = static_cast<size_t>(info->mmap_length / sizeof(multiboot_memory_map_t));
+
+    INFO2("* Multiboot provided memory map  ({} entries @ {})\n", entry_count, reinterpret_cast<const void*>(hardware_map));
+
+    for (auto map : std::span<multiboot_memory_map_t>{ hardware_map, entry_count })
     {
-      const char* str_type = map.type & MULTIBOOT_MEMORY_AVAILABLE ? "FREE" : "RESERVED";
-      const uintptr_t addr = map.addr;
+      const uintptr_t start = map.addr;
       const uintptr_t size = map.len;
-      INFO2("  {:#x} - {:#x} {} ({} KiB)", addr, addr + size - 1, str_type, size / 1024);
-
-      if (not (map.type & MULTIBOOT_MEMORY_AVAILABLE)) {
+      const uintptr_t end = start + size - 1;
 
-        if (util::bits::is_aligned<4_KiB>(map.addr)) {
-          os::mem::map({addr, addr, os::mem::Access::read | os::mem::Access::write, size},
-                       "Reserved (Multiboot)");
-          continue;
-        }
+      INFO2("  {:#16x} - {:#16x} ({} KiB): {}", start, end, size / 1024, multiboot_memory_type_str(map.type));
 
-        // For non-aligned addresses, assign
-        os::mem::vmmap().assign_range({addr, addr + size - 1, "Reserved (Multiboot)"});
+      // os::mem::map() does not accept non-aligned page addresses
+      if (not util::bits::is_aligned<4_KiB>(map.addr)) {
+        os::mem::vmmap().assign_range({start, start + size - 1, "UNALIGNED"});
+        continue;
       }
-      else
+
+      os::mem::Map rw_map = { /*.linear=*/start, /*.physical=*/start, /*.fl=*/os::mem::Access::read | os::mem::Access::write, /*.sz=*/size };
+      switch (map.type)
       {
-        // Map as free memory
-        //os::mem::map_avail({map.addr, map.addr, {os::mem::Access::read | os::mem::Access::write}, map.len}, "Reserved (Multiboot)");
+        case MULTIBOOT_MEMORY_ACPI_RECLAIMABLE:
+            os::mem::map(rw_map, "Multiboot (ACPI Reclaimable)");
+            break;
+        case MULTIBOOT_MEMORY_NVS:
+            os::mem::map(rw_map, "Multiboot (ACPI Non-volatile Storage)");
+            break;
+        case MULTIBOOT_MEMORY_BADRAM:
+            os::mem::map(rw_map, "Multiboot (Bad RAM)");
+            break;
+        case MULTIBOOT_MEMORY_RESERVED:
+            os::mem::map(rw_map, "Multiboot (Reserved)");
+            break;
+
+        case MULTIBOOT_MEMORY_AVAILABLE: {
+          // these are mapped in src/platform/${platform}/os.cpp
+          break;
+        }
+        default: {
+          char buf[32];  // libc is not entirely initialized at this point
+          std::snprintf(buf, sizeof(buf), "Unknown memory map type: %d", map.type);
+          os::panic(buf);
+        }
       }
     }
     INFO2("");

src/platform/x86_pc/os.cpp

@@ -48,6 +48,8 @@ extern uintptr_t _ELF_END_;
 // in kernel/os.cpp
 extern bool os_default_stdout;
 
+extern std::span<multiboot_memory_map_t> _multiboot_memory_maps();
+
 struct alignas(SMP_ALIGN) OS_CPU {
   uint64_t cycles_hlt = 0;
 };
@@ -125,10 +127,6 @@ void kernel::start(uint32_t boot_magic, uint32_t boot_addr)
 
   MYINFO("Total memory detected as %s ", util::Byte_r(kernel::memory_end()).to_string().c_str());
 
-  // Give the rest of physical memory to heap
-  kernel::state().heap_max = kernel::memory_end() - 1;
-  assert(kernel::heap_begin() != 0x0 and kernel::heap_max() != 0x0);
-
   PROFILE("Memory map");
   // Assign memory ranges used by the kernel
   auto& memmap = os::mem::vmmap();
@@ -145,13 +143,28 @@ void kernel::start(uint32_t boot_magic, uint32_t boot_addr)
   memmap.assign_range({0x10000, 0x9d3ff, "Stack"});
 #endif
 
-  // heap (physical) area
-  uintptr_t span_max = std::numeric_limits<std::ptrdiff_t>::max();
-  uintptr_t heap_range_max_ = std::min(span_max, kernel::heap_max());
+  multiboot_memory_map_t heap_map = {0,0,0,0};
+  for (auto entry : _multiboot_memory_maps())
+  {
+    if (not entry.is_available()) continue;
+
+    if (entry.len > heap_map.len) {
+      heap_map = entry;
+    }
+  }
+  uintptr_t end = heap_map.addr + heap_map.len - 1;
+
+  if (heap_map.addr < 0x1'000'000) {
+    kernel::state().heap_begin = std::max((uintptr_t)0x1'000'000, (uintptr_t)heap_map.addr);
+    kernel::state().heap_max = std::min(kernel::heap_max(), end);
+  } else {
+    kernel::state().heap_begin = heap_map.addr;
+    kernel::state().heap_max = end;
+  }
 
-  INFO2("* Assigning heap 0x%zx -> 0x%zx", kernel::heap_begin(), heap_range_max_);
-  memmap.assign_range({kernel::heap_begin(), heap_range_max_,
-        "Dynamic memory", kernel::heap_usage });
+
+  INFO2("* Assigning heap 0x%lx -> 0x%lx", kernel::heap_begin(), kernel::heap_max());
+  memmap.assign_range({kernel::heap_begin(), kernel::heap_max(), "Heap", kernel::heap_usage });
 
   MYINFO("Virtual memory map");
   for (const auto& entry : memmap)
@@ -182,7 +195,7 @@ void os::event_loop()
   __arch_poweroff();
 }
 
-
+/* legacy boot is used when MULTIBOOT_BOOTLOADER_MAGIC is unset, see x86_pc/kernel_start.cpp */
 void kernel::legacy_boot()
 {
   // Fetch CMOS memory info (unfortunately this is maximally 10^16 kb)