reorganization, cross compiler

17 files changed, 2950 insertions, 0 deletions

diff --git a/kernel/source/allocator.cpp b/kernel/source/allocator.cpp
new file mode 100644
index 0000000..324f992
--- /dev/null
+++ b/kernel/source/allocator.cpp
@@ -0,0 +1,160 @@
+#include <hilbert/kernel/paging.hpp>
+#include <stddef.h>
+
+namespace hilbert::kernel::allocator {
+
+  struct free_entry {
+    uint64_t start;
+    uint64_t len;//0 for unused
+  };
+
+  struct free_page {
+    free_page *next;
+    free_entry entries[255];
+  };
+
+  free_page *first_page;
+
+  static_assert(sizeof(free_page) == 4088);
+
+  free_entry *get_entry(uint64_t start, uint64_t len) {
+    for (free_page *fp = first_page; fp; fp = fp->next)
+      for (int i = 0; i < 255; ++i)
+        if (fp->entries[i].start == start && fp->entries[i].len == len)
+          return fp->entries + i;
+    return 0;
+  }
+
+  void add_entry(uint64_t start, uint64_t len) {
+    for (free_page *fp = first_page; fp; fp = fp->next)
+      for (int i = 0; i < 255; ++i)
+        if (fp->entries[i].len == 0) {
+          fp->entries[i].start = start;
+          fp->entries[i].len = len;
+          return;
+        }
+    free_page *new_page = (free_page *)paging::map_new_kernel_pages(1);
+    new_page->next = first_page;
+    first_page = new_page;
+    for (int i = 2; i < 255; ++i)
+      new_page->entries[i].len = 0;
+    new_page->entries[0].start = (uint64_t)new_page + 4088;
+    new_page->entries[0].len = 8;
+    new_page->entries[1].start = start;
+    new_page->entries[1].len = len;
+  }
+
+  //len is power of 2, start is len-aligned
+  void free_block(uint64_t start, uint64_t len) {
+    free_entry *buddy = get_entry(start ^ len, len);
+    if (buddy) {
+      buddy->start = start & ~len;
+      buddy->len = len * 2;
+    }
+    else
+      add_entry(start, len);
+  }
+
+  void free_region(uint64_t start, uint64_t len) {
+    uint64_t block_size = 1;
+    while (block_size <= len) {
+      if (start & block_size) {
+        free_block(start, block_size);
+        start += block_size;
+        len -= block_size;
+      }
+      block_size *= 2;
+    }
+    while (len) {
+      block_size /= 2;
+      if (block_size <= len) {
+        free_block(start, block_size);
+        start += block_size;
+        len -= block_size;
+      }
+    }
+    //testing
+    if (len != 0)
+      while (1)
+        ;
+  }
+
+  uint64_t take_region(uint64_t len) {
+
+    uint64_t min_size = 1;
+    while (min_size < len)
+      min_size *= 2;
+
+    free_entry *entry = 0;
+
+    for (free_page *fp = first_page; fp; fp = fp->next)
+      for (int i = 0; i < 255; ++i)
+        if (fp->entries[i].len >= min_size) {
+          if (fp->entries[i].len == min_size) {
+            entry = fp->entries + i;
+            goto loop_done;
+          }
+          if (entry == 0 || fp->entries[i].len < entry->len)
+            entry = fp->entries + i;
+        }
+
+  loop_done:
+    if (entry != 0) {
+      uint64_t start = entry->start;
+      uint64_t block_len = entry->len;
+      entry->len = 0;
+      if (block_len != len)
+        free_region(start + len, block_len - len);
+      return start;
+    }
+
+    uint64_t pages = (len - 1) / 4096 + 1;
+    uint64_t start = (uint64_t)paging::map_new_kernel_pages(pages);
+    if (pages * 4096 != len)
+      free_region(start + len, pages * 4096 - len);
+    return start;
+
+  }
+
+}
+
+using namespace hilbert::kernel::allocator;
+
+void *_new(size_t len) {
+  if (len == 0)
+    return 0;
+  uint64_t vaddr = take_region(len + sizeof(size_t));
+  *(size_t *)vaddr = len;
+  return (void *)(vaddr + sizeof(size_t));
+}
+
+void _delete(void *ptr) {
+  if ((uint64_t)ptr == 0)
+    return;
+  uint64_t vaddr = (uint64_t)ptr - sizeof(size_t);
+  free_region(vaddr, *(size_t *)vaddr + sizeof(size_t));
+}
+
+void *operator new(size_t len) {
+  return _new(len);
+}
+
+void operator delete(void *ptr, size_t) {
+  return _delete(ptr);
+}
+
+void operator delete(void *ptr) {
+  return _delete(ptr);
+}
+
+void *operator new[](size_t len) {
+  return _new(len);
+}
+
+void operator delete[](void *ptr, size_t) {
+  return _delete(ptr);
+}
+
+void operator delete[](void *ptr) {
+  return _delete(ptr);
+}
diff --git a/kernel/source/application.asm b/kernel/source/application.asm
new file mode 100644
index 0000000..ed8b190
--- /dev/null
+++ b/kernel/source/application.asm
@@ -0,0 +1,171 @@
+bits 64
+
+extern do_syscall
+
+section .text
+
+syscall_entry:
+  mov r11, rsp
+  mov rsp, 0xfffffffffffff000
+  push r11
+  push rcx
+
+  push rdx
+  push rsi
+  push rdi
+  push rax
+
+  mov rdi, rsp
+  lea rsi, [rsp + 8]
+  lea rdx, [rsp + 16]
+  lea rcx, [rsp + 24]
+
+  call do_syscall
+
+  pop rax
+  pop rdi
+  pop rsi
+  pop rdx
+
+  xor r8, r8
+  xor r9, r9
+  xor r10, r10
+  xor r11, r11
+  or r11, 0x200
+  pop rcx
+  pop rsp
+
+  o64 sysret
+
+global init_applications_asm
+init_applications_asm:
+
+  ;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
+
+  ;sfmask <- 0x0000.0000.0000.0200 (if)
+  xor edx, edx
+  mov eax, 0x200
+  mov ecx, 0xc0000084
+  wrmsr
+
+  ret
+
+section .bss
+
+resume_stack:
+  resb 4096
+
+section .text
+
+extern restore_syscall_stack
+;rdi = pointer to copy
+;rsi = intended rsp
+
+global resume_thread
+resume_thread:
+;rdi = ptr to cpu_state
+;rdi is not inside stack
+;interrupts are disabled
+
+  mov al, byte [rdi + 160] ;in_syscall
+  test al, al
+  jnz .in_syscall
+
+  mov rax, 0x3b
+  mov rbx, 0x43
+
+.common:
+  push rax
+  mov rax, qword [rdi + 56] ;rsp
+  push rax
+  mov rax, qword [rdi + 128] ;rflags
+  push rax
+  push rbx
+  mov rax, qword [rdi + 136] ;rip
+  push rax
+
+  mov rax, qword [rdi + 144] ;cr3
+  mov cr3, rax
+
+  mov rax, qword [rdi]
+  mov rbx, qword [rdi + 8]
+  mov rcx, qword [rdi + 16]
+  mov rdx, qword [rdi + 24]
+  mov rsi, qword [rdi + 40]
+  mov rbp, qword [rdi + 48]
+  mov r8, qword [rdi + 64]
+  mov r9, qword [rdi + 72]
+  mov r10, qword [rdi + 80]
+  mov r11, qword [rdi + 88]
+  mov r12, qword [rdi + 96]
+  mov r13, qword [rdi + 104]
+  mov r14, qword [rdi + 112]
+  mov r15, qword [rdi + 120]
+  mov rdi, qword [rdi + 32]
+
+  iretq
+
+.in_syscall:
+  mov rsp, resume_stack + 4096
+
+  push rdi
+  mov rsi, qword [rdi + 56] ;rsp
+  mov rdi, qword [rdi + 152] ;kernel_stack_copy
+  call restore_syscall_stack
+  pop rdi
+
+  mov rax, 0x30
+  mov rbx, 0x28
+  jmp .common
+
+extern copy_syscall_stack
+;rdi = bottom
+
+global save_thread_state
+save_thread_state:
+;rdi = pointer to cpu state structure
+
+  ;only saving registers that need to be preserved by this function
+  mov qword [rdi + 8], rbx
+  mov qword [rdi + 48], rbp
+  mov qword [rdi + 56], rsp
+  mov qword [rdi + 96], r12
+  mov qword [rdi + 104], r13
+  mov qword [rdi + 112], r14
+  mov qword [rdi + 120], r15
+
+  mov qword [rdi + 136], .resume_to ;rip
+  mov rax, cr3
+  mov qword [rdi + 144], rax ;cr3
+
+  push rdi
+  lea rdi, [rsp + 8]
+  call copy_syscall_stack
+  pop rdi
+
+  mov qword [rdi + 152], rax ;kernel_stack_copy
+  mov byte [rdi + 160], 0x01 ;in_syscall
+
+  xor al, al
+  ret
+
+.resume_to:
+  mov al, 0x01
+  ret
diff --git a/kernel/source/application.cpp b/kernel/source/application.cpp
new file mode 100644
index 0000000..c3ce2f1
--- /dev/null
+++ b/kernel/source/application.cpp
@@ -0,0 +1,550 @@
+#include <hilbert/kernel/application.hpp>
+#include <hilbert/kernel/paging.hpp>
+#include <hilbert/kernel/panic.hpp>
+
+//TODO - scheduling.
+
+namespace hilbert::kernel::application {
+
+  process::process() : framebuffer_vaddr(0) {
+
+    uint64_t p4_vaddr;
+    paging::map_new_kernel_page(p4_vaddr, p4_paddr);
+    p4 = (uint64_t *)p4_vaddr;
+
+    uint64_t p3_paddr;
+    uint64_t p3_vaddr;
+    paging::map_new_kernel_page(p3_vaddr, p3_paddr);
+    p3 = (uint64_t *)p3_vaddr;
+
+    for (int i = 1; i < 511; ++i)
+      p4[i] = 0;
+    p4[0] = paging::encode_pte(p3_paddr, true, true, true);
+    p4[511] = paging::kernel_p4e;
+
+    for (int i = 0; i < 512; ++i) {
+      p3[i] = 0;
+      p2s[i] = 0;
+      p1s[i] = 0;
+      p1es_to_free_on_exit[i] = 0;
+    }
+
+  }
+
+  void process::map_page(uint64_t vaddr, uint64_t paddr,
+    bool write, bool execute, bool free_pram_on_exit
+  ) {
+
+    uint64_t i = ((vaddr / 4096) / 512) / 512;
+    uint64_t j = ((vaddr / 4096) / 512) % 512;
+    uint64_t k = (vaddr / 4096) % 512;
+
+    if (p2s[i] == 0) {
+      uint64_t p2_paddr;
+      uint64_t p2_vaddr;
+      paging::map_new_kernel_page(p2_vaddr, p2_paddr);
+      p3[i] = paging::encode_pte(p2_paddr, true, true, true);
+      p2s[i] = (uint64_t *)p2_vaddr;
+      p1s[i] = new uint64_t *[512];
+      p1es_to_free_on_exit[i] = new bool *[512];
+      for (int u = 0; u < 512; ++u) {
+        p2s[i][u] = 0;
+        p1s[i][u] = 0;
+        p1es_to_free_on_exit[i][u] = 0;
+      }
+    }
+
+    if (p2s[i][j] == 0) {
+      uint64_t p1_paddr;
+      uint64_t p1_vaddr;
+      paging::map_new_kernel_page(p1_vaddr, p1_paddr);
+      p2s[i][j] = paging::encode_pte(p1_paddr, true, true, true);
+      p1s[i][j] = (uint64_t *)p1_vaddr;
+      p1es_to_free_on_exit[i][j] = new bool[512];
+      for (int u = 0; u < 512; ++u) {
+        p1s[i][j][u] = 0;
+        p1es_to_free_on_exit[i][j][u] = false;
+      }
+    }
+
+    p1s[i][j][k] = paging::encode_pte(paddr, true, write, execute);
+    p1es_to_free_on_exit[i][j][k] = free_pram_on_exit;
+
+  }
+
+  bool process::is_page_owned(uint64_t vaddr) {
+    uint64_t i = ((vaddr / 4096) / 512) / 512;
+    uint64_t j = ((vaddr / 4096) / 512) % 512;
+    uint64_t k = (vaddr / 4096) % 512;
+    return
+      i < 512 && p1s[i] != 0 && p1s[i][j] != 0 &&
+      p1s[i][j][k] != 0 && p1es_to_free_on_exit[i][j][k];
+  }
+
+  uint64_t process::get_free_vaddr_pages(uint64_t count) {
+    uint64_t start = 0x200000 / 4096;
+    uint64_t length = 0;
+    while (start + length <= 0x8000000000 / 4096) {
+      if (length == count)
+        return start * 4096;
+      int i = ((start + length) / 512) / 512;
+      int j = ((start + length) / 512) % 512;
+      int k = (start + length) % 512;
+      if (p1s[i] == 0 || p1s[i][j] == 0 || p1s[i][j][k] == 0)
+        ++length;
+      else {
+        start += length + 1;
+        length = 0;
+      }
+    }
+    //TODO: handle out of memory
+    return 0;
+  }
+
+  uint64_t process::count_mapped_vram_pages() {
+    uint64_t count = 0;
+    for (int i = 0; i < 512; ++i)
+      if (p1s[i] != 0)
+        for (int j = 0; j < 512; ++j)
+          if (p1s[i][j] != 0)
+            for (int k = 0; k < 512; ++k)
+              if (p1s[i][j][k] != 0)
+                ++count;
+    return count;
+  }
+
+  utility::id_allocator<process *> *processes;
+  utility::queue<thread *> *paused_threads;
+  utility::queue<thread *> *threads_waiting_for_input;
+  thread *running_thread;
+  utility::list<socket_listener *> *all_socket_listeners;
+
+  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::success) \
+      return stream_result::io_error; \
+  }
+
+#define TRY_MAR(expr) \
+  { \
+    storage::fs_result _result = expr; \
+    if (_result != storage::fs_result::success) { \
+      delete process_out; \
+      return stream_result::io_error; \
+    } \
+  }
+
+  struct load_info {
+    uint64_t foffset;
+    uint64_t fsize;
+    uint64_t vaddr;
+    uint64_t voffset;
+    uint64_t vpages;
+    bool writable;
+    bool executable;
+  };
+
+  storage::fs_result map_and_read(
+    const vfile::vfile &file, process *process, uint64_t vaddr, uint64_t faddr,
+    uint64_t len, bool writable, bool executable
+  ) {
+
+    uint64_t page_vaddr = vaddr & ~4095;
+    int at_start = vaddr & 4095;
+    int at_end = 4096 - len - at_start;
+
+    uint64_t page_paddr = paging::take_pram_page();
+    process->map_page(page_vaddr, page_paddr, writable, executable, true);
+    uint64_t page_kvaddr = paging::find_unmapped_vram_region(1);
+    paging::map_kernel_page(page_paddr, page_kvaddr, true, false);
+
+    storage::fs_result result = storage::fs_result::success;
+
+    if (at_start) {
+      uint8_t *blank = (uint8_t *)page_kvaddr;
+      for (int i = 0; i < at_start; ++i)
+        blank[i] = 0;
+    }
+
+    if (len != 0)
+      result = file.read_file(faddr, len, (void *)(page_kvaddr + at_start));
+
+    if (at_end) {
+      uint8_t *blank = (uint8_t *)(page_kvaddr + at_start + len);
+      for (int i = 0; i < at_end; ++i)
+        blank[i] = 0;
+    }
+
+    paging::unmap_kernel_page(page_kvaddr);
+    return result;
+
+  }
+
+  stream_result create_application(
+    const vfile::vfile &file, process *&process_out, thread *&thread_out
+  ) {
+
+    uint8_t magic[16];
+    if (file.dir_entry.type != storage::file_type::regular_file)
+      return stream_result::not_a_regular_file;
+    if (file.dir_entry.length < 64)
+      return stream_result::not_an_executable;
+    READ(0, 8, magic)
+    READ(16, 8, magic + 8)
+    for (int i = 0; i < 16; ++i)
+      if (magic[i] != correct_magic[i])
+        return stream_result::not_an_executable;
+
+    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 stream_result::not_an_executable;
+
+    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 voffset;
+      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)
+
+      voffset = vaddr % 4096;
+      vaddr -= voffset;
+
+      if (vsize == 0)
+        continue;
+
+      if (file.dir_entry.length < foffset + fsize)
+        return stream_result::not_an_executable;
+      if (fsize > vsize)
+        return stream_result::not_an_executable;
+
+      if (vaddr < 0x200000)
+        return stream_result::not_an_executable;
+
+      uint64_t vpages = (voffset + vsize - 1) / 4096 + 1;
+
+      if (vaddr + vpages * 4096 > 0x8000000000)
+        return stream_result::not_an_executable;
+
+      load_info info = {
+        .foffset = foffset,
+        .fsize = fsize,
+        .vaddr = vaddr,
+        .voffset = voffset,
+        .vpages = vpages,
+        .writable = (flags & 2) == 2,
+        .executable = (flags & 1) == 1
+      };
+      load_infos.add_end(info);
+
+    }
+
+    process_out = new process();
+
+    for (unsigned i = 0; i < load_infos.count; ++i) {
+      const auto &info = load_infos.buffer[i];
+
+      uint64_t vaddr = info.vaddr + info.voffset;
+      uint64_t faddr = info.foffset;
+      uint64_t v_remaining = info.vpages * 4096 - info.voffset;
+      uint64_t f_remaining = info.fsize;
+
+      if (info.voffset != 0) {
+        int to_read = info.fsize < 4096 - info.voffset
+                    ? info.fsize : 4096 - info.voffset;
+        if (to_read > 0) {
+          TRY_MAR(map_and_read(file, process_out, vaddr, faddr, to_read,
+            info.writable, info.executable))
+          vaddr += to_read;
+          faddr += to_read;
+          v_remaining -= to_read;
+          f_remaining -= to_read;
+        }
+      }
+
+      while (f_remaining > 0) {
+        int to_read = f_remaining < 4096 ? f_remaining : 4096;
+        TRY_MAR(map_and_read(file, process_out, vaddr, faddr, to_read,
+          info.writable, info.executable))
+        vaddr += to_read;
+        faddr += to_read;
+        v_remaining -= to_read;
+        f_remaining -= to_read;
+      }
+
+      if (vaddr & 4095) {
+        v_remaining -= 4096 - (vaddr & 4095);
+        vaddr += 4096 - (vaddr & 4095);
+      }
+
+      while (v_remaining > 0) {
+        map_and_read(
+          file, process_out, vaddr, 0, 0, info.writable, info.executable);
+        vaddr += 4096;
+        v_remaining -= 4096;
+      }
+
+    }
+
+    for (uint64_t vaddr = 0x1000; vaddr < 0x1ff000; vaddr += 4096) {
+      uint64_t paddr = paging::take_pram_page();
+      uint64_t kvaddr = paging::find_unmapped_vram_region(1);
+      paging::map_kernel_page(paddr, kvaddr, true, false);
+      uint8_t *p = (uint8_t *)kvaddr;
+      for (int i = 0; i < 4096; ++i)
+        p[i] = 0;
+      paging::unmap_kernel_page(kvaddr);
+      process_out->map_page(vaddr, paddr, true, false, true);
+    }
+
+    thread_out = new thread();
+    process_out->threads.insert_end(thread_out);
+    thread_out->the_process = process_out;
+
+    thread_out->state = thread_state::paused;
+
+    thread_out->cpu.rax = 0;
+    thread_out->cpu.rbx = 0;
+    thread_out->cpu.rcx = 0;
+    thread_out->cpu.rdx = 0;
+    thread_out->cpu.rdi = 0;
+    thread_out->cpu.rsi = 0;
+    thread_out->cpu.rbp = 0;
+    thread_out->cpu.rsp = 0x1ff000;
+    thread_out->cpu.r8 = 0;
+    thread_out->cpu.r9 = 0;
+    thread_out->cpu.r10 = 0;
+    thread_out->cpu.r11 = 0;
+    thread_out->cpu.r12 = 0;
+    thread_out->cpu.r13 = 0;
+    thread_out->cpu.r14 = 0;
+    thread_out->cpu.r15 = 0;
+
+    thread_out->cpu.rflags = 0x200;
+    thread_out->cpu.rip = entry_point;
+    thread_out->cpu.cr3 = process_out->p4_paddr;
+    thread_out->cpu.in_syscall = false;
+
+    return stream_result::success;
+
+  }
+
+  extern "C" void init_applications_asm();
+
+  void init_applications() {
+    processes = new utility::id_allocator<process *>();
+    paused_threads = new utility::queue<thread *>();
+    threads_waiting_for_input = new utility::queue<thread *>();
+    all_socket_listeners = new utility::list<socket_listener *>();
+    init_applications_asm();
+  }
+
+  //only called from non-interruptable contexts.
+  //cpu argument not on stack.
+  extern "C" [[noreturn]] void resume_thread(const cpu_state &cpu);
+
+  extern "C" void *copy_syscall_stack(uint8_t *rsp) {
+    uint64_t size = 0xfffffffffffff000 - (uint64_t)rsp;
+    uint8_t *buffer = new uint8_t[size];
+    for (uint64_t i = 0; i < size; ++i)
+      buffer[i] = rsp[i];
+    return buffer;
+  }
+
+  extern "C" void restore_syscall_stack(const uint8_t *from, uint8_t *rsp) {
+    uint64_t size = 0xfffffffffffff000 - (uint64_t)rsp;
+    for (uint64_t i = 0; i < size; ++i)
+      rsp[i] = from[i];
+    delete[] from;
+  }
+
+  thread::~thread() {
+    for (auto *p = the_process->threads.first; p; p = p->next)
+      if (p->value == this) {
+        the_process->threads.remove(p);
+        break;
+      }
+    if (the_process->threads.first == 0) {
+      the_process->exit_code = exit_code;
+      the_process->cleanup();
+    }
+    if (state != thread_state::running)
+      panic(0x9af5e6);
+  }
+
+  [[noreturn]] void resume_next() {
+    while (paused_threads->count == 0)
+      asm volatile ("sti\nhlt\ncli");
+    auto *t = paused_threads->take();
+    running_thread = t;
+    t->state = thread_state::running;
+    resume_thread(t->cpu);
+  }
+
+  void process::end_process(unsigned exit_code) {
+    while (threads.first != 0)
+      delete threads.first->value;
+    this->exit_code = exit_code;
+    cleanup();
+  }
+
+  void process::cleanup() {
+    //TODO
+    panic(0x9af5e6);
+  }
+
+  socket_stream::socket_stream(socket *sock, bool are_we_b)
+    : sock(sock), are_we_b(are_we_b),
+      our_threads_waiting_to_read(are_we_b
+        ? sock->process_b_threads_waiting_to_read
+        : sock->process_a_threads_waiting_to_read),
+      their_threads_waiting_to_read(are_we_b
+        ? sock->process_a_threads_waiting_to_read
+        : sock->process_b_threads_waiting_to_read),
+      them_to_us(are_we_b ? sock->a_to_b : sock->b_to_a),
+      us_to_them(are_we_b ? sock->b_to_a : sock->a_to_b),
+      them_closed(are_we_b ? sock->a_closed : sock->b_closed),
+      us_closed(are_we_b ? sock->b_closed : sock->a_closed) {}
+
+  stream_result socket_stream::seek(seek_origin, int64_t) {
+    return stream_result::not_seekable;
+  }
+
+  stream_result socket_stream::read(uint64_t count, void *into) {
+    uint8_t *buffer = (uint8_t *)into;
+    for (uint64_t i = 0; i < count; ++i) {
+      while (them_to_us.count == 0) {
+        if (them_closed)
+          return stream_result::other_end_closed;
+        if (!save_thread_state(running_thread->cpu)) {
+          running_thread->state = thread_state::waiting;
+          our_threads_waiting_to_read.insert(running_thread);
+          resume_next();
+        }
+      }
+      buffer[i] = them_to_us.take();
+    }
+    return stream_result::success;
+  }
+
+  stream_result socket_stream::write(uint64_t count, const void *from) {
+    if (them_closed)
+      return stream_result::other_end_closed;
+    const uint8_t *buffer = (const uint8_t *)from;
+    for (uint64_t i = 0; i < count; ++i) {
+      if (their_threads_waiting_to_read.count > 0) {
+        auto *ot = their_threads_waiting_to_read.take();
+        ot->state = thread_state::paused;
+        paused_threads->insert(ot);
+      }
+      us_to_them.insert(buffer[i]);
+    }
+    return stream_result::success;
+  }
+
+  stream_result socket_stream::get_length(uint64_t &) {
+    return stream_result::not_sized;
+  }
+
+  stream_result socket_stream::set_length(uint64_t) {
+    return stream_result::not_sized;
+  }
+
+  socket_stream::~socket_stream() {
+    if (our_threads_waiting_to_read.count > 0)
+      panic(0x9af5e6);
+    if (them_closed)
+      delete sock;
+    else {
+      us_closed = true;
+      while (their_threads_waiting_to_read.count > 0) {
+        auto *t = their_threads_waiting_to_read.take();
+        t->state = thread_state::paused;
+        paused_threads->insert(t);
+      }
+    }
+  }
+
+  vfile_stream::vfile_stream(vfile::vfile &&file)
+    : file(utility::move(file)), offset(0) {}
+
+  stream_result vfile_stream::seek(seek_origin origin, int64_t offset) {
+    uint64_t start_at = {};
+    switch (origin) {
+    case seek_origin::beginning:
+      start_at = 0;
+      break;
+    case seek_origin::end:
+      start_at = file.dir_entry.length;
+      break;
+    case seek_origin::current_position:
+      start_at = this->offset;
+      break;
+    }
+    if (offset < 0 && (uint64_t)-offset > start_at)
+      return stream_result::out_of_bounds;
+    if (offset + start_at > file.dir_entry.length)
+      return stream_result::out_of_bounds;
+    this->offset = start_at + offset;
+    return stream_result::success;
+  }
+
+  stream_result vfile_stream::read(uint64_t count, void *into) {
+    if (offset + count > file.dir_entry.length)
+      return stream_result::out_of_bounds;
+    if (file.read_file(offset, count, into) != storage::fs_result::success)
+      return stream_result::io_error;
+    offset += count;
+    return stream_result::success;
+  }
+
+  stream_result vfile_stream::write(uint64_t count, const void *from) {
+    if (offset + count > file.dir_entry.length)
+      return stream_result::out_of_bounds;
+    (void)from;
+    panic(0x9af5e6);
+  }
+
+  stream_result vfile_stream::get_length(uint64_t &out) {
+    out = file.dir_entry.length;
+    return stream_result::success;
+  }
+
+  stream_result vfile_stream::set_length(uint64_t to) {
+    (void)to;
+    panic(0x9af5e6);
+  }
+
+}
diff --git a/kernel/source/entry.cpp b/kernel/source/entry.cpp
new file mode 100644
index 0000000..820b107
--- /dev/null
+++ b/kernel/source/entry.cpp
@@ -0,0 +1,222 @@
+#include <hilbert/kernel/storage/bd/memory.hpp>
+#include <hilbert/kernel/storage/fs/tarfs.hpp>
+#include <hilbert/kernel/application.hpp>
+#include <hilbert/kernel/framebuffer.hpp>
+#include <hilbert/kernel/paging.hpp>
+#include <hilbert/kernel/input.hpp>
+#include <hilbert/kernel/panic.hpp>
+#include <hilbert/kernel/vfile.hpp>
+#include <limine.h>
+
+using namespace hilbert::kernel;
+
+LIMINE_BASE_REVISION(1)
+
+static volatile limine_memmap_request memmap_request {
+  .id = LIMINE_MEMMAP_REQUEST,
+  .revision = 0,
+  .response = 0
+};
+
+static volatile limine_kernel_address_request kernel_address_request {
+  .id = LIMINE_KERNEL_ADDRESS_REQUEST,
+  .revision = 0,
+  .response = 0
+};
+
+static volatile limine_framebuffer_request framebuffer_request {
+  .id = LIMINE_FRAMEBUFFER_REQUEST,
+  .revision = 0,
+  .response = 0
+};
+
+static volatile limine_hhdm_request hhdm_request {
+  .id = LIMINE_HHDM_REQUEST,
+  .revision = 0,
+  .response = 0
+};
+
+static volatile limine_module_request module_request = {
+  .id = LIMINE_MODULE_REQUEST,
+  .revision = 2,
+  .response = 0,
+  .internal_module_count = 0,
+  .internal_modules = 0
+};
+
+bool try_map_module_by_cmdline(
+  const char *cmdline, void *&vaddr_out, uint64_t &len_out
+) {
+  auto response = module_request.response;
+  if (!response)
+    return false;
+  for (uint64_t i = 0; i < response->module_count; ++i) {
+    limine_file *file = response->modules[i];
+    for (uint64_t j = 0; cmdline[j] == file->cmdline[j]; ++j)
+      if (!cmdline[j]) {
+
+        //module start is guaranteed to be page-aligned, end is not.
+        uint64_t start_paddr =
+          (uint64_t)file->address - hhdm_request.response->offset;
+        uint64_t end_paddr =
+          ((start_paddr + file->size - 1) / 4096 + 1) * 4096;
+
+        uint64_t start_vaddr =
+          paging::find_unmapped_vram_region((end_paddr - start_paddr) / 4096);
+        for (uint64_t i = 0; i < end_paddr - start_paddr; i += 4096)
+          paging::map_kernel_page(
+            start_paddr + i, start_vaddr + i, true, false);
+
+        vaddr_out = (void *)start_vaddr;
+        len_out = file->size;
+
+        return true;
+      }
+  }
+  return false;
+}
+
+//defined in linker script, page-aligned:
+extern uint8_t __kernel_start;
+extern uint8_t __kernel_end;
+extern uint8_t __kernel_rx_start;
+extern uint8_t __kernel_rx_end;
+extern uint8_t __kernel_ro_start;
+extern uint8_t __kernel_ro_end;
+extern uint8_t __kernel_rw_start;
+extern uint8_t __kernel_rw_end;
+
+uint8_t *initfs;
+uint64_t initfs_len;
+
+[[noreturn]] static void with_kernel_p4();
+
+extern "C" void load_gdt_and_idt();
+
+static bool have_initfs;
+
+extern "C" [[noreturn]] void entry() {
+
+  //TODO?: maybe we should check if the limine requests were
+  //       fulfilled and display some error message if not
+
+  //set up the physical memory usage bitmap:
+
+  paging::mark_all_pram_used();
+  auto memmap = memmap_request.response;
+  for (uint64_t i = 0; i < memmap->entry_count; ++i) {
+    //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 ||
+        entry->type == LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE)
+      paging::mark_pram_region_free(entry->base, entry->base + entry->length);
+  }
+
+  //set up page mappings:
+
+  auto kernel_address = kernel_address_request.response;
+  uint64_t kernel_offset = kernel_address->virtual_base
+                         - kernel_address->physical_base;
+
+  uint64_t hhdm = hhdm_request.response->offset;
+
+  //framebuffer might not be page-aligned
+  auto framebuffer = framebuffer_request.response->framebuffers[0];
+  uint64_t fb_start = ((uint64_t)framebuffer->address / 4096) * 4096 - hhdm;
+  uint64_t fb_end = (uint64_t)framebuffer->address
+                  + framebuffer->pitch * framebuffer->height - hhdm;
+  fb_end = ((fb_end - 1) / 4096 + 1) * 4096;
+
+  paging::init_kernel_page_tables(kernel_offset);
+
+  //kernel image rx
+  for (uint64_t vaddr = (uint64_t)&__kernel_rx_start;
+       vaddr < (uint64_t)&__kernel_rx_end; vaddr += 4096)
+    paging::map_kernel_page(vaddr - kernel_offset, vaddr, false, true);
+
+  //kernel image ro
+  for (uint64_t vaddr = (uint64_t)&__kernel_ro_start;
+       vaddr < (uint64_t)&__kernel_ro_end; vaddr += 4096)
+    paging::map_kernel_page(vaddr - kernel_offset, vaddr, false, false);
+
+  //kernel image rw
+  for (uint64_t vaddr = (uint64_t)&__kernel_rw_start;
+       vaddr < (uint64_t)&__kernel_rw_end; vaddr += 4096)
+    paging::map_kernel_page(vaddr - kernel_offset, vaddr, true, false);
+
+  //framebuffer
+  uint64_t fb_vaddr =
+    paging::find_unmapped_vram_region((fb_end - fb_start) / 4096);
+  for (uint64_t i = 0; i < fb_end - fb_start; i += 4096)
+    paging::map_kernel_page(fb_start + i, fb_vaddr + i, true, false);
+
+  have_initfs =
+    try_map_module_by_cmdline("initfs", (void *&)initfs, initfs_len);
+
+  //set up framebuffer and terminal:
+  //TODO: assumes framebuffer is 32-bpp rgb
+
+  framebuffer::init_framebuffer(fb_start, fb_vaddr,
+    framebuffer->width, framebuffer->height, framebuffer->pitch);
+
+  //switch to kernel p4
+
+  paging::map_kernel_stacks();
+  load_gdt_and_idt();
+  switch_to_kernel_p4(&with_kernel_p4);
+
+}
+
+[[noreturn]] static void with_kernel_p4() {
+
+  if (!have_initfs)
+    panic(0x5f8860);
+
+  input::init_input();
+  application::init_applications();
+
+  auto *initfs_bd = new storage::bd::memory(initfs, initfs_len);
+  auto *initfs_fs = new storage::fs::tarfs_instance(initfs_bd);
+  initfs_bd->mounted_as = initfs_fs;
+
+  vfile::vfile initfs_root;
+  initfs_root.bd = initfs_bd;
+  initfs_root.dir_entry.type = storage::file_type::directory;
+  initfs_root.path.absolute = true;
+
+  if (initfs_fs->get_root_node(initfs_root.dir_entry.node) !=
+      storage::fs_result::success)
+    panic(0x48a6ed);
+
+  vfile::set_root(initfs_root);
+
+  utility::string init_path_string("/bin/init", 9);
+  vfile::canon_path init_path;
+  vfile::canonize_path(init_path_string, init_path);
+
+  vfile::vfile init_file;
+  if (vfile::lookup_path(init_path, init_file, true) !=
+      storage::fs_result::success)
+    panic(0x7e874d);
+
+  application::process *init_process;
+  application::thread *init_thread;
+  if (application::create_application(init_file, init_process, init_thread) !=
+      application::stream_result::success)
+    panic(0xc39db3);
+
+  init_process->environment.add_end({
+    .a = utility::string("ARGC", 4),
+    .b = utility::string("1", 1)});
+  init_process->environment.add_end({
+    .a = utility::string("ARGV0", 5),
+    .b = utility::string("/bin/init", 9)});
+
+  init_thread->state = application::thread_state::paused;
+  application::paused_threads->insert(init_thread);
+  application::resume_next();
+
+}
diff --git a/kernel/source/framebuffer.cpp b/kernel/source/framebuffer.cpp
new file mode 100644
index 0000000..ab1b3d7
--- /dev/null
+++ b/kernel/source/framebuffer.cpp
@@ -0,0 +1,40 @@
+#include <hilbert/kernel/application.hpp>
+#include <hilbert/kernel/framebuffer.hpp>
+
+namespace hilbert::kernel::framebuffer {
+
+  uint64_t paddr;
+  static uint32_t *vaddr;
+  int width;
+  int height;
+  int dword_pitch;
+
+  void init_framebuffer(uint64_t paddr, uint64_t vaddr,
+    uint64_t width, uint64_t height, uint64_t pitch
+  ) {
+
+    //TODO: assumes 32-bpp rgb
+
+    framebuffer::paddr = paddr;
+    framebuffer::vaddr = (uint32_t *)vaddr;
+    framebuffer::width = width;
+    framebuffer::height = height;
+    dword_pitch = pitch / 4;
+
+  }
+
+  color encode_color(uint8_t r, uint8_t g, uint8_t b) {
+    return ((uint32_t)r << 16) | ((uint32_t)g << 8) | (uint32_t)b;
+  }
+
+  void set_pixel(int x, int y, color c) {
+    vaddr[y * dword_pitch + x] = c;
+  }
+
+  void fill_color(color c) {
+    for (int y = 0; y < height; ++y)
+      for (int x = 0; x < width; ++x)
+        vaddr[y * dword_pitch + x] = c;
+  }
+
+}
diff --git a/kernel/source/input.cpp b/kernel/source/input.cpp
new file mode 100644
index 0000000..696cb13
--- /dev/null
+++ b/kernel/source/input.cpp
@@ -0,0 +1,22 @@
+#include <hilbert/kernel/application.hpp>
+#include <hilbert/kernel/input.hpp>
+#include <hilbert/kernel/panic.hpp>
+#include <hilbert/kernel/vfile.hpp>
+
+namespace hilbert::kernel::input {
+
+  utility::queue<uint32_t> *key_queue;
+
+  void init_input() {
+    key_queue = new utility::queue<uint32_t>();
+  }
+
+  void got_input() {
+    if (application::threads_waiting_for_input->count > 0) {
+      auto *t = application::threads_waiting_for_input->take();
+      t->state = application::thread_state::paused;
+      application::paused_threads->insert(t);
+    }
+  }
+
+}
diff --git a/kernel/source/interrupts.asm b/kernel/source/interrupts.asm
new file mode 100644
index 0000000..babc020
--- /dev/null
+++ b/kernel/source/interrupts.asm
@@ -0,0 +1,340 @@
+bits 64
+
+global load_gdt_and_idt
+
+section .rodata
+
+;0x28 picked to align with limine choice
+
+;0x18 - tss
+;0x28 - kernel code
+;0x30 - kernel data
+;0x38 - user data
+;0x40 - user code
+
+tss:
+  times 9 dd 0
+  dq 0xffffffffffeff000
+  times 15 dd 0
+
+gdtr:
+  dw 0x47
+  dq gdt
+
+idtr:
+  dw 4095
+  dq idt
+
+section .bss
+
+idt:
+  resq 512
+
+global exception_info
+exception_info:
+.rax:
+  resq 1
+.rbx:
+  resq 1
+.rcx:
+  resq 1
+.rdx:
+  resq 1
+.rdi:
+  resq 1
+.rsi:
+  resq 1
+.rbp:
+  resq 1
+.rsp:
+  resq 1
+.r8:
+  resq 1
+.r9:
+  resq 1
+.r10:
+  resq 1
+.r11:
+  resq 1
+.r12:
+  resq 1
+.r13:
+  resq 1
+.r14:
+  resq 1
+.r15:
+  resq 1
+.cr2:
+  resq 1
+.cr3:
+  resq 1
+.rip:
+  resq 1
+.rflags:
+  resq 1
+.error:
+  resq 1
+.has_error:
+  resb 1
+.exception_number:
+  resb 1
+
+section .rodata
+
+has_error_code:
+  db 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0
+
+exception_isrs:
+  dq exception_00, exception_01, exception_02, exception_03
+  dq exception_04, exception_05, exception_06, exception_07
+  dq exception_08, exception_09, exception_0a, exception_0b
+  dq exception_0c, exception_0d, exception_0e, exception_0f
+
+section .text
+
+extern print_exception
+
+exception_00:
+  mov byte [exception_info.exception_number], 0x00
+  jmp exception_common
+exception_01:
+  mov byte [exception_info.exception_number], 0x01
+  jmp exception_common
+exception_02:
+  mov byte [exception_info.exception_number], 0x02
+  jmp exception_common
+exception_03:
+  mov byte [exception_info.exception_number], 0x03
+  jmp exception_common
+exception_04:
+  mov byte [exception_info.exception_number], 0x04
+  jmp exception_common
+exception_05:
+  mov byte [exception_info.exception_number], 0x05
+  jmp exception_common
+exception_06:
+  mov byte [exception_info.exception_number], 0x06
+  jmp exception_common
+exception_07:
+  mov byte [exception_info.exception_number], 0x07
+  jmp exception_common
+exception_08:
+  mov byte [exception_info.exception_number], 0x08
+  jmp exception_common
+exception_09:
+  mov byte [exception_info.exception_number], 0x09
+  jmp exception_common
+exception_0a:
+  mov byte [exception_info.exception_number], 0x0a
+  jmp exception_common
+exception_0b:
+  mov byte [exception_info.exception_number], 0x0b
+  jmp exception_common
+exception_0c:
+  mov byte [exception_info.exception_number], 0x0c
+  jmp exception_common
+exception_0d:
+  mov byte [exception_info.exception_number], 0x0d
+  jmp exception_common
+exception_0e:
+  mov byte [exception_info.exception_number], 0x0e
+  jmp exception_common
+exception_0f:
+  mov byte [exception_info.exception_number], 0x0f
+  jmp exception_common
+
+exception_common:
+  mov qword [exception_info.rax], rax
+
+  movzx rax, byte [exception_info.exception_number]
+  mov al, byte [has_error_code + rax]
+  test al, al
+  jz .no_error_code
+
+  mov byte [exception_info.has_error], 1
+  pop rax
+  mov qword [exception_info.error], rax
+  jmp .post_error_code
+
+.no_error_code:
+  mov byte [exception_info.has_error], 0
+
+.post_error_code:
+  mov qword [exception_info.rbx], rbx
+  mov qword [exception_info.rcx], rcx
+  mov qword [exception_info.rdx], rdx
+  mov qword [exception_info.rdi], rdi
+  mov qword [exception_info.rsi], rsi
+  mov qword [exception_info.rbp], rbp
+  mov qword [exception_info.r8], r8
+  mov qword [exception_info.r9], r9
+  mov qword [exception_info.r10], r10
+  mov qword [exception_info.r11], r11
+  mov qword [exception_info.r12], r12
+  mov qword [exception_info.r13], r13
+  mov qword [exception_info.r14], r14
+  mov qword [exception_info.r15], r15
+
+  pop rax
+  mov qword [exception_info.rip], rax
+  pop rax
+  pop rax
+  mov qword [exception_info.rflags], rax
+  pop rax
+  mov qword [exception_info.rsp], rax
+
+  mov rax, cr2
+  mov qword [exception_info.cr2], rax
+  mov rax, cr3
+  mov qword [exception_info.cr3], rax
+
+  jmp print_exception
+
+set_isr:
+;rdi - index
+;rsi - isr pointer
+
+  shl rdi, 4
+  add rdi, idt
+
+  mov word [rdi], si
+  shr rsi, 16
+  mov word [rdi + 6], si
+  shr rsi, 16
+  mov dword [rdi + 8], esi
+
+  mov byte [rdi + 5], 0x8e
+  mov word [rdi + 2], 0x28
+  mov byte [rdi + 4], 1
+
+  ret
+
+section .data
+
+gdt:
+  dq 0
+  dq 0
+  dq 0
+.tss:
+  dq 0x0000e90000000067
+  dq 0;tss is 2 qwords wide
+  dq 0x002f98000000ffff
+  dq 0x002f92000000ffff
+  dq 0x002ff2000000ffff
+  dq 0x002ff8000000ffff
+
+section .bss
+
+section .text
+
+write_keyboard_byte:
+  in al, 0x64
+  test al, 0x02
+  jnz write_keyboard_byte
+  mov al, dil
+  out 0x60, al
+  ret
+
+extern on_keyboard_interrupt
+
+keyboard_isr:
+
+  push r11
+  push r10
+  push r9
+  push r8
+  push rsi
+  push rdi
+  push rdx
+  push rcx
+  push rax
+
+  in al, 0x60
+  mov dil, al
+
+  call on_keyboard_interrupt
+
+  mov al, 0x20
+  out 0x20, al
+
+  pop rax
+  pop rcx
+  pop rdx
+  pop rdi
+  pop rsi
+  pop r8
+  pop r9
+  pop r10
+  pop r11
+
+  iretq
+
+load_gdt_and_idt:
+
+  ;fill exception entries in idt
+
+  mov rcx, 16
+
+.loop:
+
+  mov rdi, rcx
+  dec rdi
+  mov rsi, qword [exception_isrs + rdi * 8]
+  call set_isr
+
+  loop .loop
+
+  ;reset pic and map irqs to 0x20 - 0x2f
+
+  mov al, 0x11
+  out 0x20, al
+  mov al, 0x20
+  out 0x21, al
+  mov al, 0x04
+  out 0x21, al
+  mov al, 0x01
+  out 0x21, al
+  mov al, 0xfd ;mask all but irq 1
+  out 0x21, al
+
+  mov al, 0x11
+  out 0xa0, al
+  mov al, 0x28
+  out 0xa1, al
+  mov al, 0x02
+  out 0xa1, al
+  mov al, 0x01
+  out 0xa1, al
+  mov al, 0xff ;mask all
+  out 0xa1, al
+
+  mov rdi, 0x21
+  mov rsi, keyboard_isr
+  call set_isr
+
+  ;set keyboard config
+
+  mov al, 0x60
+  out 0x64, al
+  mov dil, 0x01
+  call write_keyboard_byte
+
+  ;make tss entry in gdt
+
+  mov rax, tss
+
+  mov word [gdt.tss + 2], ax
+  shr rax, 16
+  mov byte [gdt.tss + 4], al
+  mov byte [gdt.tss + 7], ah
+  shr rax, 16
+  mov dword [gdt.tss + 8], eax
+
+  ;load gdt, idt, tss
+
+  lgdt [gdtr]
+  lidt [idtr]
+  mov ax, 0x18
+  ltr ax
+
+  ret
diff --git a/kernel/source/interrupts.cpp b/kernel/source/interrupts.cpp
new file mode 100644
index 0000000..6e22121
--- /dev/null
+++ b/kernel/source/interrupts.cpp
@@ -0,0 +1,152 @@
+#include <hilbert/kernel/input.hpp>
+#include <hilbert/kernel/panic.hpp>
+
+using namespace hilbert::kernel;
+
+struct [[gnu::packed]] exception_info_t {
+
+  uint64_t rax;
+  uint64_t rbx;
+  uint64_t rcx;
+  uint64_t rdx;
+  uint64_t rdi;
+  uint64_t rsi;
+  uint64_t rbp;
+  uint64_t rsp;
+  uint64_t r8;
+  uint64_t r9;
+  uint64_t r10;
+  uint64_t r11;
+  uint64_t r12;
+  uint64_t r13;
+  uint64_t r14;
+  uint64_t r15;
+
+  uint64_t cr2;
+  uint64_t cr3;
+  uint64_t rip;
+  uint64_t rflags;
+
+  uint64_t error;
+  uint8_t has_error;//0 or 1
+  uint8_t exception_number;
+
+};
+
+extern exception_info_t exception_info;
+
+extern "C" [[noreturn]] void print_exception() {
+
+  //so exception_info's type is known by gdb
+  exception_info_t the_exception_info = exception_info;
+  (void)the_exception_info;
+
+  //TODO: log exception, and recover if possible.
+
+  panic(0xba40bb);
+
+}
+
+static uint32_t current_flags = 0;
+
+#define SETBIT(field, bit, cond) \
+  field = (cond) ? (field | (bit)) : (field & ~(bit));
+
+static void got_key(uint32_t key) {
+
+  input::key_queue->insert(current_flags | key);
+  input::got_input();
+
+  if (key == (input::BREAK | 0x77))
+    current_flags ^= input::NUM_LOCK;
+
+  else if (key == (input::BREAK | 0x58))
+    current_flags ^= input::CAPS_LOCK;
+
+  else if ((key & 0xff) == 0xa7)
+    SETBIT(current_flags, input::RIGHT_WIN, !(key & input::BREAK))
+
+  else if ((key & 0xff) == 0x9f)
+    SETBIT(current_flags, input::LEFT_WIN, !(key & input::BREAK))
+
+  else if ((key & 0xff) == 0x91)
+    SETBIT(current_flags, input::RIGHT_ALT, !(key & input::BREAK))
+
+  else if ((key & 0xff) == 0x11)
+    SETBIT(current_flags, input::LEFT_ALT, !(key & input::BREAK))
+
+  else if ((key & 0xff) == 0x94)
+    SETBIT(current_flags, input::RIGHT_CTRL, !(key & input::BREAK))
+
+  else if ((key & 0xff) == 0x14)
+    SETBIT(current_flags, input::LEFT_CTRL, !(key & input::BREAK))
+
+  else if ((key & 0xff) == 0x59)
+    SETBIT(current_flags, input::RIGHT_SHIFT, !(key & input::BREAK))
+
+  else if ((key & 0xff) == 0x12)
+    SETBIT(current_flags, input::LEFT_SHIFT, !(key & input::BREAK))
+
+}
+
+static uint8_t key_so_far[8];
+uint8_t key_so_far_len = 0;
+
+extern "C" void on_keyboard_interrupt(uint8_t byte) {
+
+  key_so_far[key_so_far_len++] = byte;
+
+  if (key_so_far_len == 1) {
+    if (byte != 0xe0 && byte != 0xe1 && byte != 0xf0) {
+      got_key(byte);
+      key_so_far_len = 0;
+    }
+  }
+
+  else if (key_so_far_len == 2) {
+    if (key_so_far[0] == 0xe0 && byte != 0xf0 && byte != 0x12) {
+      got_key(byte | 0x80);
+      key_so_far_len = 0;
+    }
+    else if (key_so_far[0] == 0xf0) {
+      got_key(input::BREAK | byte);
+      key_so_far_len = 0;
+    }
+  }
+
+  else if (key_so_far_len == 3) {
+    if (key_so_far[0] == 0xe0 && key_so_far[1] == 0xf0 && byte != 0x7c) {
+      got_key(input::BREAK | byte | 0x80);
+      key_so_far_len = 0;
+    }
+  }
+
+  else if (key_so_far_len == 4) {
+    if (key_so_far[0] == 0xe0 && key_so_far[1] == 0x12 &&
+        key_so_far[2] == 0xe0 && byte == 0x7c) {
+      got_key(0xe0);
+      key_so_far_len = 0;
+    }
+  }
+
+  else if (key_so_far_len == 6) {
+    if (key_so_far[0] == 0xe0 && key_so_far[1] == 0xf0 &&
+        key_so_far[2] == 0x7c && key_so_far[3] == 0xe0 &&
+        key_so_far[4] == 0xf0 && byte == 0x12) {
+      got_key(input::BREAK | 0xe0);
+      key_so_far_len = 0;
+    }
+  }
+
+  else if (key_so_far_len == 8) {
+    if (key_so_far[0] == 0xe1 && key_so_far[1] == 0x14 &&
+        key_so_far[2] == 0x77 && key_so_far[3] == 0xe1 &&
+        key_so_far[2] == 0xf0 && key_so_far[3] == 0x14 &&
+        key_so_far[4] == 0xf0 && byte == 0x77) {
+      got_key(0xe1);
+      got_key(input::BREAK | 0xe1);
+    }
+    key_so_far_len = 0;
+  }
+
+}
diff --git a/kernel/source/paging.asm b/kernel/source/paging.asm
new file mode 100644
index 0000000..f1047a9
--- /dev/null
+++ b/kernel/source/paging.asm
@@ -0,0 +1,16 @@
+bits 64
+
+;see also ../documentation/memory.txt
+
+global switch_to_kernel_p4
+
+;from paging.cpp:
+extern __kernel_p4_paddr
+
+section .text
+
+switch_to_kernel_p4:
+  mov rax, qword [__kernel_p4_paddr]
+  mov cr3, rax
+  mov rsp, 0xfffffffffffff000
+  jmp rdi
diff --git a/kernel/source/paging.cpp b/kernel/source/paging.cpp
new file mode 100644
index 0000000..d8869fc
--- /dev/null
+++ b/kernel/source/paging.cpp
@@ -0,0 +1,145 @@
+#include <hilbert/kernel/utility.hpp>
+#include <hilbert/kernel/paging.hpp>
+
+//see also ../documentation/memory.txt
+
+extern "C" {
+  uint64_t __kernel_p4_paddr;
+}
+
+namespace hilbert::kernel::paging {
+
+  static constexpr uint64_t kernel_vram_start = 0xffffffffc0000000;
+  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];
+
+  void mark_all_pram_used() {
+    utility::mark_bitmap_region_one(pram_usage_bitmap, 0, pram_pages);
+  }
+
+  void mark_pram_region_free(uint64_t start_addr, uint64_t end_addr) {
+    utility::mark_bitmap_region_zero(
+      pram_usage_bitmap, start_addr / 4096,
+      utility::min(end_addr / 4096, pram_pages));
+  }
+
+  [[gnu::aligned(4096)]] uint64_t kernel_p4[512];
+  [[gnu::aligned(4096)]] uint64_t kernel_p3[512];
+  [[gnu::aligned(4096)]] uint64_t kernel_p2[512];
+  [[gnu::aligned(4096)]] uint64_t kernel_p1s[512 * 512];
+
+  uint64_t kernel_p4e;
+
+  uint64_t encode_pte(uint64_t addr, bool user, bool write, bool execute) {
+    return (addr & 0x0000ffffffffffff) | (execute ? 0 : (1ULL << 63))
+         | (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_p4e = encode_pte(
+      (uint64_t)kernel_p3 - kernel_offset, false, true, true);
+    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);
+    for (int i = 0; i < 512; ++i)
+      kernel_p2[i] = encode_pte(
+        (uint64_t)kernel_p1s + 4096 * i - kernel_offset, false, true, true);
+    for (int i = 0; i < 512 * 512; ++i)
+      kernel_p1s[i] = 0;
+  }
+
+  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);
+  }
+
+  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"
+    );
+  }
+
+  uint64_t take_pram_page() {
+    for (uint64_t i = 0; i < pram_pages / 64; ++i)
+      if (~pram_usage_bitmap[i] != 0)
+        for (int j = 0; j < 64; ++j)
+          if (~pram_usage_bitmap[i] & (1ULL << j)) {
+            pram_usage_bitmap[i] |= (1ULL << j);
+            return 4096 * (i * 64 + j);
+          }
+    //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);
+  }
+
+  uint64_t find_unmapped_vram_region(uint64_t page_count) {
+    uint64_t start = 0;
+    uint64_t len = 0;
+    for (uint64_t i = 0; i < kernel_vram_pages; ++i)
+      if (kernel_p1s[i] == 0) {
+        ++len;
+        if (len == page_count)
+          return start * 4096 + kernel_vram_start;
+      }
+      else {
+        start = i + 1;
+        len = 0;
+      }
+    //TODO: handle error
+    return 0;
+  }
+
+  void *map_new_kernel_pages(uint64_t count) {
+    uint64_t vaddr = find_unmapped_vram_region(count);
+    for (uint64_t i = 0; i < count; ++i)
+      map_kernel_page(take_pram_page(), vaddr + i * 4096, true, false);
+    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)
+      if (kernel_p1s[i] != 0)
+        ++count;
+    return count;
+  }
+
+  uint64_t get_free_pram_page_count() {
+    uint64_t used_count = 0;
+    for (uint64_t i = 0; i < pram_pages / 64; ++i)
+      for (uint64_t j = 0; j < 64; ++j)
+        used_count += (pram_usage_bitmap[i] >> j) & 1;
+    return pram_pages - used_count;
+  }
+
+}
diff --git a/kernel/source/panic.cpp b/kernel/source/panic.cpp
new file mode 100644
index 0000000..d99be91
--- /dev/null
+++ b/kernel/source/panic.cpp
@@ -0,0 +1,11 @@
+#include <hilbert/kernel/framebuffer.hpp>
+#include <hilbert/kernel/panic.hpp>
+
+namespace hilbert::kernel {
+  [[noreturn]] void panic(uint32_t code) {
+    framebuffer::fill_color(framebuffer::encode_color(
+      code >> 16, (code >> 8) & 0xff, code & 0xff));
+    while (1)
+      asm ("hlt");
+  }
+}
diff --git a/kernel/source/storage.cpp b/kernel/source/storage.cpp
new file mode 100644
index 0000000..b6b1a04
--- /dev/null
+++ b/kernel/source/storage.cpp
@@ -0,0 +1,67 @@
+#include <hilbert/kernel/storage.hpp>
+
+namespace hilbert::kernel::storage {
+
+  bd_result block_device::load_cache_block(uint64_t i) {
+
+    if (block_cache_i == i)
+      return bd_result::success;
+
+    bd_result result = read_blocks_no_cache(i, 1, block_cache);
+
+    if (result != bd_result::success) {
+      block_cache_i = block_count;
+      return result;
+    }
+
+    block_cache_i = i;
+    return bd_result::success;
+
+  }
+
+  bd_result block_device::read_bytes(
+    uint64_t start, uint64_t count, void *into
+  ) {
+
+    if (start + count > block_size * block_count)
+      return bd_result::out_of_bounds;
+
+    uint8_t *into_u8 = (uint8_t *)into;
+
+    if (start % block_size != 0) {
+      uint64_t prefix_len = block_size - start % block_size;
+      bd_result result = load_cache_block(start / block_size);
+      if (result != bd_result::success)
+        return result;
+      for (uint64_t i = 0; i < prefix_len; ++i)
+        into_u8[i] = block_cache[start % block_size + i];
+      into_u8 += prefix_len;
+      start += prefix_len;
+      count -= prefix_len;
+    }
+
+    uint64_t postfix_start = ((start + count) / block_size) * block_size;
+
+    if (postfix_start != start) {
+      bd_result result = read_blocks_no_cache(
+        start / block_size, (postfix_start - start) / block_size, into_u8);
+      if (result != bd_result::success)
+        return result;
+      count -= postfix_start - start;
+      into_u8 += postfix_start - start;
+      start = postfix_start;
+    }
+
+    if (count != 0) {
+      bd_result result = load_cache_block(start / block_size);
+      if (result != bd_result::success)
+        return result;
+      for (uint64_t i = 0; i < count; ++i)
+        into_u8[i] = block_cache[i];
+    }
+
+    return bd_result::success;
+
+  }
+
+}
diff --git a/kernel/source/storage/bd/memory.cpp b/kernel/source/storage/bd/memory.cpp
new file mode 100644
index 0000000..d6a6719
--- /dev/null
+++ b/kernel/source/storage/bd/memory.cpp
@@ -0,0 +1,21 @@
+#include <hilbert/kernel/storage/bd/memory.hpp>
+
+namespace hilbert::kernel::storage::bd {
+
+  memory::memory(void *buffer, uint64_t buffer_len)
+    : buffer((uint8_t *)buffer)
+  {
+    block_size = 1;
+    block_count = buffer_len;
+    //block cache will never be used, since the block size is 1.
+  }
+
+  bd_result memory::read_blocks_no_cache(
+    uint64_t start, uint64_t count, void *into
+  ) {
+    for (uint64_t i = 0; i < count; ++i)
+      ((uint8_t *)into)[i] = buffer[start + i];
+    return bd_result::success;
+  }
+
+}
diff --git a/kernel/source/storage/fs/tarfs.cpp b/kernel/source/storage/fs/tarfs.cpp
new file mode 100644
index 0000000..5986f62
--- /dev/null
+++ b/kernel/source/storage/fs/tarfs.cpp
@@ -0,0 +1,238 @@
+#include <hilbert/kernel/storage/fs/tarfs.hpp>
+
+//in tarfs_instance, node_id_t and directory_iter_t refer to the number
+//of bytes into the block device that the info sector is located.
+
+namespace hilbert::kernel::storage::fs {
+
+  #define BD_TO_FS(expr) \
+    { \
+      bd_result _result = expr; \
+      if (_result == bd_result::out_of_bounds) \
+        return fs_result::fs_corrupt; \
+      if (_result == bd_result::device_error) \
+        return fs_result::device_error; \
+    }
+
+  #define FS_TO_FS(expr) \
+    { \
+      fs_result _result = expr; \
+      if (_result != fs_result::success) \
+        return _result; \
+    }
+
+  tarfs_instance::tarfs_instance(block_device *bd) : bd(bd) {}
+
+  fs_result tarfs_instance::next_node(node_id_t node, node_id_t &out) {
+
+    uint64_t bytes;
+    FS_TO_FS(read_num(node + 124, 12, bytes))
+    out = node + ((bytes - 1) / 512 + 2) * 512;
+
+    uint8_t sector[512];
+    BD_TO_FS(bd->read_bytes(node, 512, sector))
+    for (unsigned i = 0; i < 512; ++i)
+      if (sector[i] != 0)
+        return fs_result::success;
+
+    return fs_result::does_not_exist;
+
+  }
+
+  fs_result tarfs_instance::read_full_name(
+    node_id_t node, utility::string &out
+  ) {
+
+    out.count = 0;
+    out.verify_buffer_len(155);
+    BD_TO_FS(bd->read_bytes(node + 345, 155, out.buffer))
+
+    while (out.count < 155 && out.buffer[out.count] != '\0')
+      ++out.count;
+
+    unsigned new_max = out.count + 100;
+    out.verify_buffer_len(new_max);
+    BD_TO_FS(bd->read_bytes(node, 100, out.buffer + out.count))
+
+    while (out.count < 255 && out.buffer[out.count] != '\0')
+      ++out.count;
+
+    return fs_result::success;
+
+  }
+
+  //len <= 12.
+  fs_result tarfs_instance::read_num(
+    uint64_t offset, unsigned len, uint64_t &out
+  ) {
+
+    char buf[12];
+    BD_TO_FS(bd->read_bytes(offset, len, buf))
+
+    out = 0;
+    for (unsigned i = 0; i < len && buf[i] != '\0'; ++i) {
+      if (buf[i] < '0' || buf[i] > '7')
+        return fs_result::fs_corrupt;
+      out = out * 8 + buf[i] - '0';
+    }
+
+    return fs_result::success;
+
+  }
+
+  fs_result tarfs_instance::first_child_starting_at(
+    node_id_t parent, node_id_t start, node_id_t &out
+  ) {
+
+    utility::string parent_full_name;
+    FS_TO_FS(read_full_name(parent, parent_full_name))
+
+    utility::string child_full_name;
+    out = start;
+
+    while (true) {
+
+      FS_TO_FS(read_full_name(out, child_full_name))
+
+      if (child_full_name.count > parent_full_name.count &&
+          child_full_name.starts_with(parent_full_name)
+      ) {
+        if (child_full_name.buffer[child_full_name.count - 1] == '/')
+          --child_full_name.count;
+        for (unsigned i = parent_full_name.count;
+             i < child_full_name.count; ++i)
+          if (child_full_name.buffer[i] == '/')
+            goto next;
+        return fs_result::success;
+      }
+
+    next:
+      FS_TO_FS(next_node(out, out))
+
+    }
+
+  }
+
+  fs_result tarfs_instance::get_dir_entry(node_id_t node, dir_entry &entry) {
+
+    utility::string full_name;
+    read_full_name(node, full_name);
+
+    if (full_name.count == 2)
+      entry.name.count = 0;
+
+    else {
+
+      if (full_name.buffer[full_name.count - 1] == '/')
+        --full_name.count;
+
+      unsigned last_slash =
+        utility::find_last(full_name.buffer, full_name.count, '/');
+      entry.name.count = full_name.count - last_slash - 1;
+      entry.name.verify_buffer_len(entry.name.count);
+
+      for (unsigned i = 0; i < entry.name.count; ++i)
+        entry.name.buffer[i] = full_name.buffer[last_slash + 1 + i];
+
+    }
+
+    entry.node = node;
+
+    char ch;
+    BD_TO_FS(bd->read_bytes(node + 156, 1, &ch));
+    switch (ch) {
+      case '0':
+        entry.type = file_type::regular_file;
+        break;
+      case '2':
+        entry.type = file_type::symlink;
+        break;
+      case '5':
+        entry.type = file_type::directory;
+        break;
+      default:
+        return fs_result::fs_corrupt;
+    }
+
+    if (entry.type == file_type::regular_file) {
+      uint64_t length;
+      FS_TO_FS(read_num(node + 124, 12, length))
+      entry.length = length;
+    }
+
+    else if (entry.type == file_type::symlink) {
+      utility::string target;
+      target.verify_buffer_len(100);
+      BD_TO_FS(bd->read_bytes(node + 157, 100, target.buffer))
+      while (target.count < 100 && target.buffer[target.count] != '\0')
+        ++target.count;
+      entry.target = utility::move(target);
+    }
+
+    return fs_result::success;
+
+  }
+
+  fs_result tarfs_instance::get_root_node(node_id_t &out) {
+
+    utility::string full_name;
+    node_id_t on = 0;
+
+    while (true) {
+
+      FS_TO_FS(read_full_name(on, full_name))
+      if (full_name.count == 2) {
+        out = on;
+        return fs_result::success;
+      }
+      fs_result result = next_node(on, on);
+      if (result == fs_result::does_not_exist)
+        return fs_result::fs_corrupt;
+      FS_TO_FS(result)
+
+    }
+
+  }
+
+  fs_result tarfs_instance::get_first_child(
+    node_id_t node, dir_entry &out, directory_iter_t &iter_out
+  ) {
+
+    node_id_t child;
+    FS_TO_FS(first_child_starting_at(node, 0, child))
+
+    dir_entry entry;
+    FS_TO_FS(get_dir_entry(child, entry))
+    out = utility::move(entry);
+    iter_out = (directory_iter_t)child;
+    return fs_result::success;
+
+  }
+
+  fs_result tarfs_instance::get_next_child(
+    node_id_t node, dir_entry &out, directory_iter_t &iter
+  ) {
+
+    node_id_t start;
+    FS_TO_FS(next_node((node_id_t)iter, start))
+
+    node_id_t child;
+    FS_TO_FS(first_child_starting_at(node, start, child))
+
+    dir_entry entry;
+    FS_TO_FS(get_dir_entry(child, entry))
+    out = utility::move(entry);
+    iter = (directory_iter_t)child;
+    return fs_result::success;
+
+  }
+
+  fs_result tarfs_instance::read_bytes_from_file(
+    node_id_t node, uint64_t start, uint64_t count, void *into
+  ) {
+    BD_TO_FS(bd->read_bytes(node + 512 + start, count, into))
+    return fs_result::success;
+  }
+
+
+}
diff --git a/kernel/source/syscall.cpp b/kernel/source/syscall.cpp
new file mode 100644
index 0000000..768ff0d
--- /dev/null
+++ b/kernel/source/syscall.cpp
@@ -0,0 +1,538 @@
+#include <hilbert/kernel/application.hpp>
+#include <hilbert/kernel/framebuffer.hpp>
+#include <hilbert/kernel/paging.hpp>
+#include <hilbert/kernel/input.hpp>
+#include <hilbert/kernel/panic.hpp>
+#include <hilbert/kernel/vfile.hpp>
+
+namespace hilbert::kernel::syscall {
+
+  enum file_result : uint64_t {
+    file_result_success,
+    file_result_bad_file_handle,
+    file_result_device_error,
+    file_result_file_system_corrupt,
+    file_result_out_of_bounds,
+    file_result_does_not_exist,
+    file_result_directory
+  };
+
+  bool is_range_owned_by_application(uint64_t start, uint64_t end) {
+    auto *process = application::running_thread->the_process;
+    uint64_t pstart = (start / 4096) * 4096;
+    uint64_t pend = ((end - 1) / 4096 + 1) * 4096;
+    for (uint64_t p = pstart; p < pend; p += 4096)
+      if (!process->is_page_owned(p))
+        return false;
+    return true;
+  }
+
+  void set_zero(uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx) {
+    rax = 0;
+    rdi = 0;
+    rsi = 0;
+    rdx = 0;
+  }
+
+  void encode_color_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+    rax = (uint64_t)framebuffer::encode_color(
+      rdi & 0xff, (rdi >> 8) & 0xff, (rdi >> 16) & 0xff);
+    rdi = 0;
+    rsi = 0;
+    rdx = 0;
+  }
+
+  void get_framebuffer_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    auto *process = application::running_thread->the_process;
+    if (process->framebuffer_vaddr == 0) {
+      uint64_t pages_needed =
+        (framebuffer::dword_pitch * framebuffer::height * 4 - 1) / 4096 + 1;
+      uint64_t vaddr = process->get_free_vaddr_pages(pages_needed);
+      for (uint64_t i = 0; i < pages_needed; ++i)
+        process->map_page(
+          vaddr + i * 4096, framebuffer::paddr + i * 4096, true, false, false);
+      process->framebuffer_vaddr = vaddr;
+    }
+
+    rax = process->framebuffer_vaddr;
+    rdi =
+      (uint64_t)(uint32_t)framebuffer::width |
+      ((uint64_t)(uint32_t)framebuffer::height << 32);
+    rsi = (uint32_t)framebuffer::dword_pitch;
+    rdx = 0;
+
+  }
+
+  void open_file_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    if (!is_range_owned_by_application(rdi, rdi + rsi)) {
+      set_zero(rax, rdi, rsi, rdx);
+      return;
+    }
+
+    utility::string path_string((const char *)rdi, rsi);
+
+    set_zero(rax, rdi, rsi, rdx);
+
+    vfile::canon_path cp;
+    vfile::vfile file;
+    vfile::canonize_path(path_string, cp);
+
+    switch (vfile::lookup_path(cp, file, true)) {
+
+    case storage::fs_result::device_error:
+    case storage::fs_result::fs_corrupt:
+
+      rax = (uint64_t)application::stream_result::io_error;
+      return;
+
+    case storage::fs_result::does_not_exist:
+
+      if (!(rdx & 1)) {
+        rax = (uint64_t)application::stream_result::does_not_exist;
+        return;
+      }
+
+      //TODO: create the file
+      panic(0x9af5e6);
+
+    case storage::fs_result::success:
+
+      if (rdx & 2) {
+        rax = (uint64_t)application::stream_result::already_exists;
+        return;
+      }
+
+      if (file.dir_entry.type != storage::file_type::regular_file) {
+        rax = (uint64_t)application::stream_result::not_a_regular_file;
+        return;
+      }
+
+      rax = (uint64_t)application::stream_result::success;
+      rdi = application::running_thread->the_process->open_streams.add_new(
+        new application::vfile_stream(utility::move(file)));
+
+      return;
+
+    }
+
+  }
+
+  void end_this_thread_syscall(
+    uint64_t &, uint64_t &rdi, uint64_t &, uint64_t &
+  ) {
+    application::running_thread->exit_code = (int)(uint32_t)rdi;
+    delete application::running_thread;
+    application::resume_next();
+  }
+
+  void get_new_pages_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    uint64_t count = rdi;
+    set_zero(rax, rdi, rsi, rdx);
+
+    auto *p = application::running_thread->the_process;
+    uint64_t vaddr = p->get_free_vaddr_pages(count);
+
+    for (uint64_t i = 0; i < count; ++i) {
+      uint64_t kvaddr;
+      uint64_t paddr;
+      paging::map_new_kernel_page(kvaddr, paddr);
+      for (int i = 0; i < 4096; ++i)
+        ((uint8_t *)kvaddr)[i] = 0;
+      paging::unmap_kernel_page((uint64_t)kvaddr);
+      p->map_page(vaddr + i * 4096, paddr, true, false, true);
+    }
+
+    rax = vaddr;
+
+  }
+
+  void read_key_packet_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    set_zero(rax, rdi, rsi, rdx);
+    auto *t = application::running_thread;
+
+    do
+      if (input::key_queue->count > 0) {
+        rax = (uint64_t)input::key_queue->take();
+        return;
+      }
+    while (application::save_thread_state(t->cpu));
+
+    t->state = application::thread_state::waiting;
+    application::threads_waiting_for_input->insert(t);
+    application::resume_next();
+
+  }
+
+  void create_private_socket_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+    auto *s = new application::socket;
+    auto *ss1 = new application::socket_stream(s, false);
+    auto *ss2 = new application::socket_stream(s, true);
+    set_zero(rax, rdi, rsi, rdx);
+    auto *p = application::running_thread->the_process;
+    rax = (uint64_t)p->open_streams.add_new(ss1);
+    rdi = (uint64_t)p->open_streams.add_new(ss2);
+  }
+
+  void create_socket_listener_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    if (!is_range_owned_by_application(rdi, rdi + rsi)) {
+      set_zero(rax, rdi, rsi, rdx);
+      return;
+    }
+
+    utility::string id_string((const char *)rdi, rsi);
+    set_zero(rax, rdi, rsi, rdx);
+
+    for (auto *p = application::all_socket_listeners->first; p; p = p->next)
+      if (p->value->id == id_string) {
+        rax = (uint64_t)application::stream_result::socket_id_already_used;
+        return;
+      }
+
+    auto *sl = new application::socket_listener();
+    sl->id = utility::move(id_string);
+    sl->is_listening = true;
+    rax = (uint64_t)application::stream_result::success;
+    rdi = (uint64_t)application::running_thread->the_process
+      ->socket_listeners.add_new(utility::move(sl));
+
+  }
+
+  void stop_socket_listener_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    set_zero(rax, rdi, rsi, rdx);
+    auto *p = application::running_thread->the_process;
+
+    if (p->socket_listeners.has_id(handle)) {
+      auto *sl = p->socket_listeners.get(handle);
+      p->socket_listeners.remove_id(handle);
+      if (sl->waiting_to_accept_connection.count > 0 ||
+          sl->waiting_to_connect.count > 0) {
+        sl->is_listening = false;
+        while (sl->waiting_to_accept_connection.count > 0) {
+          auto *t = sl->waiting_to_accept_connection.take();
+          t->state = application::thread_state::paused;
+          application::paused_threads->insert(t);
+        }
+        while (sl->waiting_to_connect.count > 0) {
+          auto *t = sl->waiting_to_connect.take();
+          t->state = application::thread_state::paused;
+          application::paused_threads->insert(t);
+        }
+      }
+      else
+        delete sl;
+    }
+
+  }
+
+  void accept_socket_connection_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    set_zero(rax, rdi, rsi, rdx);
+    auto *t = application::running_thread;
+    auto *p = t->the_process;
+
+    if (!p->socket_listeners.has_id(handle)) {
+      rax = (uint64_t)application::stream_result::socket_id_not_in_use;
+      return;
+    }
+
+    auto *sl = p->socket_listeners.get(handle);
+
+    if (sl->waiting_to_connect.count > 0) {
+      auto *ot = sl->waiting_to_connect.take();
+      auto *sock = new application::socket();
+      application::stream *s1 = new application::socket_stream(sock, false);
+      application::stream *s2 = new application::socket_stream(sock, true);
+      unsigned handle = p->open_streams.add_new(utility::move(s1));
+      ot->just_connected_to = s2;
+      ot->state = application::thread_state::paused;
+      application::paused_threads->insert(ot);
+      rax = (uint64_t)application::stream_result::success;
+      rdi = handle;
+      return;
+    }
+
+    if (application::save_thread_state(t->cpu)) {
+      if (sl->is_listening) {
+        rax = (uint64_t)application::stream_result::success;
+        rdi = p->open_streams.add_new(utility::move(t->just_accepted));
+      }
+      else {
+        if (sl->waiting_to_accept_connection.count == 0 &&
+            sl->waiting_to_connect.count == 0)
+          delete sl;
+        rax = (uint64_t)application::stream_result::socket_listener_closed;
+      }
+      return;
+    }
+
+    t->state = application::thread_state::waiting;
+    sl->waiting_to_accept_connection.insert(t);
+    application::resume_next();
+
+  }
+
+  void connect_to_socket_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    if (!is_range_owned_by_application(rdi, rdi + rsi)) {
+      set_zero(rax, rdi, rsi, rdx);
+      return;
+    }
+
+    utility::string id_string((const char *)rdi, rsi);
+    set_zero(rax, rdi, rsi, rdx);
+
+    for (auto *i = application::all_socket_listeners->first; i; i = i->next)
+      if (i->value->id == id_string) {
+        auto *sl = i->value;
+        auto *t = application::running_thread;
+        auto *p = t->the_process;
+
+        if (sl->waiting_to_accept_connection.count > 0) {
+          auto *ot = sl->waiting_to_accept_connection.take();
+          auto *sock = new application::socket();
+          auto *s1 = new application::socket_stream(sock, false);
+          auto *s2 = new application::socket_stream(sock, true);
+          unsigned handle = p->open_streams.add_new(utility::move(s1));
+          ot->just_accepted = s2;
+          ot->state = application::thread_state::paused;
+          application::paused_threads->insert(ot);
+          rax = (uint64_t)application::stream_result::success;
+          rdi = handle;
+          return;
+        }
+
+        if (application::save_thread_state(t->cpu)) {
+          if (sl->is_listening) {
+            rax = (uint64_t)application::stream_result::success;
+            rdi = p->open_streams.add_new(utility::move(t->just_connected_to));
+          }
+          else {
+            if (sl->waiting_to_accept_connection.count == 0 &&
+                sl->waiting_to_connect.count == 0)
+              delete sl;
+            rax = (uint64_t)application::stream_result::socket_id_not_in_use;
+          }
+          return;
+        }
+
+        t->state = application::thread_state::waiting;
+        sl->waiting_to_connect.insert(t);
+        application::resume_next();
+
+      }
+
+    rax = (uint64_t)application::stream_result::socket_id_not_in_use;
+
+  }
+
+  void close_stream_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    set_zero(rax, rdi, rsi, rdx);
+    auto *p = application::running_thread->the_process;
+
+    if (p->open_streams.has_id(handle)) {
+      application::stream *s = p->open_streams.get(handle);
+      p->open_streams.remove_id(handle);
+      delete s;
+    }
+
+  }
+
+  void seek_stream_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    uint8_t origin = (uint8_t)rsi;
+    int64_t offset = (int64_t)rdx;
+    set_zero(rax, rdi, rsi, rdx);
+
+    if (origin >= 3)
+      return;
+
+    auto *p = application::running_thread->the_process;
+
+    if (!p->open_streams.has_id(handle)) {
+      rax = (uint64_t)application::stream_result::bad_handle;
+      return;
+    }
+
+    rax = (uint64_t)p->open_streams.get(handle)
+      ->seek((application::seek_origin)origin, offset);
+
+  }
+
+  void read_from_stream_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    uint64_t count = (uint64_t)rsi;
+    uint64_t buffer = (uint64_t)rdx;
+    set_zero(rax, rdi, rsi, rdx);
+
+    if (!is_range_owned_by_application(buffer, buffer + count))
+      return;
+
+    auto *p = application::running_thread->the_process;
+
+    if (!p->open_streams.has_id(handle)) {
+      rax = (uint64_t)application::stream_result::bad_handle;
+      return;
+    }
+
+    rax = (uint64_t)p->open_streams.get(handle)->read(count, (void *)buffer);
+
+  }
+
+  void write_to_stream_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    uint64_t count = (uint64_t)rsi;
+    uint64_t buffer = (uint64_t)rdx;
+    set_zero(rax, rdi, rsi, rdx);
+
+    if (!is_range_owned_by_application(buffer, buffer + count))
+      return;
+
+    auto *p = application::running_thread->the_process;
+
+    if (!p->open_streams.has_id(handle)) {
+      rax = (uint64_t)application::stream_result::bad_handle;
+      return;
+    }
+
+    rax = (uint64_t)p->open_streams.get(handle)
+      ->write(count, (const void *)buffer);
+
+  }
+
+  void get_stream_length_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    set_zero(rax, rdi, rsi, rdx);
+
+    auto *p = application::running_thread->the_process;
+
+    if (!p->open_streams.has_id(handle)) {
+      rax = (uint64_t)application::stream_result::bad_handle;
+      return;
+    }
+
+    rax = (uint64_t)p->open_streams.get(handle)->get_length(rdi);
+
+  }
+
+  void start_process_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+    //TODO
+    (void)rax;
+    (void)rdi;
+    (void)rsi;
+    (void)rdx;
+    panic(0x9af5e6);
+  }
+
+  void end_this_process_syscall(
+    uint64_t &, uint64_t &rdi, uint64_t &, uint64_t &
+  ) {
+    application::running_thread->the_process->end_process((unsigned)rdi);
+    application::resume_next();
+  }
+
+  void set_stream_length_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = (unsigned)rdi;
+    uint64_t new_length = rsi;
+    set_zero(rax, rdi, rsi, rdx);
+
+    auto *p = application::running_thread->the_process;
+
+    if (!p->open_streams.has_id(handle)) {
+      rax = (uint64_t)application::stream_result::bad_handle;
+      return;
+    }
+
+    rax = (uint64_t)p->open_streams.get(handle)->set_length(new_length);
+
+  }
+
+  typedef void (*syscall_handler)(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx);
+
+  syscall_handler handlers[] = {
+    &encode_color_syscall,
+    &get_framebuffer_syscall,
+    &open_file_syscall,
+    &end_this_thread_syscall,
+    &get_new_pages_syscall,
+    &read_key_packet_syscall,
+    &create_private_socket_syscall,
+    &create_socket_listener_syscall,
+    &stop_socket_listener_syscall,
+    &accept_socket_connection_syscall,
+    &connect_to_socket_syscall,
+    &close_stream_syscall,
+    &seek_stream_syscall,
+    &read_from_stream_syscall,
+    &write_to_stream_syscall,
+    &get_stream_length_syscall,
+    &start_process_syscall,
+    &end_this_process_syscall,
+    &set_stream_length_syscall
+  };
+
+  static constexpr int max_syscall_number = 18;
+
+}
+
+using namespace hilbert::kernel::syscall;
+
+extern "C" void do_syscall(
+  uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+) {
+
+  if (rax <= max_syscall_number && handlers[rax] != 0)
+    handlers[rax](rax, rdi, rsi, rdx);
+  else
+    set_zero(rax, rdi, rsi, rdx);
+
+}
diff --git a/kernel/source/utility.cpp b/kernel/source/utility.cpp
new file mode 100644
index 0000000..12e88fd
--- /dev/null
+++ b/kernel/source/utility.cpp
@@ -0,0 +1,51 @@
+#include <hilbert/kernel/utility.hpp>
+
+void *operator new(size_t, void *ptr) {
+  return ptr;
+}
+
+void operator delete(void *, void *) {}
+
+namespace hilbert::kernel::utility {
+
+  void mark_bitmap_region_zero(
+      uint64_t *bitmap, uint64_t start_i, uint64_t end_i) {
+
+    if (start_i % 64 != 0) {
+      uint64_t keep = (1 << (start_i % 64)) - 1;
+      bitmap[start_i / 64] &= keep;
+      start_i = (start_i / 64 + 1) * 64;
+    }
+
+    if (end_i % 64 != 0) {
+      uint64_t replace = (1 << (end_i % 64)) - 1;
+      bitmap[end_i / 64] &= ~replace;
+      end_i = (end_i / 64) * 64;
+    }
+
+    for (uint64_t i = start_i / 64; i < end_i / 64; ++i)
+      bitmap[i] = 0;
+
+  }
+
+  void mark_bitmap_region_one(
+      uint64_t *bitmap, uint64_t start_i, uint64_t end_i) {
+
+    if (start_i % 64 != 0) {
+      uint64_t keep = (1 << (start_i % 64)) - 1;
+      bitmap[start_i / 64] |= ~keep;
+      start_i = (start_i / 64 + 1) * 64;
+    }
+
+    if (end_i % 64 != 0) {
+      uint64_t replace = (1 << (end_i % 64)) - 1;
+      bitmap[end_i / 64] |= replace;
+      end_i = (end_i / 64) * 64;
+    }
+
+    for (uint64_t i = start_i / 64; i < end_i / 64; ++i)
+      bitmap[i] = 0xffffffffffffffff;
+
+  }
+
+}
diff --git a/kernel/source/vfile.cpp b/kernel/source/vfile.cpp
new file mode 100644
index 0000000..89c95e6
--- /dev/null
+++ b/kernel/source/vfile.cpp
@@ -0,0 +1,206 @@
+#include <hilbert/kernel/vfile.hpp>
+
+//TODO: handle symlink loops nicely in vfile::get_child,
+//      vfile::get_children, and lookup_path.
+
+namespace hilbert::kernel::vfile {
+
+  void canon_path::parent() {
+    if (segments.count != 0)
+      --segments.count;
+    else if (!absolute)
+      ++parent_count;
+  }
+
+  void canon_path::rel(const canon_path &r) {
+    if (r.absolute) {
+      segments.count = 0;
+      absolute = true;
+      parent_count = 0;
+    }
+    for (unsigned i = 0; i < r.parent_count; ++i)
+      parent();
+    for (unsigned i = 0; i < r.segments.count; ++i)
+      segments.add_end(r.segments.buffer[i]);
+  }
+
+  void canonize_path(const utility::string &name, canon_path &out) {
+
+    out.absolute = false;
+    out.parent_count = 0;
+    out.segments.count = 0;
+
+    const char *str = name.buffer;
+    unsigned len = name.count;
+
+    if (len == 0)
+      return;
+
+    if (len == 1 && str[0] == '/') {
+      out.absolute = true;
+      return;
+    }
+
+    if (str[0] == '/') {
+      out.absolute = true;
+      ++str;
+      --len;
+    }
+
+    while (len != 0) {
+
+      unsigned segment_len = utility::find(str, len, '/');
+      unsigned to_skip = segment_len == len ? segment_len : segment_len + 1;
+
+      if (segment_len == 0)
+        ;
+
+      else if (segment_len == 1 && str[0] == '.')
+        ;
+
+      else if (segment_len == 2 && str[0] == '.' && str[1] == '.')
+        out.parent();
+
+      else {
+        utility::string segment(str, segment_len);
+        out.segments.add_end(utility::move(segment));
+      }
+
+      str += to_skip;
+      len -= to_skip;
+
+    }
+
+  }
+
+#define RET_NOT_SUC(expr) \
+  { \
+    storage::fs_result _result = expr; \
+    if (_result != storage::fs_result::success) \
+      return _result; \
+  }
+
+  storage::fs_result vfile::follow_symlinks(vfile &out) const {
+
+    if (dir_entry.type != storage::file_type::symlink) {
+      out = *this;
+      return storage::fs_result::success;
+    }
+
+    canon_path target_path;
+    canonize_path(dir_entry.target, target_path);
+    canon_path full_path = path;
+    full_path.parent();
+    full_path.rel(target_path);
+
+    vfile next;
+    RET_NOT_SUC(lookup_path(full_path, next, false))
+
+    next.path = path;
+    return next.follow_symlinks(out);
+
+  }
+
+  storage::fs_result vfile::get_child(
+    vfile &out, const utility::string &name
+  ) const {
+
+    storage::dir_entry entry;
+    storage::directory_iter_t iter;
+
+    RET_NOT_SUC(bd->mounted_as->get_first_child(dir_entry.node, entry, iter))
+
+    while (true) {
+
+      if (entry.name == name) {
+
+        vfile vf;
+        vf.bd = bd;
+        vf.dir_entry = utility::move(entry);
+        vf.path = path;
+        vf.path.segments.add_end(name);
+        out = utility::move(vf);
+        return storage::fs_result::success;
+
+      }
+
+      RET_NOT_SUC(bd->mounted_as->get_next_child(dir_entry.node, entry, iter))
+
+    }
+
+  }
+
+  storage::fs_result vfile::get_children(utility::vector<vfile> &out) const {
+
+    storage::dir_entry entry;
+    storage::directory_iter_t iter;
+
+    storage::fs_result result =
+      bd->mounted_as->get_first_child(dir_entry.node, entry, iter);
+    if (result == storage::fs_result::does_not_exist)
+      return storage::fs_result::success;
+    else if (result != storage::fs_result::success)
+      return result;
+
+    while (true) {
+
+      vfile vf;
+      vf.bd = bd;
+      vf.path = path;
+      vf.path.segments.add_end(entry.name);
+      vf.dir_entry = utility::move(entry);
+      out.add_end(utility::move(vf));
+
+      result = bd->mounted_as->get_next_child(dir_entry.node, entry, iter);
+      if (result == storage::fs_result::does_not_exist)
+        return storage::fs_result::success;
+      else if (result != storage::fs_result::success)
+        return result;
+
+    }
+
+  }
+
+  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);
+  }
+
+  //TODO: see comment at top of vfile.hpp.
+  static const vfile *root;
+
+  void set_root(const vfile &root) {
+    kernel::vfile::root = new vfile(root);
+  }
+
+  storage::fs_result lookup_path(
+    const canon_path &path, vfile &out, bool follow_final_symlink
+  ) {
+
+    //assume path is absolute.
+
+    out = *root;
+    for (unsigned i = 0; i < path.segments.count; ++i) {
+
+      vfile result;
+      RET_NOT_SUC(out.follow_symlinks(result))
+      out = utility::move(result);
+
+      RET_NOT_SUC(out.get_child(result, path.segments.buffer[i]))
+      out = utility::move(result);
+
+    }
+
+    if (follow_final_symlink) {
+      vfile result;
+      RET_NOT_SUC(out.follow_symlinks(result))
+      out = utility::move(result);
+    }
+
+    return storage::fs_result::success;
+
+  }
+
+}