application loading

7 files changed, 601 insertions, 100 deletions

diff --git a/kernel/application.cpp b/kernel/application.cpp
new file mode 100644
index 0000000..19b1dbc
--- /dev/null
+++ b/kernel/application.cpp
@@ -0,0 +1,266 @@
+#include <mercury/kernel/application.hpp>
+#include <mercury/kernel/paging.hpp>
+
+//TODO - scheduling.
+
+namespace mercury::kernel::application {
+
+  app_instance::app_instance() : state(app_state::paused) {
+
+    framebuffer_vaddr = 0;
+
+    uint64_t p3_paddr;
+    uint64_t p2_paddr;
+
+    uint64_t p4_vaddr;
+    uint64_t p3_vaddr;
+    uint64_t p2_vaddr;
+
+    paging::map_new_kernel_page(p4_vaddr, p4_paddr);
+    paging::map_new_kernel_page(p3_vaddr, p3_paddr);
+    paging::map_new_kernel_page(p2_vaddr, p2_paddr);
+
+    p4 = (uint64_t *)p4_vaddr;
+    p3 = (uint64_t *)p3_vaddr;
+    p2 = (uint64_t *)p2_vaddr;
+
+    for (int i = 1; i < 511; ++i)
+      p4[i] = 0;
+    p4[511] = paging::kernel_p4e;
+    p4[0] = paging::encode_pte(p3_paddr, true, true, true, false);
+
+    for (int i = 1; i < 512; ++i)
+      p3[i] = 0;
+    p3[0] = paging::encode_pte(p2_paddr, true, true, true, false);
+
+    for (int i = 0; i < 512; ++i)
+      p2[i] = 0;
+
+    p2es_to_free_on_exit = new bool[512];
+
+  }
+
+  app_instance::~app_instance() {
+
+    for (int i = 1; i < 512; ++i)
+      if (p2[i] != 0 && p2es_to_free_on_exit[i]) {
+        uint64_t paddr = p2[i] & ~0x1fffffULL;
+        paging::mark_pram_region_free(paddr, paddr + 0x200000);
+      }
+
+    delete[] p2es_to_free_on_exit;
+
+    uint64_t p2_paddr = p3[0] & ~0x1fffffULL;
+    paging::unmap_kernel_page((uint64_t)p2);
+    paging::mark_pram_region_free(p2_paddr, p2_paddr + 4096);
+
+    uint64_t p3_paddr = p4[0] & ~0x1fffffULL;
+    paging::unmap_kernel_page((uint64_t)p3);
+    paging::mark_pram_region_free(p3_paddr, p3_paddr + 4096);
+
+    paging::unmap_kernel_page((uint64_t)p4);
+    paging::mark_pram_region_free(p4_paddr, p4_paddr + 4096);
+
+  }
+
+  void app_instance::map_page(uint64_t vaddr, uint64_t paddr,
+    bool write, bool execute, bool free_pram_on_exit
+  ) {
+    uint64_t i = vaddr / 0x200000;
+    p2[i] = paging::encode_pte(paddr, true, write, execute, true);
+    p2es_to_free_on_exit[i] = free_pram_on_exit;
+  }
+
+  uint64_t app_instance::get_free_vaddr_pages(uint64_t count) {
+    uint64_t start = 1;
+    uint64_t length = 0;
+    while (start + length < 510) {
+      if (length == count)
+        return start * 0x200000;
+      if (p2[start + length] == 0)
+        ++length;
+      else {
+        start += length + 1;
+        length = 0;
+      }
+    }
+    //TODO: handle out of memory
+    return 0;
+  }
+
+  void app_instance::create_stack() {
+    uint64_t stack_paddr = paging::take_2mib_pram_page();
+    map_page(0x3fe00000, stack_paddr, true, false, true);
+    for (int i = 0; i < 512; ++i) {
+      uint64_t vaddr = paging::find_unmapped_vram_region(1);
+      paging::map_kernel_page(stack_paddr + 512 * i, vaddr, true, false);
+      for (int j = 0; j < 4096 / 8; ++j)
+        *(uint64_t *)(vaddr + j * 8) = 0;
+      paging::unmap_kernel_page(vaddr);
+    }
+    saved_regs.rsp = 0x40000000;
+  }
+
+  void app_instance::set_instruction_pointer(uint64_t vaddr) {
+    saved_regs.rip = vaddr;
+  }
+
+  uint64_t app_instance::count_mapped_vram_pages() {
+    uint64_t count = 0;
+    for (int i = 1; i < 512; ++i)
+      if (p2[i] != 0)
+        ++count;
+    return count;
+  }
+
+  app_instance *running_app;
+
+  static uint8_t correct_magic[16] = {
+    0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00,
+    0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00
+  };
+
+#define READ(a, b, c) \
+  { \
+    storage::fs_result _result = file.read_file(a, b, c); \
+    if (_result == storage::fs_result::device_error) \
+      return create_app_result::device_error; \
+    if (_result == storage::fs_result::fs_corrupt) \
+      return create_app_result::fs_corrupt; \
+  }
+
+  struct load_info {
+    uint64_t foffset;
+    uint64_t fsize;
+    uint64_t vaddr;
+    uint64_t vpages;
+    bool writable;
+    bool executable;
+  };
+
+  create_app_result create_app(const vfile::vfile &file, app_instance *&out) {
+
+    uint8_t magic[16];
+    if (file.dir_entry.length < 64)
+      return create_app_result::app_corrupt;
+    READ(0, 8, magic)
+    READ(16, 8, magic + 8)
+    for (int i = 0; i < 16; ++i)
+      if (magic[i] != correct_magic[i])
+        return create_app_result::app_corrupt;
+
+    uint64_t entry_point;
+    uint64_t phead_start;
+    uint16_t phead_entry_size;
+    uint16_t phead_entry_count;
+
+    READ(24, 8, &entry_point)
+    READ(32, 8, &phead_start)
+    READ(54, 2, &phead_entry_size)
+    READ(56, 2, &phead_entry_count)
+
+    if (file.dir_entry.length <
+        phead_start + phead_entry_size * phead_entry_count)
+      return create_app_result::app_corrupt;
+
+    utility::vector<load_info> load_infos;
+
+    for (uint16_t i = 0; i < phead_entry_count; ++i) {
+
+      uint64_t entry_start = phead_start + phead_entry_size * i;
+
+      uint32_t seg_type;
+      READ(entry_start, 4, &seg_type)
+      if (seg_type != 1)
+        continue;
+
+      uint64_t foffset;
+      uint64_t vaddr;
+      uint64_t fsize;
+      uint64_t vsize;
+      uint32_t flags;
+
+      READ(entry_start + 8, 8, &foffset)
+      READ(entry_start + 16, 8, &vaddr)
+      READ(entry_start + 32, 8, &fsize)
+      READ(entry_start + 40, 8, &vsize)
+      READ(entry_start + 4, 4, &flags)
+
+      if (vaddr & 0x1fffff)
+        return create_app_result::app_corrupt;
+      if (file.dir_entry.length < foffset + fsize)
+        return create_app_result::app_corrupt;
+      if (fsize > vsize)
+        return create_app_result::app_corrupt;
+      if (vaddr == 0)
+        return create_app_result::app_corrupt;
+
+      uint64_t vpages = (vsize - 1) / 0x200000 + 1;
+
+      if (vaddr + vpages * 0x200000 > ((1 << 30) - (4 << 20)))
+        return create_app_result::app_corrupt;
+
+      load_info info = {
+        .foffset = foffset,
+        .fsize = fsize,
+        .vaddr = vaddr,
+        .vpages = vpages,
+        .writable = (flags & 2) == 2,
+        .executable = (flags & 1) == 1
+      };
+      load_infos.add_end(info);
+
+    }
+
+    out = new app_instance();
+
+    for (unsigned i = 0; i < load_infos.count; ++i) {
+      const auto &info = load_infos.buffer[i];
+      for (uint64_t j = 0; j < info.vpages; ++j) {
+        uint64_t paddr = paging::take_2mib_pram_page();
+        out->map_page(info.vaddr + j * 0x200000, paddr,
+          info.writable, info.executable, true);
+        for (int k = 0; k < 512; ++k) {
+          uint64_t offset_in_segment = j * 0x200000 + k * 4096;
+          uint64_t kvaddr = paging::find_unmapped_vram_region(1);
+          paging::map_kernel_page(paddr + k * 4096, kvaddr, true, false);
+          storage::fs_result result = storage::fs_result::success;
+          if (info.fsize > offset_in_segment) {
+            if (info.fsize >= offset_in_segment + 4096)
+              result = file.read_file(
+                info.foffset + offset_in_segment, 4096, (void *)kvaddr);
+            else {
+              int to_read = info.fsize - offset_in_segment;
+              result = file.read_file(
+                info.foffset + offset_in_segment, to_read, (void *)kvaddr);
+              uint8_t *blank = (uint8_t *)(kvaddr + to_read);
+              for (int i = 0; i < 4096 - to_read; ++i)
+                blank[i] = 0;
+            }
+          }
+          else {
+            uint8_t *blank = (uint8_t *)kvaddr;
+            for (int i = 0; i < 4096; ++i)
+              blank[i] = 0;
+          }
+          paging::unmap_kernel_page(kvaddr);
+          if (result == storage::fs_result::device_error) {
+            delete out;
+            return create_app_result::device_error;
+          }
+          if (result == storage::fs_result::fs_corrupt) {
+            delete out;
+            return create_app_result::fs_corrupt;
+          }
+        }
+      }
+    }
+
+    out->create_stack();
+    out->set_instruction_pointer(entry_point);
+
+    return create_app_result::success;
+
+  }
+
+}
diff --git a/kernel/entry.cpp b/kernel/entry.cpp
index 445d560..f7ba71d 100644
--- a/kernel/entry.cpp
+++ b/kernel/entry.cpp
@@ -1,5 +1,6 @@
 #include <mercury/kernel/storage/bd/memory.hpp>
 #include <mercury/kernel/storage/fs/tarfs.hpp>
+#include <mercury/kernel/application.hpp>
 #include <mercury/kernel/framebuffer.hpp>
 #include <mercury/kernel/terminal.hpp>
 #include <mercury/kernel/limine.hpp>
@@ -103,6 +104,8 @@ uint64_t initfs_len;
 
 [[noreturn]] static void with_kernel_p4();
 
+extern "C" void load_gdt_and_idt();
+
 extern "C" [[noreturn]] void entry() {
 
   //TODO?: maybe we should check if the limine requests were
@@ -113,9 +116,9 @@ extern "C" [[noreturn]] void entry() {
   paging::mark_all_pram_used();
   auto memmap = memmap_request.response;
   for (uint64_t i = 0; i < memmap->entry_count; ++i) {
-    //we don't start allocating physical pages until after we are done using
-    //limine structures (specifically at the call to paging::map_kernel_stack),
-    //so we consider bootloader reclaimable to be free. usable and bootloader
+    //we don't allocate any physical pages until after we are done using limine
+    //structures (specifically at the call to paging::map_kernel_stacks), so
+    //we consider bootloader reclaimable to be free. usable and bootloader
     //reclaimable are guaranteed by limine spec to be page-aligned.
     auto entry = memmap->entries[i];
     if (entry->type == LIMINE_MEMMAP_USABLE ||
@@ -175,79 +178,29 @@ extern "C" [[noreturn]] void entry() {
 
   //switch to kernel p4
 
-  paging::map_kernel_stack();
+  paging::map_kernel_stacks();
+  load_gdt_and_idt();
   switch_to_kernel_p4(&with_kernel_p4);
 
 }
 
+static void print_mem() {
+  uint64_t used_vram_mib = (paging::get_used_vram_page_count() + 128) / 256;
+  uint64_t free_pram_mib = (paging::get_free_pram_page_count() + 128) / 256;
+  terminal::put_int_decimal(used_vram_mib);
+  terminal::put_string_sz(" MiB kernel memory mapped.\n");
+  terminal::put_int_decimal(free_pram_mib);
+  terminal::put_string_sz(" MiB physical memory free.\n");
+}
+
 [[noreturn]] static void print_and_halt(const char *msg) {
   terminal::put_string_sz(msg);
   while (1)
     asm ("hlt");
 }
 
-static void draw_indent(unsigned indent) {
-  for (unsigned i = 0; i < indent; ++i)
-    terminal::put_char(' ');
-}
-
-static void dir_tree(
-  const vfile::vfile &root, const vfile::vfile &f, unsigned indent
-) {
-
-  draw_indent(indent);
-  terminal::put_string(f.dir_entry.name);
-  terminal::put_char('\n');
-
-  std::optional<vfile::vfile> followed;
-  utility::vector<vfile::vfile> children;
-
-  switch (f.dir_entry.type) {
-
-    case storage::file_type::regular_file:
-      draw_indent(indent + 2);
-      terminal::put_string_sz("type: regular file\n");
-      draw_indent(indent + 2);
-      terminal::put_string_sz("length: ");
-      terminal::put_int_decimal(f.dir_entry.length);
-      terminal::put_string_sz(" bytes\n");
-      break;
-
-    case storage::file_type::symlink:
-      draw_indent(indent + 2);
-      terminal::put_string_sz("type: symlink\n");
-      draw_indent(indent + 2);
-      terminal::put_string_sz("target: ");
-      terminal::put_string(f.dir_entry.target);
-      terminal::put_char('\n');
-      if (f.follow_symlinks(root, followed) != storage::fs_result::success)
-        print_and_halt("failed to follow symlink.");
-      if (!followed) {
-        draw_indent(indent + 4);
-        terminal::put_string_sz("[broken]\n");
-      }
-      dir_tree(root, *followed, indent + 4);
-      break;
-
-    case storage::file_type::directory:
-      if (f.get_children(children) != storage::fs_result::success)
-        print_and_halt("failed to get children.");
-      draw_indent(indent + 2);
-      terminal::put_string_sz("type: directory\n");
-      draw_indent(indent + 2);
-      terminal::put_string_sz("children:\n");
-      if (children.count == 0) {
-        draw_indent(indent + 4);
-        terminal::put_string_sz("[empty]\n");
-      }
-      else
-        for (unsigned i = 0; i < children.count; ++i)
-          dir_tree(root, children.buffer[i], indent + 4);
-      break;
-
-  }
-
-}
+extern "C" [[noreturn]] void start_user_mode(
+  uint64_t rip, uint64_t rsp, uint64_t p4_paddr);
 
 [[noreturn]] static void with_kernel_p4() {
 
@@ -257,27 +210,46 @@ static void dir_tree(
   storage::fs::tarfs_instance initfs_fs(&initfs_bd);
   initfs_bd.mounted_as = &initfs_fs;
 
-  terminal::put_string_sz("kernel initialization complete.\n");
-
-  int used_vram_kib = paging::get_used_vram_page_count() * 4;
-  int free_pram_kib = paging::get_free_pram_page_count() * 4;
+  vfile::vfile vfs_root;
+  vfs_root.bd = &initfs_bd;
+  vfs_root.dir_entry.type = storage::file_type::directory;
+  vfs_root.path.absolute = true;
 
-  terminal::put_int_decimal(used_vram_kib);
-  terminal::put_string_sz(" kiB kernel memory mapped.\n");
-  terminal::put_int_decimal(free_pram_kib);
-  terminal::put_string_sz(" kiB physical memory free.\n");
+  if (initfs_fs.get_root_node(vfs_root.dir_entry.node) !=
+      storage::fs_result::success)
+    print_and_halt("failed to get root node of initfs.");
 
-  vfile::vfile root;
-  root.bd = &initfs_bd;
-  root.dir_entry.type = storage::file_type::directory;
-  root.path.absolute = true;
+  utility::string init_path_string("/bin/init.elf", 13);
+  vfile::canon_path init_path;
+  vfile::canonize_path(init_path_string, init_path);
 
-  if (initfs_fs.get_root_node(root.dir_entry.node) !=
+  std::optional<vfile::vfile> init_file;
+  if (vfile::lookup_path(vfs_root, init_path, init_file) !=
       storage::fs_result::success)
-    print_and_halt("failed to get root node.");
-
-  terminal::put_string_sz("initfs");
-  dir_tree(root, root, 0);
-  print_and_halt("halting.");
+    print_and_halt("failed to look up /bin/init.elf.");
+  if (!init_file)
+    print_and_halt("/bin/init.elf does not exist.");
+
+  terminal::put_string_sz("/bin/init.elf is ");
+  terminal::put_int_decimal(init_file->dir_entry.length);
+  terminal::put_string_sz(" bytes long.\n");
+
+  application::app_instance *init;
+  if (application::create_app(*init_file, init) !=
+      application::create_app_result::success)
+    print_and_halt("failed to parse /bin/init.elf.");
+
+  terminal::put_string_sz("/bin/init.elf loaded:\n  instruction pointer 0x");
+  terminal::put_int_hex(init->saved_regs.rip, 8);
+  terminal::put_string_sz("\n  stack pointer 0x");
+  terminal::put_int_hex(init->saved_regs.rsp, 8);
+  terminal::put_string_sz("\n  ");
+  terminal::put_int_decimal(init->count_mapped_vram_pages() * 2);
+  terminal::put_string_sz(" MiB userspace memory used\n");
+
+  print_mem();
+  terminal::put_string_sz("switching to /bin/init.elf.\n");
+  application::running_app = init;
+  start_user_mode(init->saved_regs.rip, init->saved_regs.rsp, init->p4_paddr);
 
 }
diff --git a/kernel/paging.cpp b/kernel/paging.cpp
index 8c27abc..17b61f4 100644
--- a/kernel/paging.cpp
+++ b/kernel/paging.cpp
@@ -10,9 +10,13 @@ extern "C" {
 namespace mercury::kernel::paging {
 
   static constexpr uint64_t kernel_vram_start = 0xffffffffc0000000;
-  static constexpr uint64_t kernel_vram_pages = 261888;
-  static constexpr uint64_t kernel_stack_bottom = 0xfffffffffff01000;
-  static constexpr uint64_t kernel_stack_top = 0xfffffffffffff000;
+  static constexpr uint64_t kernel_vram_end = 0xffffffffffe00000;
+  static constexpr uint64_t kernel_vram_pages =
+    (kernel_vram_end - kernel_vram_start) / 4096;
+  static constexpr uint64_t syscall_stack_bottom = 0xfffffffffff01000;
+  static constexpr uint64_t syscall_stack_top = 0xfffffffffffff000;
+  static constexpr uint64_t interrupt_stack_bottom = 0xffffffffffe01000;
+  static constexpr uint64_t interrupt_stack_top = 0xffffffffffeff000;
 
   static constexpr uint64_t pram_pages = 1 << 23;
   static uint64_t pram_usage_bitmap[pram_pages / 64];
@@ -32,25 +36,29 @@ namespace mercury::kernel::paging {
   [[gnu::aligned(4096)]] uint64_t kernel_p2[512];
   [[gnu::aligned(4096)]] uint64_t kernel_p1s[512 * 512];
 
-  static uint64_t encode_pte(
-      uint64_t addr, bool user, bool write, bool execute) {
+  uint64_t kernel_p4e;
+
+  uint64_t encode_pte(
+    uint64_t addr, bool user, bool write, bool execute, bool ps
+  ) {
     return (addr & 0x0000ffffffffffff) | (execute ? 0 : (1ULL << 63))
-         | (user << 2) | (write << 1) | 1;
+         | (ps << 7) | (user << 2) | (write << 1) | 1;
   }
 
   void init_kernel_page_tables(uint64_t kernel_offset) {
     __kernel_p4_paddr = (uint64_t)kernel_p4 - kernel_offset;
     for (int i = 0; i < 511; ++i)
       kernel_p4[i] = 0;
-    kernel_p4[511] = encode_pte(
-      (uint64_t)kernel_p3 - kernel_offset, false, true, true);
+    kernel_p4e = encode_pte(
+      (uint64_t)kernel_p3 - kernel_offset, false, true, true, false);
+    kernel_p4[511] = kernel_p4e;
     for (int i = 0; i < 511; ++i)
       kernel_p3[i] = 0;
     kernel_p3[511] = encode_pte(
-      (uint64_t)kernel_p2 - kernel_offset, false, true, true);
+      (uint64_t)kernel_p2 - kernel_offset, false, true, true, false);
     for (int i = 0; i < 512; ++i)
       kernel_p2[i] = encode_pte(
-        (uint64_t)kernel_p1s + 4096 * i - kernel_offset, false, true, true);
+        (uint64_t)kernel_p1s + 4096 * i - kernel_offset, false, true, true, false);
     for (int i = 0; i < 512 * 512; ++i)
       kernel_p1s[i] = 0;
   }
@@ -58,14 +66,22 @@ namespace mercury::kernel::paging {
   void map_kernel_page(
       uint64_t paddr, uint64_t vaddr, bool write, bool execute) {
     uint64_t i = (vaddr - kernel_vram_start) / 4096;
-    kernel_p1s[i] = encode_pte(paddr, false, write, execute);
+    kernel_p1s[i] = encode_pte(paddr, false, write, execute, false);
+  }
+
+  void unmap_kernel_page(uint64_t vaddr) {
+    uint64_t i = (vaddr - kernel_vram_start) / 4096;
+    kernel_p1s[i] = 0;
+    asm volatile (
+      "mov %%cr3, %%rax\nmov %%rax, %%cr3" ::: "%rax"
+    );
   }
 
   static uint64_t take_pram_page() {
     for (uint64_t i = 0; i < pram_pages / 64; ++i)
-      if (pram_usage_bitmap[i] != 0xffffffffffffffff)
+      if (~pram_usage_bitmap[i] != 0)
         for (int j = 0; j < 64; ++j)
-          if (!(pram_usage_bitmap[i] & (1ULL << j))) {
+          if (~pram_usage_bitmap[i] & (1ULL << j)) {
             pram_usage_bitmap[i] |= (1ULL << j);
             return 4096 * (i * 64 + j);
           }
@@ -73,9 +89,27 @@ namespace mercury::kernel::paging {
     return 0;
   }
 
-  void map_kernel_stack() {
-    for (uint64_t vaddr = kernel_stack_bottom;
-         vaddr < kernel_stack_top; vaddr += 4096)
+  uint64_t take_2mib_pram_page() {
+    for (uint64_t i = 0; i < pram_pages / 512; ++i) {
+      for (int j = 0; j < 8; ++j)
+        if (pram_usage_bitmap[i * 8 + j] != 0)
+          goto next_i;
+      for (int j = 0; j < 8; ++j)
+        pram_usage_bitmap[i * 8 + j] = ~0ULL;
+      return 0x200000 * i;
+    next_i:
+      ;
+    }
+    //TODO: handle error
+    return 0;
+  }
+
+  void map_kernel_stacks() {
+    for (uint64_t vaddr = syscall_stack_bottom;
+         vaddr < syscall_stack_top; vaddr += 4096)
+      map_kernel_page(take_pram_page(), vaddr, true, false);
+    for (uint64_t vaddr = interrupt_stack_bottom;
+         vaddr < interrupt_stack_top; vaddr += 4096)
       map_kernel_page(take_pram_page(), vaddr, true, false);
   }
 
@@ -103,6 +137,12 @@ namespace mercury::kernel::paging {
     return (void *)vaddr;
   }
 
+  void map_new_kernel_page(uint64_t &vaddr_out, uint64_t &paddr_out) {
+    vaddr_out = find_unmapped_vram_region(1);
+    paddr_out = take_pram_page();
+    map_kernel_page(paddr_out, vaddr_out, true, false);
+  }
+
   uint64_t get_used_vram_page_count() {
     uint64_t count = 0;
     for (uint64_t i = 0; i < kernel_vram_pages; ++i)
diff --git a/kernel/syscall.asm b/kernel/syscall.asm
new file mode 100644
index 0000000..56be8a4
--- /dev/null
+++ b/kernel/syscall.asm
@@ -0,0 +1,160 @@
+bits 64
+
+global load_gdt_and_idt
+global start_user_mode
+
+section .rodata
+
+;0x28 picked to align with limine choice
+;0x28 - kernel code
+;0x30 - kernel data
+;0x38 - user data
+;0x40 - user code
+
+gdtr:
+  dw 0x47
+  dq gdt
+
+gdt:
+  dq 0
+  dq 0
+  dq 0
+  dq 0
+  dq 0
+  dq 0x00209b0000000000
+  dq 0x00009b0000000000
+  dq 0x0000fb0000000000
+  dq 0x0020fb0000000000
+
+idtr:
+  dw 4095
+  dq idt
+
+idt:
+  times 256 - ($ - idt) / 16 dq 0
+
+section .text
+
+load_gdt_and_idt:
+  lgdt [gdtr]
+  lidt [idtr]
+  ret
+
+extern syscall_encode_color
+
+encode_color_syscall:
+  call syscall_encode_color
+  mov edi, eax
+  xor rax, rax
+  mov eax, edi
+  xor rdi, rdi
+  xor rsi, rsi
+  xor rdx, rdx
+  jmp syscall_return
+
+extern syscall_get_fb_vaddr
+extern syscall_get_fb_dims
+extern syscall_get_fb_pitch
+
+get_framebuffer_syscall:
+  call syscall_get_fb_vaddr
+  push rax
+  call syscall_get_fb_dims
+  push rax
+  call syscall_get_fb_pitch
+  xor rsi, rsi
+  mov esi, eax
+  pop rdi
+  pop rax
+  xor rdx, rdx
+  jmp syscall_return
+
+extern syscall_copy_framebuffer
+
+draw_framebuffer_syscall:
+  call syscall_copy_framebuffer
+  xor rax, rax
+  xor rdi, rdi
+  xor rsi, rsi
+  xor rdx, rdx
+  jmp syscall_return
+
+bad_syscall:
+  xor rax, rax
+  xor rdi, rdi
+  xor rsi, rsi
+  xor rdx, rdx
+  jmp syscall_return
+
+syscall_entry:
+  mov r11, rsp
+  mov rsp, 0xfffffffffffff000
+  push r11
+  push rcx
+
+  cmp rax, 0
+  je encode_color_syscall
+  cmp rax, 1
+  je get_framebuffer_syscall
+  cmp rax, 2
+  je draw_framebuffer_syscall
+  jmp bad_syscall
+
+syscall_return:
+  xor r8, r8
+  xor r9, r9
+  xor r10, r10
+  xor r11, r11
+  or r11, 0x200
+  pop rcx
+  pop rsp
+
+  o64 sysret
+
+start_user_mode:
+;intended rip in rdi
+;intended rsp in rsi
+;intended p4_paddr in rdx
+
+  mov rax, rdx
+  mov cr3, rax
+
+  ;efer <- efer | 0x1
+  mov rcx, 0xc0000080
+  rdmsr
+  or al, 1
+  wrmsr
+
+  ;lstar <- syscall_entry
+  mov rdx, syscall_entry
+  mov eax, edx
+  shr rdx, 32
+  mov ecx, 0xc0000082
+  wrmsr
+
+  ;star <- 0x0030.0028.0000.0000
+  mov edx, 0x00300028
+  xor eax, eax
+  mov ecx, 0xc0000081
+  wrmsr
+
+  mov rcx, rdi
+  mov rsp, rsi
+  xor r11, r11
+  or r11, 0x200
+
+  xor rax, rax
+  xor rbx, rbx
+  xor rdx, rdx
+  xor rdi, rdi
+  xor rsi, rsi
+  xor rbp, rbp
+  xor r8, r8
+  xor r9, r9
+  xor r10, r10
+  xor r12, r12
+  xor r13, r13
+  xor r14, r14
+  xor r15, r15
+
+  o64 sysret
diff --git a/kernel/syscall.cpp b/kernel/syscall.cpp
new file mode 100644
index 0000000..e91d12d
--- /dev/null
+++ b/kernel/syscall.cpp
@@ -0,0 +1,46 @@
+#include <mercury/kernel/application.hpp>
+#include <mercury/kernel/framebuffer.hpp>
+#include <mercury/kernel/paging.hpp>
+
+using namespace mercury::kernel;
+
+extern "C" uint32_t syscall_encode_color(uint32_t c) {
+  return (uint32_t)framebuffer::encode_color(
+    c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff
+  );
+}
+
+extern "C" uint64_t syscall_get_fb_vaddr() {
+  auto *app = application::running_app;
+  if (app->framebuffer_vaddr != 0)
+    return app->framebuffer_vaddr;
+  uint64_t fb_len = framebuffer::dword_pitch * framebuffer::height * 4;
+  uint64_t fb_pages = (fb_len - 1) / 0x200000 + 1;
+  uint64_t vaddr = app->get_free_vaddr_pages(fb_pages);
+  for (uint64_t i = 0; i < fb_pages; ++i) {
+    uint64_t paddr = paging::take_2mib_pram_page();
+    app->map_page(vaddr + i * 0x200000, paddr, true, false, true);
+  }
+  app->framebuffer_vaddr = vaddr;
+  return vaddr;
+}
+
+extern "C" uint64_t syscall_get_fb_dims() {
+  return (uint64_t)(uint32_t)framebuffer::width +
+    ((uint64_t)(uint32_t)framebuffer::height << 32);
+}
+
+extern "C" uint32_t syscall_get_fb_pitch() {
+  return (uint32_t)framebuffer::dword_pitch;
+}
+
+extern "C" void syscall_copy_framebuffer() {
+  auto *app = application::running_app;
+  if (app->framebuffer_vaddr != 0) {
+    const uint32_t *source = (const uint32_t *)app->framebuffer_vaddr;
+    for (int y = 0; y < framebuffer::height; ++y)
+      for (int x = 0; x < framebuffer::width; ++x)
+        framebuffer::vaddr[y * framebuffer::dword_pitch + x]
+          = source[y * framebuffer::dword_pitch + x];
+  }
+}
diff --git a/kernel/terminal.cpp b/kernel/terminal.cpp
index 59e1ee5..1074fe7 100644
--- a/kernel/terminal.cpp
+++ b/kernel/terminal.cpp
@@ -108,4 +108,14 @@ namespace mercury::kernel::terminal {
 
   }
 
+  static char hex_digits[] = "0123456789abcdef";
+
+  void put_int_hex(uint64_t n, int digits, bool with_dots) {
+    for (int digit = digits - 1; digit >= 0; --digit) {
+      put_char(hex_digits[(n >> (digit * 4)) & 0xf]);
+      if (with_dots && digit % 4 == 0 && digit != 0)
+        put_char('.');
+    }
+  }
+
 }
diff --git a/kernel/vfile.cpp b/kernel/vfile.cpp
index 9f549e5..3b9dcb2 100644
--- a/kernel/vfile.cpp
+++ b/kernel/vfile.cpp
@@ -163,6 +163,13 @@ namespace mercury::kernel::vfile {
 
   }
 
+  storage::fs_result vfile::read_file(
+    uint64_t start, uint64_t length, void *into
+  ) const {
+    return bd->mounted_as->read_bytes_from_file(
+      dir_entry.node, start, length, into);
+  }
+
   storage::fs_result lookup_path(
     const vfile &root, const canon_path &path, std::optional<vfile> &out
   ) {