Merge pull request #1293 from alfred-bratterud/dev

Multiboot modules + chainloading

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,15 +37,16 @@ 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 
+   * Returns the version of the OS from when
    * the service was built.
   **/
   static const std::string& version() noexcept
   { return version_field; }
 
-  /** 
+  /**
    *  Returns the commandline arguments provided,
    *  if any, to the VM passed on by multiboot or
    *  other mechanisms. The first argument is always
@@ -113,7 +115,7 @@ class OS {
    * The on_panic handler will be called directly after a panic,
    * or any condition which will deliberately cause the OS to become
    * unresponsive. After the handler is called, the OS goes to sleep.
-   * This handler can thus be used to, for example, automatically 
+   * This handler can thus be used to, for example, automatically
    * have the OS restart on any crash.
   **/
   typedef void (*on_panic_func) ();
@@ -204,6 +206,22 @@ 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 < 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 +234,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,13 +243,19 @@ 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
   OS(OS&)  = delete;

vmbuild/elf.h api/util/elf.hvmbuild/elf.h renamed to api/util/elf.h

@@ -2,8 +2,11 @@
 KERNEL=${1-build/test_grub}
 DISK=${DISK-$KERNEL.grub.img}
 MOUNTDIR=${MOUNTDIR-/mnt}
-MOUNT_OPTS="sync,rw"
-BLOCKCCOUNT=10000
+MOUNT_OPTS="rw"
+
+# GRUB uses roughly 4.6 Mb of disk
+GRUB_KB=5000
+
 set -e
 
 function unmount {
@@ -23,18 +26,25 @@ function clean {
 
 
 function create_disk {
-  echo -e ">>> Creating FAT file system on $DISK with $BLOCKSIZE blocks"
-  # NOTE: mkfs with the '-C' option creates the disk before creating FS
-  # fallocate -l 10MiB $DISK
 
   if [ -f $DISK ]
   then
     echo -e ">>> $DISK allready exists. Preserving existing image as $DISK.bak"
     mv $DISK $DISK.bak
   fi
 
+  # Kernel size in Kb
+  KERN_KB=$(( ($(stat -c%s "$KERNEL") / 1024) ))
+
+  # Estimate some overhead for the FAT
+  FAT_KB=$(( ($KERN_KB + $GRUB_KB) / 10 ))
 
-  mkfs.fat -C $DISK $BLOCKCCOUNT
+  DISK_KB=$(( $KERN_KB + $GRUB_KB + $FAT_KB ))
+
+  echo ">>> Estimated disk size: $GRUB_KB Kb GRUB + $KERN_KB Kb kernel + $FAT_KB Kb FAT = $DISK_KB Kb"
+  echo ">>> Creating FAT file system on $DISK"
+
+  mkfs.fat -C $DISK $DISK_KB
 }
 
 function mount_loopback {
@@ -58,6 +68,7 @@ function mount_loopback {
 function copy_kernel {
   echo ">>> Copying kernel '$KERNEL' to $MOUNTDIR/boot/includeos_service"
   sudo cp $KERNEL $MOUNTDIR/boot/includeos_service
+  sync
 }
 
 function build {
@@ -130,6 +141,9 @@ copy_kernel
 echo -e ">>> Running grub install"
 sudo grub-install --target=i386-pc --force --boot-directory $MOUNTDIR/boot/ $LOOP
 
+echo -e ">>> Synchronize file cache"
+sync
+
 unmount
 
 echo -e ">>> Done. You can now boot $DISK"

vmbuild/elf_binary.hpp api/util/elf_binary.hppvmbuild/elf_binary.hpp renamed to api/util/elf_binary.hpp

@@ -27,7 +27,7 @@ add_custom_command(
 # TODO: i wanted to use a glob, but then found out that not everything is included
 set(OS_OBJECTS
   kernel/kernel_start.cpp kernel/sanity_checks.cpp kernel/syscalls.cpp
-  kernel/irq_manager.cpp
+  kernel/irq_manager.cpp kernel/multiboot.cpp
   kernel/os.cpp kernel/cpuid.cpp kernel/memmap.cpp kernel/pci_manager.cpp
   kernel/heap.cpp kernel/service_stub.cpp kernel/main_call.cpp
   kernel/elf.cpp kernel/terminal.cpp kernel/terminal_disk.cpp
@@ -37,7 +37,7 @@ set(OS_OBJECTS
   util/memstream.c util/async.cpp util/statman.cpp util/logger.cpp
   util/os_statman.cpp util/sha1.cpp
   util/syslog_facility.cpp util/syslogd.cpp util/uri.cpp util/percent_encoding.cpp
-  util/tar.cpp util/path_to_regex.cpp
+  util/tar.cpp util/path_to_regex.cpp util/elf_binary.cpp
   crt/c_abi.c crt/string.c crt/quick_exit.cpp crt/cxx_abi.cpp
   hw/ide.cpp hw/pci_device.cpp hw/ps2.cpp hw/serial.cpp hw/serial1.cpp
   hw/cmos.cpp hw/block_device.cpp hw/msi.cpp hw/pci_msi.cpp

etc/scripts/grubify.sh

@@ -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/CMakeLists.txt

@@ -24,7 +24,7 @@
 #include <string>
 #include <unistd.h>
 #include <vector>
-#include "../../vmbuild/elf.h"
+#include <util/elf.h>
 
 static const char* boot_stringz = "Bootloader area";
 extern "C" char _ELF_START_;

src/crt/c_abi.c

@@ -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();