kernel: support for multiboot modules (WIP)

Author: alfreb

api/kernel/os.hpp

@@ -26,6 +26,7 @@
 #include <string>
 #include <sstream>
 #include <vector>
+#include <boot/multiboot.h>
 
 /**
  *  The entrypoint for OS services
@@ -36,6 +37,7 @@ class OS {
 public:
   using print_func  = delegate<void(const char*, size_t)>;
   using Plugin = delegate<void()>;
+  using Span_mods = gsl::span<multiboot_module_t>;
 
   /**
    * Returns the version of the OS from when
@@ -204,6 +206,23 @@ class OS {
   /** Start the OS.  @todo Should be `init()` - and not accessible from ABI */
   static void start(uint32_t boot_magic, uint32_t boot_addr);
 
+  /** Get "kernel modules", provided by multiboot */
+  static Span_mods modules() {
+
+    if (bootinfo_ and bootinfo_->flags & MULTIBOOT_INFO_MODS) {
+
+      Expects(bootinfo_->mods_count > 0
+              and bootinfo_->mods_count < std::numeric_limits<int>::max());
+
+      return Span_mods{
+        reinterpret_cast<multiboot_module_t*>(bootinfo_->mods_addr),
+          static_cast<int>(bootinfo_->mods_count) };
+
+    }
+
+    return nullptr;
+  }
+
 private:
 
   /** Process multiboot info. Called by 'start' if multibooted **/
@@ -216,15 +235,6 @@ class OS {
   static bool is_softreset_magic(uint32_t value);
   static void resume_softreset(intptr_t boot_addr);
 
-  static constexpr int PAGE_SHIFT = 12;
-
-  static bool power_;
-  static bool boot_sequence_passed_;
-
-  static MHz cpu_mhz_;
-
-  static std::string version_field;
-
   struct Plugin_struct {
     Plugin_struct(Plugin f, const char* n)
       : func_{f}, name_{n}
@@ -234,14 +244,18 @@ class OS {
     const char* name_;
   };
 
+  static constexpr int PAGE_SHIFT = 12;
+  static bool power_;
+  static bool boot_sequence_passed_;
+  static MHz cpu_mhz_;
+  static std::string version_field;
   static std::vector<Plugin_struct> plugins_;
-
   static uintptr_t low_memory_size_;
   static uintptr_t high_memory_size_;
   static uintptr_t memory_end_;
   static uintptr_t heap_max_;
   static const uintptr_t elf_binary_size_;
-
+  static multiboot_info_t* bootinfo_;
   static std::string cmdline;
 
   // Prohibit copy and move operations

src/crt/c_abi.c

@@ -26,8 +26,12 @@
 #include <kprint>
 
 #define HEAP_ALIGNMENT   63
-caddr_t heap_begin;
-caddr_t heap_end;
+void* heap_begin;
+void* heap_end;
+
+extern char _ELF_SYM_START_;
+extern char _end;
+
 
 /// IMPLEMENTATION OF Newlib I/O:
 #undef stdin
@@ -42,10 +46,25 @@ __FILE* stderr;
 const uintptr_t __stack_chk_guard = _STACK_GUARD_VALUE_;
 extern void panic(const char* why) __attribute__((noreturn));
 
-void _init_c_runtime()
-{
-  extern char _ELF_SYM_START_;
-  extern char _end;
+void _init_bss() {
+  /// Initialize .bss section
+  extern char _BSS_START_, _BSS_END_;
+  streamset8(&_BSS_START_, 0, &_BSS_END_ - &_BSS_START_);
+
+}
+
+void _init_heap(uintptr_t free_mem_begin) {
+  // NOTE: Initialize the heap before exceptions
+  // cache-align heap, because its not aligned
+  heap_begin = (void*) free_mem_begin + HEAP_ALIGNMENT;
+  heap_begin = (void*) ((size_t)heap_begin & ~HEAP_ALIGNMENT);
+  // heap end tracking, used with sbrk
+  heap_end   = heap_begin;
+
+
+}
+
+uintptr_t _move_symbols(void* sym_loc) {
 
   /// read out size of symbols **before** moving them
   extern int  _get_elf_section_datasize(const void*);
@@ -54,23 +73,25 @@ void _init_c_runtime()
 
   /// move ELF symbols to safe area
   extern void _move_elf_syms_location(const void*, void*);
-  _move_elf_syms_location(&_ELF_SYM_START_, &_end);
+  _move_elf_syms_location(&_ELF_SYM_START_, sym_loc);
 
-  /// Initialize .bss section
-  extern char _BSS_START_, _BSS_END_;
-  streamset8(&_BSS_START_, 0, &_BSS_END_ - &_BSS_START_);
+  return elfsym_size;
+
+}
+
+void _crt_sanity_checks() {
 
-  /// Initialize the heap before exceptions
-  // set heap start at end of ELF symbols
-  heap_begin = &_end + elfsym_size;
-  // cache-align heap, because its not aligned
-  heap_begin += HEAP_ALIGNMENT;
-  heap_begin = (char*) ((uintptr_t)heap_begin & ~(uintptr_t) HEAP_ALIGNMENT);
-  // heap end tracking, used with sbrk
-  heap_end   = heap_begin;
   // validate that heap is aligned
   int validate_heap_alignment =
-      ((uintptr_t)heap_begin & (uintptr_t) HEAP_ALIGNMENT) == 0;
+    ((uintptr_t)heap_begin & (uintptr_t) HEAP_ALIGNMENT) == 0;
+
+  assert(heap_begin >= (void*) &_end);
+  assert(heap_end >= heap_begin);
+  assert(validate_heap_alignment);
+};
+
+void _init_c_runtime()
+{
 
   /// initialize newlib I/O
   _REENT_INIT_PTR(_REENT);
@@ -89,10 +110,8 @@ void _init_c_runtime()
   extern void _init_elf_parser();
   _init_elf_parser();
 
-  // sanity checks
-  assert(heap_begin >= &_end);
-  assert(heap_end >= heap_begin);
-  assert(validate_heap_alignment);
+  _crt_sanity_checks();
+
 }
 
 // stack-protector

src/kernel/kernel_start.cpp

@@ -22,25 +22,43 @@
 
 #define MULTIBOOT_CMDLINE_LOC 0x7000
 
-extern "C" void __init_sanity_checks();
-extern "C" void kernel_sanity_checks();
-extern "C" void _init_c_runtime();
-extern "C" void _init_syscalls();
-extern "C" void _init();
+extern "C" {
+  void __init_sanity_checks();
+  void kernel_sanity_checks();
+  uintptr_t _multiboot_free_begin(uintptr_t boot_addr);
+  uintptr_t _move_symbols(uintptr_t loc);
+  void _init_bss();
+  void _init_heap(uintptr_t);
+  void _init_c_runtime();
+  void _init_syscalls();
+  void _init();
+  extern uintptr_t _end;
+}
 
 extern "C"
 void kernel_start(uintptr_t magic, uintptr_t addr)
 {
+
   // generate checksums of read-only areas etc.
   __init_sanity_checks();
 
+  uintptr_t free_mem_begin = reinterpret_cast<uintptr_t>(&_end);
+
   // Save multiboot string before symbols overwrite area after binary
   if (magic == MULTIBOOT_BOOTLOADER_MAGIC) {
-    char* cmdline = reinterpret_cast<char*>(reinterpret_cast<multiboot_info_t*>(addr)->cmdline);
-    strcpy(reinterpret_cast<char*>(MULTIBOOT_CMDLINE_LOC), cmdline);
-    ((multiboot_info_t*) addr)->cmdline = MULTIBOOT_CMDLINE_LOC;
+    free_mem_begin = _multiboot_free_begin(addr);
   }
 
+  // Preserve symbols from the ELF binary
+  free_mem_begin += _move_symbols(free_mem_begin);
+
+
+  // Initialize zero-initialized vars
+  _init_bss();
+
+  // Initialize heap
+  _init_heap(free_mem_begin);
+
   // Initialize stack-unwinder, call global constructors etc.
   _init_c_runtime();
 

src/kernel/multiboot.cpp

@@ -16,27 +16,72 @@
 // limitations under the License.
 
 #include <os>
+#include <kprint>
 #include <boot/multiboot.h>
 
 #define MYINFO(X,...) INFO("Kernel", X, ##__VA_ARGS__)
 
+extern "C" {
+
+  extern uintptr_t _end;
+
+  // Function to deterimine the end of multiboot provided data
+  // (e.g. multiboot's data area as offset to the _end symbol)
+  uintptr_t _multiboot_free_begin(uintptr_t boot_addr){
+
+    multiboot_info_t* bootinfo = (multiboot_info_t*) boot_addr;
+    uintptr_t multi_end = reinterpret_cast<uintptr_t>(&_end);
+
+    if (bootinfo->flags & MULTIBOOT_INFO_CMDLINE
+        and bootinfo->cmdline > multi_end) {
+      debug("* Multiboot cmdline end: 0x%x \n", bootinfo->cmdline);
+      multi_end = bootinfo->cmdline;
+    }
+
+    debug("* Multiboot end: 0x%x \n", multi_end);
+
+
+    if (not bootinfo->mods_count)
+      return multi_end;
+
+    multiboot_module_t* mods_list =  (multiboot_module_t*)bootinfo->mods_addr;
+    debug("* Module list @ %p \n",mods_list);
+
+    for (multiboot_module_t* mod = mods_list;
+         mod < mods_list + bootinfo->mods_count;
+         mod ++) {
+
+      debug("\t * Module @ %p \n", (void*)mod->mod_start);
+      debug("\t * Args: %s \n ", (char*)mod->cmdline);
+      debug("\t * End: %p \n ", (char*)mod->mod_end);
+
+      if (mod->mod_end > multi_end)
+        multi_end = mod->mod_end;
+
+    }
+
+    debug("* Multiboot end: 0x%x \n", multi_end);
+    return multi_end;
+  }
+}
+
 void OS::multiboot(uint32_t boot_magic, uint32_t boot_addr){
   MYINFO("Booted with multiboot");
-  INFO2("* magic value: 0x%x Multiboot info at 0x%x", boot_magic, boot_addr);
 
-  multiboot_info_t* bootinfo = (multiboot_info_t*) boot_addr;
+  INFO2("* magic value: 0x%x Multiboot info at 0x%x", boot_magic, boot_addr);
+  bootinfo_ = (multiboot_info_t*) boot_addr;
 
-  if (! bootinfo->flags & MULTIBOOT_INFO_MEMORY) {
+  if (! bootinfo_->flags & MULTIBOOT_INFO_MEMORY) {
     INFO2("* No memory info provided in multiboot info");
     return;
   }
 
   uint32_t mem_low_start = 0;
-  uint32_t mem_low_end = (bootinfo->mem_lower * 1024) - 1;
-  uint32_t mem_low_kb = bootinfo->mem_lower;
+  uint32_t mem_low_end = (bootinfo_->mem_lower * 1024) - 1;
+  uint32_t mem_low_kb = bootinfo_->mem_lower;
   uint32_t mem_high_start = 0x100000;
-  uint32_t mem_high_end = mem_high_start + (bootinfo->mem_upper * 1024) - 1;
-  uint32_t mem_high_kb = bootinfo->mem_upper;
+  uint32_t mem_high_end = mem_high_start + (bootinfo_->mem_upper * 1024) - 1;
+  uint32_t mem_high_kb = bootinfo_->mem_upper;
 
   OS::low_memory_size_ = mem_low_kb * 1024;
   OS::high_memory_size_ = mem_high_kb * 1024;
@@ -49,26 +94,39 @@ void OS::multiboot(uint32_t boot_magic, uint32_t boot_addr){
         mem_high_start, mem_high_end, mem_high_kb);
   INFO2("");
 
-  if (bootinfo->flags & MULTIBOOT_INFO_CMDLINE) {
-    INFO2("* Booted with parameters @ %p: %s",(void*)bootinfo->cmdline, (char*)bootinfo->cmdline);
-    cmdline = std::string((char*) bootinfo->cmdline);
+  if (bootinfo_->flags & MULTIBOOT_INFO_CMDLINE) {
+    INFO2("* Booted with parameters @ 0x%x: %s", bootinfo_->cmdline,
+          reinterpret_cast<const char*>(bootinfo_->cmdline));
+    cmdline = reinterpret_cast<const char*>(bootinfo_->cmdline);
   }
 
-  if (bootinfo->flags & MULTIBOOT_INFO_MEM_MAP) {
+  if (bootinfo_->flags & MULTIBOOT_INFO_MEM_MAP) {
     INFO2("* Multiboot provided memory map  (%i entries @ %p)",
-          bootinfo->mmap_length / sizeof(multiboot_memory_map_t), (void*)bootinfo->mmap_addr);
-    gsl::span<multiboot_memory_map_t> mmap { reinterpret_cast<multiboot_memory_map_t*>(bootinfo->mmap_addr),
-        (int)(bootinfo->mmap_length / sizeof(multiboot_memory_map_t))};
+          bootinfo_->mmap_length / sizeof(multiboot_memory_map_t), (void*)bootinfo_->mmap_addr);
+    gsl::span<multiboot_memory_map_t> mmap { reinterpret_cast<multiboot_memory_map_t*>(bootinfo_->mmap_addr),
+        (int)(bootinfo_->mmap_length / sizeof(multiboot_memory_map_t))};
 
     for (auto map : mmap) {
       const char* str_type = map.type & MULTIBOOT_MEMORY_AVAILABLE ? "FREE" : "RESERVED";
       INFO2("\t 0x%08llx - 0x%08llx %s (%llu Kb.)",
             map.addr, map.addr + map.len - 1, str_type, map.len / 1024 );
 
       if (not (map.type & MULTIBOOT_MEMORY_AVAILABLE)) {
-        memory_map().assign_range({static_cast<uintptr_t>(map.addr), static_cast<uintptr_t>(map.addr + map.len - 1), "Reserved", "Multiboot / BIOS"});
+        memory_map().assign_range({static_cast<uintptr_t>(map.addr),
+              static_cast<uintptr_t>(map.addr + map.len - 1), "Reserved", "Multiboot / BIOS"});
       }
     }
     printf("\n");
   }
+
+  Span_mods mods = modules();
+
+  if (not mods.empty()) {
+    MYINFO("OS loaded with %i modules", mods.size());
+    for (auto mod : mods) {
+      INFO2("* %s @ 0x%x - 0x%x, size: %ib",
+            reinterpret_cast<char*>(mod.cmdline),
+            mod.mod_start, mod.mod_end, mod.mod_end - mod.mod_start);
+    }
+  }
 }