update

.gitignore

@@ -1,5 +1,5 @@
 .vscode/
-include/hilbert/kernel/limine.hpp
 limine
+mintsuki-freestanding-headers
 obj
 out

applications/init/main.cpp

@@ -1,29 +1,35 @@
-#include <hilbert/syscall.hpp>
+#include <daguerre/image.hpp>
-
-using hilbert::syscall::encoded_color;
-using hilbert::syscall::color;
-
-encoded_color *fb;
-uint32_t fb_width;
-uint32_t fb_height;
-uint32_t fb_pitch;
 
 int main(int, char **) {
 
-  hilbert::syscall::get_framebuffer(fb, fb_width, fb_height, fb_pitch);
+  auto fb = daguerre::get_hilbert_framebuffer();
-  for (uint32_t y = 0; y < fb_height; ++y)
+
-    for (uint32_t x = 0; x < fb_width; ++x) {
+  auto white = daguerre::to_hilbert_color({.r = 255, .g = 255, .b = 255});
-       color c = {
+  auto gray  = daguerre::to_hilbert_color({.r = 127, .g = 127, .b = 127});
-        .r = 0,
+
-        .g = (uint8_t)(y * 255 / fb_height),
+  for (unsigned y = 0; y < fb.get_height(); ++y)
-        .b = (uint8_t)(x * 255 / fb_width)
+    for (unsigned x = 0; x < fb.get_width(); ++x) {
-      };
+      uint8_t v = (y / 16) % 2 == (x / 16) % 2;
-      fb[y * fb_pitch + x] = hilbert::syscall::encode_color(c);
+      fb.get(x, y) = v ? white : gray;
     }
 
-  //*(int *)0x12345678 = 0;
+  daguerre::image<daguerre::color24> img;
-  //fb_width = *(uint32_t *)0xffffffffc0000000;
+
-  //return 100 / (uint8_t)(uint64_t)fb;
+  std::FILE *file = std::fopen("/assets/burdon.ppm", "r");
+  assert(file != 0);
+  assert(daguerre::try_load_ppm(file, img));
+  std::fclose(file);
+
+  unsigned width =
+    img.get_width() < fb.get_width() ? img.get_width() : fb.get_width();
+  unsigned height =
+    img.get_height() < fb.get_height() ? img.get_height() : fb.get_height();
+
+  unsigned x_off = (fb.get_width() - width) / 2;
+  unsigned y_off = (fb.get_height() - height) / 2;
+
+  daguerre::copy_image(img, fb, 0, 0, x_off, y_off, width, height);
+
   return 0;
 
 }

documentation/syscalls.txt

@@ -8,6 +8,15 @@ for all system calls:
   rbx, rbp, rsp, r12-r15 are preserved.
   rcx, rflags, r8-r11 are clobbered.
 
+file result:
+  0 = success
+  1 = bad file handle
+  2 = device error
+  3 = file system corrupt
+  4 = tried to read out of bounds
+  5 = file does not exist
+  6 = tried to open directory
+
 encode color:
   rax in: 0
   edi in: r + g * 256 + b * 65536
@@ -20,3 +29,40 @@ get framebuffer:
   esi out: pitch
   framebuffer is always 32 bpp. use the encode color syscall
   to encode colors. pitch is in dwords, not in bytes.
+
+open file:
+  rax in: 2
+  rdi in: pointer to file path
+  rsi in: file path length
+  rax out: file result
+  rdi out: file handle (if rax = success)
+
+get file length:
+  rax in: 3
+  rdi in: file handle
+  rax out: file result
+  rdi out: file length (if rax = success)
+
+read from file:
+  rax in: 4
+  rdi in: pointer to request struct
+  rax out: file result
+  request struct:
+    qword: file handle
+    qword: start offset in bytes
+    qword: length in bytes
+    qword: pointer to buffer
+
+end this process:
+  rax in: 5
+  edi in: exit code (signed)
+
+get new pages:
+  rax in: 6
+  rdi in: number of pages to allocate
+  rax out: start of first page
+  the allocated pages are next to each other, writable, and not executable.
+
+close file:
+  rax in: 7
+  rdi in: file handle

include/hilbert/kernel/framebuffer.hpp

@@ -1,27 +0,0 @@
-#ifndef HILBERT_KERNEL_FRAMEBUFFER_HPP
-#define HILBERT_KERNEL_FRAMEBUFFER_HPP
-
-#include <cstdint>
-
-namespace hilbert::kernel::framebuffer {
-
-  extern int width;
-  extern int height;
-
-  void init_framebuffer(uint64_t paddr, uint64_t vaddr, uint64_t width, uint64_t height, uint64_t pitch);
-
-  typedef uint32_t color;
-  color encode_color(uint8_t r, uint8_t g, uint8_t b);
-
-  void set_pixel(int x, int y, color c);
-
-  //[from_start_x, from_end_x) x [from_start_y, from_end_y) -> [to_start_x, ...) x [to_start_y, ...)
-  //we assume from_start_x < from_end_x and from_start_y < from_end_y
-  void move_region(int from_start_x, int from_start_y, int from_end_x, int from_end_y, int to_start_x, int to_start_y);
-
-  //[start_x, end_x) x [start_y, end_y)
-  void fill_region(int start_x, int start_y, int end_x, int end_y, color c);
-
-}
-
-#endif

include/hilbert/kernel/storage/fs/tarfs.hpp

@@ -1,32 +0,0 @@
-#ifndef HILBERT_KERNEL_STORAGE_FS_TARFS_HPP
-#define HILBERT_KERNEL_STORAGE_FS_TARFS_HPP
-
-#include <hilbert/kernel/storage.hpp>
-
-namespace hilbert::kernel::storage::fs {
-
-  class tarfs_instance : public file_system_instance {
-
-  private:
-    block_device *bd;
-
-    fs_result next_node(node_id_t node, std::optional<node_id_t> &out);
-    fs_result read_full_name(node_id_t node, utility::string &out);
-    //len <= 12.
-    fs_result read_num(uint64_t offset, unsigned len, uint64_t &out);
-    fs_result first_child_starting_at(node_id_t parent, node_id_t start, std::optional<node_id_t> &out);
-    fs_result get_dir_entry(node_id_t node, dir_entry &entry);
-
-  public:
-    tarfs_instance(block_device *bd);
-
-    fs_result get_root_node(node_id_t &out);
-    fs_result get_first_child(node_id_t node, std::optional<dir_entry> &out, directory_iter_t &iter_out);
-    fs_result get_next_child(node_id_t node, std::optional<dir_entry> &out, directory_iter_t &iter);
-    fs_result read_bytes_from_file(node_id_t node, uint64_t start, uint64_t count, void *into);
-
-  };
-
-}
-
-#endif

include/hilbert/kernel/syscall.hpp

@@ -1,13 +0,0 @@
-#include <cstdint>
-
-namespace hilbert::kernel::syscall {
-
-  typedef void (*syscall_handler)(
-    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx);
-
-  void init_syscalls();
-
-  //assumes this rax has not been used yet and is < 256.
-  void add_syscall(uint64_t rax, syscall_handler handler);
-
-}

include/hilbert/syscall.hpp

@@ -1,24 +0,0 @@
-#ifndef HILBERT_SYSCALL_HPP
-#define HILBERT_SYSCALL_HPP
-
-#include <cstdint>
-
-namespace hilbert::syscall {
-
-  typedef uint32_t encoded_color;
-
-  struct [[gnu::packed]] color {
-    uint8_t r;
-    uint8_t g;
-    uint8_t b;
-  };
-
-  extern "C" encoded_color encode_color(color c);
-
-  extern "C" void get_framebuffer(encoded_color *&framebuffer_out,
-    uint32_t &width_out, uint32_t &height_out, uint32_t &pitch_out
-  );
-
-}
-
-#endif

kernel/allocator.cpp

@@ -1,5 +1,5 @@
 #include <hilbert/kernel/paging.hpp>
-#include <cstddef>
+#include <stddef.h>
 
 namespace hilbert::kernel::allocator {
 

kernel/application.cpp

@@ -72,6 +72,15 @@ namespace hilbert::kernel::application {
 
   }
 
+  bool app_instance::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 app_instance::get_free_vaddr_pages(uint64_t count) {
     uint64_t start = 0x200000 / 4096;
     uint64_t length = 0;
@@ -129,7 +138,10 @@ namespace hilbert::kernel::application {
     bool executable;
   };
 
-  create_app_result create_app(const vfile::vfile &file, app_instance *&out) {
+  create_app_result create_app(
+    const vfile::vfile &file, app_instance *&out,
+    const vfile::vfile &working_dir
+  ) {
 
     uint8_t magic[16];
     if (file.dir_entry.length < 64)
@@ -259,6 +271,8 @@ namespace hilbert::kernel::application {
     out->saved_regs.rsp = 0x1ff000;
     out->saved_regs.rip = entry_point;
 
+    out->working_dir = working_dir;
+
     return create_app_result::success;
 
   }

kernel/entry.cpp

@@ -3,9 +3,9 @@
 #include <hilbert/kernel/application.hpp>
 #include <hilbert/kernel/framebuffer.hpp>
 #include <hilbert/kernel/terminal.hpp>
-#include <hilbert/kernel/limine.hpp>
 #include <hilbert/kernel/paging.hpp>
 #include <hilbert/kernel/vfile.hpp>
+#include "../limine/limine.h"
 
 using namespace hilbert::kernel;
 
@@ -197,32 +197,31 @@ extern "C" [[noreturn]] void start_user_mode(
 
   terminal::init_terminal();
 
-  storage::bd::memory initfs_bd(initfs, initfs_len);
+  auto *initfs_bd = new storage::bd::memory(initfs, initfs_len);
-  storage::fs::tarfs_instance initfs_fs(&initfs_bd);
+  auto *initfs_fs = new storage::fs::tarfs_instance(initfs_bd);
-  initfs_bd.mounted_as = &initfs_fs;
+  initfs_bd->mounted_as = initfs_fs;
 
-  vfile::vfile vfs_root;
+  vfile::vfile initfs_root;
-  vfs_root.bd = &initfs_bd;
+  initfs_root.bd = initfs_bd;
-  vfs_root.dir_entry.type = storage::file_type::directory;
+  initfs_root.dir_entry.type = storage::file_type::directory;
-  vfs_root.path.absolute = true;
+  initfs_root.path.absolute = true;
 
-  if (initfs_fs.get_root_node(vfs_root.dir_entry.node) !=
+  if (initfs_fs->get_root_node(initfs_root.dir_entry.node) !=
       storage::fs_result::success)
     print_and_halt("failed to get root node of initfs.");
 
+  vfile::set_root(initfs_root);
+
   utility::string init_path_string("/bin/init.elf", 13);
   vfile::canon_path init_path;
   vfile::canonize_path(init_path_string, init_path);
 
-  std::optional<vfile::vfile> init_file;
+  vfile::vfile init_file;
-  if (vfile::lookup_path(vfs_root, init_path, init_file) !=
+  if (vfile::lookup_path(init_path, init_file) != storage::fs_result::success)
-      storage::fs_result::success)
     print_and_halt("failed to look up /bin/init.elf.");
-  if (!init_file)
-    print_and_halt("/bin/init.elf does not exist.");
 
   application::app_instance *init;
-  if (application::create_app(*init_file, init) !=
+  if (application::create_app(init_file, init, initfs_root) !=
       application::create_app_result::success)
     print_and_halt("failed to parse /bin/init.elf.");
 

kernel/framebuffer.cpp

@@ -1,44 +1,13 @@
 #include <hilbert/kernel/application.hpp>
 #include <hilbert/kernel/framebuffer.hpp>
-#include <hilbert/kernel/syscall.hpp>
 
 namespace hilbert::kernel::framebuffer {
 
-  static uint64_t paddr;
+  uint64_t paddr;
   static uint32_t *vaddr;
   int width;
   int height;
-  static int dword_pitch;
+  int dword_pitch;
-
-  void encode_color_syscall(
-    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
-  ) {
-    rax = (uint64_t)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 *app = application::running_app;
-    if (app->framebuffer_vaddr == 0) {
-      uint64_t pages_needed = (dword_pitch * height * 4 - 1) / 4096 + 1;
-      uint64_t vaddr = app->get_free_vaddr_pages(pages_needed);
-      for (uint64_t i = 0; i < pages_needed; ++i)
-        app->map_page(vaddr + i * 4096, paddr + i * 4096, true, false, false);
-      app->framebuffer_vaddr = vaddr;
-    }
-
-    rax = app->framebuffer_vaddr;
-    rdi = (uint64_t)(uint32_t)width | ((uint64_t)(uint32_t)height << 32);
-    rsi = (uint32_t)dword_pitch;
-    rdx = 0;
-
-  }
 
   void init_framebuffer(uint64_t paddr, uint64_t vaddr,
     uint64_t width, uint64_t height, uint64_t pitch
@@ -52,9 +21,6 @@ namespace hilbert::kernel::framebuffer {
     framebuffer::height = height;
     dword_pitch = pitch / 4;
 
-    syscall::add_syscall(0, &encode_color_syscall);
-    syscall::add_syscall(1, &get_framebuffer_syscall);
-
   }
 
   color encode_color(uint8_t r, uint8_t g, uint8_t b) {

kernel/include/hilbert/kernel/application.hpp

@@ -1,13 +1,14 @@
-#ifndef HILBERT_KERNEL_APPLICATION_HPP
+#pragma once
-#define HILBERT_KERNEL_APPLICATION_HPP
 
 #include <hilbert/kernel/vfile.hpp>
-#include <cstdint>
+#include <stdint.h>
 
 //TODO: end application, threading.
 
 namespace hilbert::kernel::application {
 
+  void init_syscalls();
+
   enum class app_state {
     running,
     paused,
@@ -16,6 +17,10 @@ namespace hilbert::kernel::application {
 
   struct app_instance {
 
+    utility::id_allocator<vfile::vfile> open_files;
+
+    vfile::vfile working_dir;
+
     app_state state;
 
     uint64_t *p4;
@@ -31,7 +36,7 @@ namespace hilbert::kernel::application {
     uint64_t framebuffer_vaddr;
 
     //only valid if state is zombie
-    int exit_code;
+    int32_t exit_code;
 
     //only valid if state is paused
     struct {
@@ -46,7 +51,10 @@ namespace hilbert::kernel::application {
     void map_page(uint64_t vaddr, uint64_t paddr,
       bool write, bool execute, bool free_pram_on_exit);
 
-    //returns start of first page.
+    //where "owned" means in lower half and marked free on exit
+    bool is_page_owned(uint64_t vaddr);
+
+    //returns start of first page
     uint64_t get_free_vaddr_pages(uint64_t count);
 
     //in lower half
@@ -63,8 +71,7 @@ namespace hilbert::kernel::application {
     fs_corrupt
   };
 
-  create_app_result create_app(const vfile::vfile &file, app_instance *&out);
+  create_app_result create_app(const vfile::vfile &file,
+    app_instance *&out, const vfile::vfile &working_dir);
 
 }
-
-#endif

kernel/include/hilbert/kernel/framebuffer.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace hilbert::kernel::framebuffer {
+
+  extern uint64_t paddr;
+  extern int width;
+  extern int height;
+  extern int dword_pitch;
+
+  void init_framebuffer(
+    uint64_t paddr, uint64_t vaddr, uint64_t width,
+    uint64_t height, uint64_t pitch);
+
+  typedef uint32_t color;
+  color encode_color(uint8_t r, uint8_t g, uint8_t b);
+
+  void set_pixel(int x, int y, color c);
+
+  //[from_start_x, from_end_x) x [from_start_y, from_end_y)
+  //  -> [to_start_x, ...) x [to_start_y, ...).
+  //we assume from_start_x < from_end_x and from_start_y < from_end_y.
+  void move_region(
+    int from_start_x, int from_start_y, int from_end_x,
+    int from_end_y, int to_start_x, int to_start_y);
+
+  //[start_x, end_x) x [start_y, end_y)
+  void fill_region(int start_x, int start_y, int end_x, int end_y, color c);
+
+}

kernel/include/hilbert/kernel/paging.hpp

@@ -1,7 +1,6 @@
-#ifndef HILBERT_KERNEL_PAGING_HPP
+#pragma once
-#define HILBERT_KERNEL_PAGING_HPP
 
-#include <cstdint>
+#include <stdint.h>
 
 //in paging.asm
 extern "C" [[noreturn]] void switch_to_kernel_p4(void (*and_then_jump_to)());
@@ -41,5 +40,3 @@ namespace hilbert::kernel::paging {
   extern uint64_t kernel_p4e;
 
 }
-
-#endif

kernel/include/hilbert/kernel/storage.hpp

@@ -1,8 +1,7 @@
-#ifndef HILBERT_KERNEL_STORAGE_HPP
+#pragma once
-#define HILBERT_KERNEL_STORAGE_HPP
 
 #include <hilbert/kernel/utility.hpp>
-#include <cstdint>
+#include <stdint.h>
 
 namespace hilbert::kernel::storage {
 
@@ -24,7 +23,8 @@ namespace hilbert::kernel::storage {
   enum class fs_result {
     success,
     device_error,
-    fs_corrupt
+    fs_corrupt,
+    does_not_exist
   };
 
   struct dir_entry {
@@ -47,16 +47,19 @@ namespace hilbert::kernel::storage {
     //it is assumed that this is a directory. sets iter_out
     //to a value that can be passed to subsequent calls
     //to get_next_child with the same argument for node.
-    virtual fs_result get_first_child(node_id_t node, std::optional<dir_entry> &out, directory_iter_t &iter_out) = 0;
+    virtual fs_result get_first_child(
+      node_id_t node, dir_entry &out, directory_iter_t &iter_out) = 0;
 
     //it is assumed that this is a directory. sets iter_out
     //to a value that can be passed to subsequent calls
     //to get_next_child with the same argument for node.
-    virtual fs_result get_next_child(node_id_t node, std::optional<dir_entry> &out, directory_iter_t &iter) = 0;
+    virtual fs_result get_next_child(
+      node_id_t node, dir_entry &out, directory_iter_t &iter) = 0;
 
     //it is assumed that this is a regular file and that
     //the region requested is within the bounds of the file.
-    virtual fs_result read_bytes_from_file(node_id_t node, uint64_t start, uint64_t count, void *into) = 0;
+    virtual fs_result read_bytes_from_file(
+      node_id_t node, uint64_t start, uint64_t count, void *into) = 0;
 
   };
 
@@ -72,7 +75,8 @@ namespace hilbert::kernel::storage {
   protected:
     //implemented in driver. it is assumed that the
     //blocks are within the bounds of the device.
-    virtual bd_result read_blocks_no_cache(uint64_t start, uint64_t count, void *into) = 0;
+    virtual bd_result read_blocks_no_cache(
+      uint64_t start, uint64_t count, void *into) = 0;
 
     //it is assumed that this is only called once, by the driver, after
     //block_size and block_count have been set, and before read_bytes or
@@ -100,5 +104,3 @@ namespace hilbert::kernel::storage {
   };
 
 }
-
-#endif

kernel/include/hilbert/kernel/storage/bd/memory.hpp

@@ -1,5 +1,4 @@
-#ifndef HILBERT_KERNEL_STORAGE_BD_MEMORY_HPP
+#pragma once
-#define HILBERT_KERNEL_STORAGE_BD_MEMORY_HPP
 
 #include <hilbert/kernel/storage.hpp>
 
@@ -13,10 +12,9 @@ namespace hilbert::kernel::storage::bd {
   public:
     memory(void *buffer, uint64_t buffer_len);
 
-    bd_result read_blocks_no_cache(uint64_t start, uint64_t count, void *into) override;
+    bd_result read_blocks_no_cache(
+      uint64_t start, uint64_t count, void *into) override;
 
   };
 
 }
-
-#endif

kernel/include/hilbert/kernel/storage/fs/tarfs.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <hilbert/kernel/storage.hpp>
+
+namespace hilbert::kernel::storage::fs {
+
+  class tarfs_instance : public file_system_instance {
+
+  private:
+    block_device *bd;
+
+    fs_result next_node(node_id_t node, node_id_t &out);
+    fs_result read_full_name(node_id_t node, utility::string &out);
+    //len <= 12
+    fs_result read_num(uint64_t offset, unsigned len, uint64_t &out);
+    fs_result first_child_starting_at(
+      node_id_t parent, node_id_t start, node_id_t &out);
+    fs_result get_dir_entry(node_id_t node, dir_entry &entry);
+
+  public:
+    tarfs_instance(block_device *bd);
+
+    fs_result get_root_node(node_id_t &out);
+    fs_result get_first_child(node_id_t node,
+      dir_entry &out, directory_iter_t &iter_out);
+    fs_result get_next_child(
+      node_id_t node, dir_entry &out, directory_iter_t &iter);
+    fs_result read_bytes_from_file(
+      node_id_t node, uint64_t start, uint64_t count, void *into);
+
+  };
+
+}

kernel/include/hilbert/kernel/terminal.hpp

@@ -1,10 +1,9 @@
-#ifndef HILBERT_KERNEL_TERMINAL_HPP
+#pragma once
-#define HILBERT_KERNEL_TERMINAL_HPP
 
 #include <hilbert/kernel/framebuffer.hpp>
 #include <hilbert/kernel/utility.hpp>
-#include <cstddef>
+#include <stddef.h>
-#include <cstdint>
+#include <stdint.h>
 
 namespace hilbert::kernel::terminal {
 
@@ -31,5 +30,3 @@ namespace hilbert::kernel::terminal {
   void put_int_hex(uint64_t n, int digits, bool with_dots = true);
 
 }
-
-#endif

kernel/include/hilbert/kernel/utility.hpp

@@ -1,20 +1,44 @@
-#ifndef HILBERT_KERNEL_UTILITY_HPP
+#pragma once
-#define HILBERT_KERNEL_UTILITY_HPP
 
-#include <optional>
+#include <stddef.h>
-#include <cstdint>
+#include <stdint.h>
+
+void *operator new(size_t, void *ptr);
+void operator delete(void *, void *);
 
 namespace hilbert::kernel::utility {
 
+  template <class t>
+  struct no_ref;
+  template <class t>
+  struct no_ref<t &&> {
+    typedef t _t;
+  };
+  template <class t>
+  struct no_ref<t &> {
+    typedef t _t;
+  };
+  template <class t>
+  struct no_ref {
+    typedef t _t;
+  };
+
+  template <class t>
+  constexpr typename no_ref<t>::_t &&move(t &&v) {
+    return static_cast<typename no_ref<t>::_t &&>(v);
+  }
+
   template <class t>
   static inline t min(t a, t b) {
     return a < b ? a : b;
   }
 
   //includes start_i, does not include end_i
-  void mark_bitmap_region_zero(uint64_t *bitmap, uint64_t start_i, uint64_t end_i);
+  void mark_bitmap_region_zero(
+    uint64_t *bitmap, uint64_t start_i, uint64_t end_i);
   //includes start_i, does not include end_i
-  void mark_bitmap_region_one(uint64_t *bitmap, uint64_t start_i, uint64_t end_i);
+  void mark_bitmap_region_one(
+    uint64_t *bitmap, uint64_t start_i, uint64_t end_i);
 
   struct uuid {
     uint8_t bytes[16];
@@ -64,6 +88,9 @@ namespace hilbert::kernel::utility {
 
     list() : first(0), last(0) {}
 
+    list(const list &other) = delete;
+    list(list &&other) = delete;
+
     ~list() {
       if (first) {
         for (node *n = first->next; n; n = n->next)
@@ -72,6 +99,9 @@ namespace hilbert::kernel::utility {
       }
     }
 
+    list &operator =(const list &other) = delete;
+    list &operator =(list &&other) = delete;
+
     void insert_end(const value_t &value) {
       node *n = new node {};
       n->value = value;
@@ -136,7 +166,7 @@ namespace hilbert::kernel::utility {
         buffer[i] = copy_from[i];
     }
 
-    vector(const vector<value_t> &other)
+    vector(const vector &other)
       : buffer(new value_t[other.buffer_len]),
         buffer_len(other.buffer_len), count(other.count)
     {
@@ -144,12 +174,14 @@ namespace hilbert::kernel::utility {
         buffer[i] = other.buffer[i];
     }
 
+    vector(vector &&other) = delete;
+
     ~vector() {
       if (buffer)
         delete[] buffer;
     }
 
-    vector<value_t> &operator =(const vector<value_t> &other) {
+    vector &operator =(const vector &other) {
       if (buffer)
         delete[] buffer;
       buffer = new value_t[other.buffer_len];
@@ -160,7 +192,7 @@ namespace hilbert::kernel::utility {
       return *this;
     }
 
-    vector<value_t> &operator =(vector<value_t> &&other) {
+    vector &operator =(vector &&other) {
       if (buffer)
         delete[] buffer;
       buffer = other.buffer;
@@ -170,7 +202,7 @@ namespace hilbert::kernel::utility {
       return *this;
     }
 
-    bool operator ==(const vector<value_t> &other) {
+    bool operator ==(const vector &other) {
       if (other.count != count)
         return false;
       for (unsigned i = 0; i < count; ++i)
@@ -188,7 +220,7 @@ namespace hilbert::kernel::utility {
       while (new_buffer_len < target_len);
       value_t *new_buffer = new value_t[new_buffer_len];
       for (unsigned i = 0; i < count; ++i)
-        new_buffer[i] = std::move(buffer[i]);
+        new_buffer[i] = move(buffer[i]);
       delete[] buffer;
       buffer = new_buffer;
       buffer_len = new_buffer_len;
@@ -196,7 +228,7 @@ namespace hilbert::kernel::utility {
 
     void add_end(value_t &&v) {
       verify_buffer_len(count + 1);
-      buffer[count] = std::move(v);
+      buffer[count] = move(v);
       ++count;
     }
 
@@ -206,7 +238,7 @@ namespace hilbert::kernel::utility {
       ++count;
     }
 
-    bool starts_with(const vector<value_t> &other) {
+    bool starts_with(const vector &other) {
       if (count < other.count)
         return false;
       for (unsigned i = 0; i < other.count; ++i)
@@ -219,6 +251,47 @@ namespace hilbert::kernel::utility {
 
   typedef vector<char> string;
 
-}
+  template <class value_t>
+  struct id_allocator {
 
-#endif
+    vector<value_t *> the_vector;
+
+  public:
+    id_allocator() : the_vector() {}
+    id_allocator(const id_allocator &other) = delete;
+    id_allocator(id_allocator &&other) = delete;
+    id_allocator &operator =(const id_allocator &other) = delete;
+    id_allocator &operator =(id_allocator &&other) = delete;
+
+    //returns id; pointer becomes owned by id_allocator
+    unsigned add(value_t *v) {
+      for (unsigned i = 0; i < the_vector.count; ++i)
+        if (the_vector.buffer[i] == 0) {
+          the_vector.buffer[i] = v;
+          return i;
+        }
+      the_vector.add_end(v);
+      return the_vector.count - 1;
+    }
+
+    //returns id
+    unsigned add_new(value_t &&v) {
+      return add(new value_t(move(v)));
+    }
+
+    bool has_id(unsigned i) {
+      return i < the_vector.count && the_vector.buffer[i] != 0;
+    }
+
+    value_t &get(unsigned i) {
+      return *the_vector.buffer[i];
+    }
+
+    void remove_id(unsigned i) {
+      delete the_vector.buffer[i];
+      the_vector.buffer[i] = 0;
+    }
+
+  };
+
+}

kernel/include/hilbert/kernel/vfile.hpp

@@ -1,5 +1,4 @@
-#ifndef HILBERT_KERNEL_VFILE_HPP
+#pragma once
-#define HILBERT_KERNEL_VFILE_HPP
 
 #include <hilbert/kernel/storage.hpp>
 #include <hilbert/kernel/utility.hpp>
@@ -38,13 +37,11 @@ namespace hilbert::kernel::vfile {
     storage::block_device *bd;
     storage::dir_entry dir_entry;
 
-    //TODO: instead of passing root, use saved mount points.
+    storage::fs_result follow_symlinks(vfile &out) const;
-    storage::fs_result follow_symlinks(
-      const vfile &root, std::optional<vfile> &out) const;
 
     //dir_entry.type is assumed to be directory.
     storage::fs_result get_child(
-      std::optional<vfile> &out, const utility::string &name) const;
+      vfile &out, const utility::string &name) const;
     //dir_entry.type is assumed to be directory. out must be empty on entry.
     storage::fs_result get_children(utility::vector<vfile> &out) const;
 
@@ -55,13 +52,12 @@ namespace hilbert::kernel::vfile {
 
   };
 
+  //TODO: see comment at top of file.
+  void set_root(const vfile &root);
+
   //path must be absolute. follows symlinks on all but the last node.
   //relative_to should be a directory to do the lookup inside; e.g.,
   //if relative_to is /a/b and path is c, then out becomes /a/b/c.
-  //TODO: instead of passing root, use saved mount points.
+  storage::fs_result lookup_path(const canon_path &path, vfile &out);
-  storage::fs_result lookup_path(
-    const vfile &root, const canon_path &path, std::optional<vfile> &out);
 
 }
-
-#endif

kernel/storage/fs/tarfs.cpp

@@ -5,27 +5,25 @@
 
 namespace hilbert::kernel::storage::fs {
 
-#define BD_TO_FS(expr) \
+  #define BD_TO_FS(expr) \
-  { \
+    { \
-    bd_result _result = expr; \
+      bd_result _result = expr; \
-    if (_result == bd_result::out_of_bounds) \
+      if (_result == bd_result::out_of_bounds) \
-      return fs_result::fs_corrupt; \
+        return fs_result::fs_corrupt; \
-    if (_result == bd_result::device_error) \
+      if (_result == bd_result::device_error) \
-      return fs_result::device_error; \
+        return fs_result::device_error; \
-  }
+    }
 
-#define FS_TO_FS(expr) \
+  #define FS_TO_FS(expr) \
-  { \
+    { \
-    fs_result _result = expr; \
+      fs_result _result = expr; \
-    if (_result != fs_result::success) \
+      if (_result != fs_result::success) \
-      return _result; \
+        return _result; \
-  }
+    }
 
   tarfs_instance::tarfs_instance(block_device *bd) : bd(bd) {}
 
-  fs_result tarfs_instance::next_node(
+  fs_result tarfs_instance::next_node(node_id_t node, node_id_t &out) {
-    node_id_t node, std::optional<node_id_t> &out
-  ) {
 
     uint64_t bytes;
     FS_TO_FS(read_num(node + 124, 12, bytes))
@@ -37,8 +35,7 @@ namespace hilbert::kernel::storage::fs {
       if (sector[i] != 0)
         return fs_result::success;
 
-    out = {};
+    return fs_result::does_not_exist;
-    return fs_result::success;
 
   }
 
@@ -84,7 +81,7 @@ namespace hilbert::kernel::storage::fs {
   }
 
   fs_result tarfs_instance::first_child_starting_at(
-    node_id_t parent, node_id_t start, std::optional<node_id_t> &out
+    node_id_t parent, node_id_t start, node_id_t &out
   ) {
 
     utility::string parent_full_name;
@@ -93,9 +90,9 @@ namespace hilbert::kernel::storage::fs {
     utility::string child_full_name;
     out = start;
 
-    do {
+    while (true) {
 
-      FS_TO_FS(read_full_name(*out, child_full_name))
+      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)
@@ -110,11 +107,9 @@ namespace hilbert::kernel::storage::fs {
       }
 
     next:
-      next_node(*out, out);
+      FS_TO_FS(next_node(out, out))
 
-    } while (out);
+    }
-
-    return fs_result::success;
 
   }
 
@@ -171,7 +166,7 @@ namespace hilbert::kernel::storage::fs {
       BD_TO_FS(bd->read_bytes(node + 157, 100, target.buffer))
       while (target.count < 100 && target.buffer[target.count] != '\0')
         ++target.count;
-      entry.target = std::move(target);
+      entry.target = utility::move(target);
     }
 
     return fs_result::success;
@@ -181,64 +176,53 @@ namespace hilbert::kernel::storage::fs {
   fs_result tarfs_instance::get_root_node(node_id_t &out) {
 
     utility::string full_name;
-    std::optional<node_id_t> on = 0;
+    node_id_t on = 0;
 
-    do {
+    while (true) {
 
-      FS_TO_FS(read_full_name(*on, full_name))
+      FS_TO_FS(read_full_name(on, full_name))
       if (full_name.count == 2) {
-        out = *on;
+        out = on;
         return fs_result::success;
       }
-      next_node(*on, on);
+      fs_result result = next_node(on, on);
+      if (result == fs_result::does_not_exist)
+        return fs_result::fs_corrupt;
+      FS_TO_FS(result)
 
-    } while (on);
+    }
-
-    return fs_result::fs_corrupt;
 
   }
 
   fs_result tarfs_instance::get_first_child(
-    node_id_t node, std::optional<dir_entry> &out, directory_iter_t &iter_out
+    node_id_t node, dir_entry &out, directory_iter_t &iter_out
   ) {
 
-    std::optional<node_id_t> child;
+    node_id_t child;
     FS_TO_FS(first_child_starting_at(node, 0, child))
-    if (!child) {
-      out = {};
-      return fs_result::success;
-    }
 
     dir_entry entry;
-    FS_TO_FS(get_dir_entry(*child, entry))
+    FS_TO_FS(get_dir_entry(child, entry))
-    out = std::move(entry);
+    out = utility::move(entry);
-    iter_out = (directory_iter_t)*child;
+    iter_out = (directory_iter_t)child;
     return fs_result::success;
 
   }
 
   fs_result tarfs_instance::get_next_child(
-    node_id_t node, std::optional<dir_entry> &out, directory_iter_t &iter
+    node_id_t node, dir_entry &out, directory_iter_t &iter
   ) {
 
-    std::optional<node_id_t> start;
+    node_id_t start;
     FS_TO_FS(next_node((node_id_t)iter, start))
-    if (!start) {
-      out = {};
-      return fs_result::success;
-    }
 
-    std::optional<node_id_t> child;
+    node_id_t child;
-    FS_TO_FS(first_child_starting_at(node, *start, child))
+    FS_TO_FS(first_child_starting_at(node, start, child))
-    if (!child) {
-      out = {};
-      return fs_result::success;
-    }
 
     dir_entry entry;
-    FS_TO_FS(get_dir_entry(*child, entry))
+    FS_TO_FS(get_dir_entry(child, entry))
-    out = std::move(entry);
+    out = utility::move(entry);
-    iter = (directory_iter_t)*child;
+    iter = (directory_iter_t)child;
     return fs_result::success;
 
   }

kernel/syscall.cpp

@@ -1,21 +1,247 @@
 #include <hilbert/kernel/application.hpp>
 #include <hilbert/kernel/framebuffer.hpp>
-#include <hilbert/kernel/syscall.hpp>
 #include <hilbert/kernel/paging.hpp>
+#include <hilbert/kernel/vfile.hpp>
 
 namespace hilbert::kernel::syscall {
 
-  syscall_handler handlers[256];
+  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
+  };
 
-  void init_syscalls() {
+  bool is_range_owned_by_application(uint64_t start, uint64_t end) {
-    for (int i = 0; i < 256; ++i)
+    auto *app = application::running_app;
-      handlers[i] = 0;
+    uint64_t pstart = (start / 4096) * 4096;
+    uint64_t pend = ((end - 1) / 4096 + 1) * 4096;
+    for (uint64_t p = pstart; p < pend; p += 4096)
+      if (!app->is_page_owned(p))
+        return false;
+    return true;
   }
 
-  void add_syscall(uint64_t rax, syscall_handler handler) {
+  void set_zero(uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx) {
-    handlers[rax] = handler;
+    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 *app = application::running_app;
+    if (app->framebuffer_vaddr == 0) {
+      uint64_t pages_needed =
+        (framebuffer::dword_pitch * framebuffer::height * 4 - 1) / 4096 + 1;
+      uint64_t vaddr = app->get_free_vaddr_pages(pages_needed);
+      for (uint64_t i = 0; i < pages_needed; ++i)
+        app->map_page(
+          vaddr + i * 4096, framebuffer::paddr + i * 4096, true, false, false);
+      app->framebuffer_vaddr = vaddr;
+    }
+
+    rax = app->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((const char *)rdi, rsi);
+    vfile::canon_path cp;
+    vfile::canonize_path(path, cp);
+
+    set_zero(rax, rdi, rsi, rdx);
+
+    vfile::vfile file;
+    switch (vfile::lookup_path(cp, file)) {
+    case storage::fs_result::success:
+      break;
+    case storage::fs_result::device_error:
+      rax = file_result_device_error;
+      return;
+    case storage::fs_result::fs_corrupt:
+      rax = file_result_file_system_corrupt;
+      return;
+    case storage::fs_result::does_not_exist:
+      rax = file_result_does_not_exist;
+      return;
+    }
+
+    vfile::vfile real_file;
+    switch (file.follow_symlinks(real_file)) {
+    case storage::fs_result::success:
+      break;
+    case storage::fs_result::device_error:
+      rax = file_result_device_error;
+      return;
+    case storage::fs_result::fs_corrupt:
+      rax = file_result_file_system_corrupt;
+      return;
+    case storage::fs_result::does_not_exist:
+      rax = file_result_does_not_exist;
+      return;
+    }
+
+    if (real_file.dir_entry.type != storage::file_type::regular_file) {
+      rax = file_result_directory;
+      return;
+    }
+
+    unsigned handler =
+      application::running_app->open_files.add_new(utility::move(real_file));
+    rax = file_result_success;
+    rdi = (uint64_t)handler;
+
+  }
+
+  void get_file_length_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    auto &open_files = application::running_app->open_files;
+    unsigned handle = (unsigned)rdi;
+
+    set_zero(rax, rdi, rsi, rdx);
+
+    if (!open_files.has_id(handle)) {
+      rax = file_result_bad_file_handle;
+      return;
+    }
+
+    rax = file_result_success;
+    rdi = open_files.get(handle).dir_entry.length;
+
+  }
+
+  void read_from_file_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    if (!is_range_owned_by_application(rdi, rdi + 32)) {
+      set_zero(rax, rdi, rsi, rdx);
+      return;
+    }
+
+    const uint64_t *request = (const uint64_t *)rdi;
+    unsigned handle = (unsigned)request[0];
+    uint64_t start = request[1];
+    uint64_t length = request[2];
+    uint64_t buffer_vaddr = request[3];
+
+    set_zero(rax, rdi, rsi, rdx);
+
+    if (!is_range_owned_by_application(buffer_vaddr, buffer_vaddr + length))
+      return;
+
+    auto &open_files = application::running_app->open_files;
+
+    if (!open_files.has_id(handle))
+      rax = file_result_bad_file_handle;
+
+    vfile::vfile &file = open_files.get(handle);
+
+    if (start + length > file.dir_entry.length)
+      rax = file_result_out_of_bounds;
+
+    switch (file.read_file(start, length, (void *)buffer_vaddr)) {
+    case storage::fs_result::success:
+      rax = file_result_success;
+      return;
+    case storage::fs_result::device_error:
+      rax = file_result_device_error;
+      return;
+    case storage::fs_result::fs_corrupt:
+    case storage::fs_result::does_not_exist:
+      rax = file_result_file_system_corrupt;
+      return;
+    }
+
+  }
+
+  [[noreturn]] void end_this_process_syscall(
+    uint64_t &, uint64_t &, uint64_t &, uint64_t &
+  ) {
+
+    //TODO
+    while (1)
+      ;
+
+  }
+
+  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 *app = application::running_app;
+    uint64_t vaddr = app->get_free_vaddr_pages(count);
+
+    for (uint64_t i = 0; i < count; ++i) {
+      uint64_t paddr = paging::take_pram_page();
+      app->map_page(vaddr + i * 4096, paddr, true, false, true);
+    }
+
+    rax = vaddr;
+
+  }
+
+  void close_file_syscall(
+    uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
+  ) {
+
+    unsigned handle = rdi;
+    set_zero(rax, rdi, rsi, rdx);
+    application::running_app->open_files.remove_id(handle);
+
+  }
+
+  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,
+    &get_file_length_syscall,
+    &read_from_file_syscall,
+    &end_this_process_syscall,
+    &get_new_pages_syscall,
+    &close_file_syscall
+  };
+
+  static constexpr int max_syscall_number = 7;
+
 }
 
 using namespace hilbert::kernel::syscall;
@@ -24,13 +250,9 @@ extern "C" void do_syscall(
   uint64_t &rax, uint64_t &rdi, uint64_t &rsi, uint64_t &rdx
 ) {
 
-  if (rax < 256 && handlers[rax] != 0)
+  if (rax <= max_syscall_number && handlers[rax] != 0)
     handlers[rax](rax, rdi, rsi, rdx);
-  else {
+  else
-    rax = 0;
+    set_zero(rax, rdi, rsi, rdx);
-    rdi = 0;
-    rsi = 0;
-    rdx = 0;
-  }
 
 }

kernel/utility.cpp

@@ -1,5 +1,11 @@
 #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(

kernel/vfile.cpp

@@ -63,7 +63,7 @@ namespace hilbert::kernel::vfile {
 
       else {
         utility::string segment(str, segment_len);
-        out.segments.add_end(std::move(segment));
+        out.segments.add_end(utility::move(segment));
       }
 
       str += to_skip;
@@ -80,9 +80,7 @@ namespace hilbert::kernel::vfile {
       return _result; \
   }
 
-  storage::fs_result vfile::follow_symlinks(
+  storage::fs_result vfile::follow_symlinks(vfile &out) const {
-    const vfile &root, std::optional<vfile> &out
-  ) const {
 
     if (dir_entry.type != storage::file_type::symlink) {
       out = *this;
@@ -95,37 +93,33 @@ namespace hilbert::kernel::vfile {
     full_path.parent();
     full_path.rel(target_path);
 
-    std::optional<vfile> next;
+    vfile next;
-    RET_NOT_SUC(lookup_path(root, full_path, next))
+    RET_NOT_SUC(lookup_path(full_path, next))
-    if (!next) {
-      out = {};
-      return storage::fs_result::success;
-    }
 
-    next->path = path;
+    next.path = path;
-    return next->follow_symlinks(root, out);
+    return next.follow_symlinks(out);
 
   }
 
   storage::fs_result vfile::get_child(
-    std::optional<vfile> &out, const utility::string &name
+    vfile &out, const utility::string &name
   ) const {
 
-    std::optional<storage::dir_entry> entry;
+    storage::dir_entry entry;
     storage::directory_iter_t iter;
 
     RET_NOT_SUC(bd->mounted_as->get_first_child(dir_entry.node, entry, iter))
 
-    while (entry) {
+    while (true) {
 
-      if (entry->name == name) {
+      if (entry.name == name) {
 
         vfile vf;
         vf.bd = bd;
-        vf.dir_entry = std::move(*entry);
+        vf.dir_entry = utility::move(entry);
         vf.path = path;
         vf.path.segments.add_end(name);
-        out = std::move(vf);
+        out = utility::move(vf);
         return storage::fs_result::success;
 
       }
@@ -134,33 +128,37 @@ namespace hilbert::kernel::vfile {
 
     }
 
-    out = {};
-    return storage::fs_result::success;
-
   }
 
   storage::fs_result vfile::get_children(utility::vector<vfile> &out) const {
 
-    std::optional<storage::dir_entry> entry;
+    storage::dir_entry entry;
     storage::directory_iter_t iter;
 
-    RET_NOT_SUC(bd->mounted_as->get_first_child(dir_entry.node, entry, 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 (entry) {
+    while (true) {
 
       vfile vf;
       vf.bd = bd;
       vf.path = path;
-      vf.path.segments.add_end(entry->name);
+      vf.path.segments.add_end(entry.name);
-      vf.dir_entry = std::move(*entry);
+      vf.dir_entry = utility::move(entry);
-      out.add_end(std::move(vf));
+      out.add_end(utility::move(vf));
 
-      RET_NOT_SUC(bd->mounted_as->get_next_child(dir_entry.node, entry, iter))
+      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;
 
     }
 
-    return storage::fs_result::success;
-
   }
 
   storage::fs_result vfile::read_file(
@@ -170,25 +168,26 @@ namespace hilbert::kernel::vfile {
       dir_entry.node, start, length, into);
   }
 
-  storage::fs_result lookup_path(
+  //TODO: see comment at top of vfile.hpp.
-    const vfile &root, const canon_path &path, std::optional<vfile> &out
+  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) {
 
     //assume path is absolute.
 
-    out = root;
+    out = *root;
     for (unsigned i = 0; i < path.segments.count; ++i) {
 
-      std::optional<vfile> result;
+      vfile result;
-      RET_NOT_SUC(out->follow_symlinks(root, result))
+      RET_NOT_SUC(out.follow_symlinks(result))
-      out = std::move(result);
+      out = utility::move(result);
-      if (!out)
-        return storage::fs_result::success;
 
-      RET_NOT_SUC(out->get_child(result, path.segments.buffer[i]))
+      RET_NOT_SUC(out.get_child(result, path.segments.buffer[i]))
-      out = std::move(result);
+      out = utility::move(result);
-      if (!out)
-        return storage::fs_result::success;
 
     }
 

libraries/daguerre/include/daguerre/image.hpp

@@ -0,0 +1,155 @@
+#pragma once
+
+#include <euler/syscall.hpp>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+
+namespace daguerre {
+
+  struct color24 {
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
+  };
+
+  using hilbert_color = euler::syscall::encoded_color;
+
+  static inline hilbert_color to_hilbert_color(const color24 &c) {
+    return _syscall_encode_color(c.r, c.g, c.b);
+  }
+
+  template <class pixel_type = color24>
+  class image {
+
+    pixel_type *buffer;
+    unsigned width;
+    unsigned height;
+    unsigned pitch; //in pixels
+
+    bool buffer_owned;
+
+  public:
+    image() : buffer(0) {}
+
+    image(pixel_type *buffer, unsigned width,
+      unsigned height, unsigned pitch, bool buffer_owned
+    ) : buffer(buffer), width(width), height(height),
+        pitch(pitch), buffer_owned(buffer_owned) {}
+
+    image(unsigned width, unsigned height)
+      : buffer(new pixel_type[width * height]), width(width),
+        height(height), pitch(width), buffer_owned(true) {}
+
+    image(const image<pixel_type> &other) = delete;
+
+    image(image<pixel_type> &&other)
+      : buffer(other.buffer), width(other.width), height(other.height),
+        pitch(other.pitch), buffer_owned(other.buffer_owned) {
+      other.buffer = 0;
+    }
+
+    ~image() {
+      if (buffer && buffer_owned)
+        delete[] buffer;
+    }
+
+    image &operator =(const image<pixel_type> &other) = delete;
+
+    image &operator =(image<pixel_type> &&other) {
+      if (buffer && buffer_owned)
+        delete[] buffer;
+      buffer = other.buffer;
+      width = other.width;
+      height = other.height;
+      pitch = other.pitch;
+      buffer_owned = other.buffer_owned;
+      other.buffer = 0;
+      return *this;
+    }
+
+    pixel_type &get(unsigned x, unsigned y) {
+      return buffer[y * pitch + x];
+    }
+
+    const pixel_type &get(unsigned x, unsigned y) const {
+      return buffer[y * pitch + x];
+    }
+
+    pixel_type *get_buffer() {
+      return buffer;
+    }
+
+    const pixel_type *get_buffer() const {
+      return buffer;
+    }
+
+    unsigned get_width() const {
+      return width;
+    }
+
+    unsigned get_height() const {
+      return height;
+    }
+
+    unsigned get_pitch() const {
+      return pitch;
+    }
+
+  };
+
+  template <class pixel_type>
+  void default_converter(const pixel_type &i, pixel_type &o) {
+    o = i;
+  }
+
+  static inline void default_converter(const color24 &i, hilbert_color &o) {
+    o = to_hilbert_color(i);
+  }
+
+  //copies a rectangle of size width x height from source to destination. the
+  //rectangle starts in source at (source_x, source_y), and in destination at
+  //(destination_x, destination_y). every pixel is passed through the converter
+  //template argument.
+  template <
+    class source_pixel_type, class destination_pixel_type,
+    void (*converter)(const source_pixel_type &, destination_pixel_type &) =
+      &default_converter>
+  void copy_image(const image<source_pixel_type> &source,
+    image<destination_pixel_type> &destination, unsigned source_x,
+    unsigned source_y, unsigned destination_x, unsigned destination_y,
+    unsigned width, unsigned height
+  ) {
+
+    assert(source_x + width <= source.get_width());
+    assert(source_y + height <= source.get_height());
+    assert(destination_x + width <= destination.get_width());
+    assert(destination_y + height <= destination.get_height());
+
+    unsigned source_pitch = source.get_pitch();
+    unsigned destination_pitch = destination.get_pitch();
+
+    const source_pixel_type *source_buffer =
+      &source.get_buffer()[source_y * source_pitch + source_x];
+    destination_pixel_type *destination_buffer = &destination.get_buffer()[
+      destination_y * destination_pitch + destination_x];
+
+    for (unsigned y = 0; y < height; ++y)
+      for (unsigned x = 0; x < width; ++x)
+        converter(source_buffer[y * source_pitch + x],
+          destination_buffer[y * destination_pitch + x]);
+
+  }
+
+  static inline image<hilbert_color> get_hilbert_framebuffer() {
+    hilbert_color *ptr;
+    uint32_t width;
+    uint32_t height;
+    uint32_t pitch;
+    _syscall_get_framebuffer(ptr, width, height, pitch);
+    return image<hilbert_color>(ptr, width, height, pitch, false);
+  }
+
+  bool try_load_ppm(std::FILE *from, image<color24> &into);
+
+}

libraries/daguerre/ppm.cpp

@@ -0,0 +1,52 @@
+#include <daguerre/image.hpp>
+#include <cctype>
+
+namespace daguerre {
+
+  static unsigned read_int(std::FILE *from) {
+    unsigned out = 0;
+    int ch;
+    do
+      ch = std::fgetc(from);
+    while (std::isspace(ch));
+    while (true) {
+      if (ch == EOF)
+        return out;
+      if (ch < '0' || ch > '9') {
+        std::ungetc(ch, from);
+        return out;
+      }
+      out = out * 10 + (ch - '0');
+      ch = std::fgetc(from);
+    }
+  }
+
+  bool try_load_ppm(std::FILE *from, image<color24> &into) {
+
+    if (std::fgetc(from) != 'P' || std::fgetc(from) != '6' ||
+        std::fgetc(from) != '\n')
+      return false;
+
+    unsigned width = read_int(from);
+    unsigned height = read_int(from);
+    unsigned max = read_int(from);
+    std::fgetc(from);//newline
+
+    if (max != 255)
+      return false;
+
+    into = image<color24>(width, height);
+    color24 *buffer = into.get_buffer();
+
+    for (unsigned y = 0; y < height; ++y)
+      for (unsigned x = 0; x < width; ++x) {
+        buffer[y * width + x].r = std::fgetc(from);
+        buffer[y * width + x].g = std::fgetc(from);
+        buffer[y * width + x].b = std::fgetc(from);
+      }
+
+    return true;
+
+  }
+
+}

libraries/euler/allocator.cpp

@@ -0,0 +1,147 @@
+#include <euler/syscall.hpp>
+
+//i guess we could figure out which parts of the pages the kernel allocated to
+//load the application were not actually needed and add those to the memory
+//that is available to be allocated, but whatever.
+
+namespace euler::allocator {
+
+  struct block_info {
+    //vaddr, divisible by size
+    uint64_t start;
+    //power of 2, 0 for unused
+    uint64_t size;
+  };
+
+  struct block_info_page {
+    block_info infos[255];
+    block_info_page *next;
+  };
+
+  static_assert(sizeof(block_info_page) == 4088);
+
+  static block_info_page *first_bi_page = 0;
+
+  static block_info *try_find_block(uint64_t start, uint64_t size) {
+    for (block_info_page *bip = first_bi_page; bip; bip = bip->next)
+      for (int i = 0; i < 255; ++i)
+        if (bip->infos[i].start == start && bip->infos[i].size == size)
+          return bip->infos + i;
+    return 0;
+  }
+
+  static block_info *add_block(uint64_t start, uint64_t size) {
+    for (block_info_page *bip = first_bi_page; bip; bip = bip->next)
+      for (int i = 0; i < 255; ++i)
+        if (bip->infos[i].size == 0) {
+          bip->infos[i].start = start;
+          bip->infos[i].size = size;
+          return bip->infos + i;
+        }
+    block_info_page *new_bip = (block_info_page *)_syscall_get_new_pages(1);
+    new_bip->infos[0].start = start;
+    new_bip->infos[0].size = size;
+    for (int i = 1; i < 255; ++i)
+      new_bip->infos[i].size = 0;
+    new_bip->next = first_bi_page;
+    first_bi_page = new_bip;
+    return new_bip->infos;
+  }
+
+  static block_info *find_minimal_block(uint64_t minimum_length) {
+    block_info *minimal_so_far = 0;
+    uint64_t length_so_far = UINT64_MAX;
+    for (block_info_page *bip = first_bi_page; bip; bip = bip->next)
+      for (int i = 0; i < 255; ++i)
+        if (bip->infos[i].size == minimum_length)
+          return bip->infos + i;
+        else if (
+          bip->infos[i].size > minimum_length &&
+          bip->infos[i].size < length_so_far
+        ) {
+          minimal_so_far = bip->infos + i;
+          length_so_far = bip->infos[i].size;
+        }
+    if (minimal_so_far != 0)
+      return minimal_so_far;
+    uint64_t pages_needed = (minimum_length - 1) / 4096 + 1;
+    void *block_start = _syscall_get_new_pages(pages_needed);
+    return add_block((uint64_t)block_start, pages_needed * 4096);
+  }
+
+  static void deallocate_aligned(uint64_t start, uint64_t length) {
+    block_info *buddy = try_find_block(start ^ length, length);
+    if (buddy) {
+      buddy->size = 0;
+      deallocate_aligned(start & ~length, length * 2);
+      return;
+    }
+    add_block(start, length);
+  }
+
+  static void deallocate(void *start, uint64_t length) {
+    uint64_t at = (uint64_t)start;
+    uint64_t left = length;
+    uint64_t i;
+    for (i = 1; i <= left; i *= 2)
+      if (at & i) {
+        deallocate_aligned(at, i);
+        at += i;
+        left -= i;
+      }
+    for (i /= 2; left > 0; i /= 2)
+      if (i <= left) {
+        deallocate_aligned(at, i);
+        at += i;
+        left -= i;
+      }
+  }
+
+  [[nodiscard]] static void *allocate(uint64_t length) {
+    block_info *bi = find_minimal_block(length);
+    void *to_return = (void *)bi->start;
+    void *new_start = (void *)(bi->start + length);
+    uint64_t new_length = bi->size - length;
+    bi->size = 0;
+    deallocate(new_start, new_length);
+    return to_return;
+  }
+
+  static void deallocate_with_length(void *start) {
+    uint64_t real_start = (uint64_t)start - 8;
+    deallocate((void *)real_start, *(uint64_t *)real_start);
+  }
+
+  [[nodiscard]] static void *allocate_with_length(uint64_t length) {
+    uint64_t *real_start = (uint64_t *)allocate(length + 8);
+    *real_start = length + 8;
+    return real_start + 1;
+  }
+
+}
+
+using namespace euler::allocator;
+
+void operator delete[](void *start) {
+  deallocate_with_length(start);
+}
+
+void operator delete(void *start) {
+  deallocate_with_length(start);
+}
+
+void operator delete[](void *start, uint64_t) {
+  deallocate_with_length(start);
+}
+
+void operator delete(void *start, uint64_t) {
+  deallocate_with_length(start);
+}
+
+void *operator new[](uint64_t size) {
+  return allocate_with_length(size);
+}
+
+void *operator new(uint64_t size) {
+  return allocate_with_length(size);
+}

libraries/euler/cassert.cpp

@@ -0,0 +1,16 @@
+#include <cassert>
+
+namespace euler {
+
+  [[noreturn]] void assert_failed(
+    const char *, const char *, int, const char *
+  ) {
+    //TODO: print error and abort
+    //we could just exit right now but i want to keep us in
+    //the application so we can get a stack trace in gdb.
+    while (1)
+      ;
+  }
+
+
+}

libraries/euler/cctype.cpp

@@ -0,0 +1,11 @@
+#include <cctype>
+
+namespace std {
+
+  int isspace(int ch) {
+    return
+      ch == ' ' || ch == '\n' || ch == '\t' ||
+      ch == '\r' || ch == '\v' || ch == '\f';
+  }
+
+}

libraries/euler/cstdio.cpp

@@ -0,0 +1,102 @@
+#include <euler/syscall.hpp>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+
+namespace euler {
+
+  //read-only with no error bits for now
+  struct file_t {
+
+    syscall::file_handle handle;
+
+    //TODO: variable size buffer? maybe a multiple of block size for device?
+    char buffer[1024];
+    //in bytes, aligned to buffer size; 1 for no buffer loaded
+    uint64_t buffer_start;
+
+    bool is_offset_in_buffer() {
+      return
+        buffer_start != 1 && offset >= buffer_start &&
+        offset < buffer_start + 1024;
+    }
+
+    syscall::file_result ensure_offset_in_buffer() {
+      if (is_offset_in_buffer())
+        return syscall::file_result::success;
+      uint64_t new_buffer_start = (offset / 1024) * 1024;
+      uint64_t new_buffer_end = new_buffer_start + 1024;
+      if (length < new_buffer_end)
+        new_buffer_end = length;
+      syscall::file_result result = _syscall_read_from_file(
+        handle, new_buffer_start, new_buffer_end - new_buffer_start, buffer);
+      if (result == syscall::file_result::success)
+        buffer_start = new_buffer_start;
+      return result;
+    }
+
+    uint64_t offset;
+    uint64_t length;
+
+  };
+
+}
+
+namespace std {
+
+  FILE *fopen(const char *path, const char *mode) {
+
+    assert(mode[0] == 'r' && mode[1] == '\0');
+
+    euler::syscall::file_handle handle;
+    euler::syscall::file_result result =
+      _syscall_open_file(path, strlen(path), handle);
+    if (result != euler::syscall::file_result::success)
+      return 0;
+
+    uint64_t length;
+    result = _syscall_get_file_length(handle, length);
+    if (result != euler::syscall::file_result::success) {
+      _syscall_close_file(handle);
+      return 0;
+    }
+
+    return new FILE {
+      .handle = handle,
+      .buffer = {},
+      .buffer_start = 1,
+      .offset = 0,
+      .length = length
+    };
+
+  }
+
+  int fclose(FILE *file) {
+    _syscall_close_file(file->handle);
+    delete file;
+    return 0;
+  }
+
+  int fgetc(FILE *from) {
+    if (from->offset >= from->length)
+      return EOF;
+    assert(
+      from->ensure_offset_in_buffer() == euler::syscall::file_result::success);
+    char ch = from->buffer[from->offset - from->buffer_start];
+    ++from->offset;
+    return ch;
+  }
+
+  int ungetc(int ch, FILE *from) {
+    if (ch == EOF || from->offset == 0)
+      return EOF;
+    --from->offset;
+    if (!from->is_offset_in_buffer()) {
+      ++from->offset;
+      return EOF;
+    }
+    from->buffer[from->offset - from->buffer_start] = ch;
+    return ch;
+  }
+
+}

libraries/euler/entry.cpp

@@ -1,14 +1,19 @@
+#include <euler/syscall.hpp>
+
 int main(int argc, char **argv);
 
 extern "C" [[noreturn]] void _entry() {
+
+  //TODO: static constructors
+
   //TODO: get command line via system call and populate argc and argv.
   int argc = 0;
   char **argv = 0;
 
   int result = main(argc, argv);
 
-  //TODO: exit via system call and return result.
+  //TODO: static destructors
-  (void)result;
+
-  while (1)
+  _syscall_end_this_process(result);
-    ;
+
 }

libraries/euler/include/cassert

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace euler {
+  [[noreturn]] void assert_failed(
+    const char *file, const char *function, int line, const char *condition);
+}
+
+#ifdef NDEBUG
+#define assert(condition) ((void)0)
+#else
+#define assert(condition) ((condition) ? ((void)0) : \
+  euler::assert_failed(__FILE__, __func__, __LINE__, #condition))
+#endif

libraries/euler/include/cctype

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace std {
+
+  int isspace(int ch);
+
+}

libraries/euler/include/cstddef

@@ -0,0 +1 @@
+../../../mintsuki-freestanding-headers/stddef.h

libraries/euler/include/cstdint

@@ -0,0 +1 @@
+../../../mintsuki-freestanding-headers/stdint.h

libraries/euler/include/cstdio

@@ -0,0 +1,19 @@
+#pragma once
+
+#define EOF (-1)
+
+namespace euler {
+  struct file_t;
+}
+
+namespace std {
+
+  typedef euler::file_t FILE;
+
+  FILE *fopen(const char *path, const char *mode);
+  int fclose(FILE *file);
+
+  int fgetc(FILE *from);
+  int ungetc(int ch, FILE *from);
+
+}

libraries/euler/include/cstring

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstddef>
+
+namespace std {
+
+  static inline size_t strlen(const char *str) {
+    size_t i = 0;
+    while (str[i])
+      ++i;
+    return i;
+  }
+
+}

libraries/euler/include/euler/syscall.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <cstdint>
+
+namespace euler::syscall {
+
+  typedef uint32_t encoded_color;
+  typedef int32_t exit_code;
+  typedef uint64_t file_handle;
+
+  enum [[nodiscard]] file_result : uint64_t {
+    success,
+    bad_file_handle,
+    device_error,
+    file_system_corrupt,
+    out_of_bounds,
+    does_not_exist,
+    directory
+  };
+
+}
+
+extern "C" {
+
+  euler::syscall::encoded_color _syscall_encode_color(
+    uint8_t red, uint8_t green, uint8_t blue);
+
+  void _syscall_get_framebuffer(
+    euler::syscall::encoded_color *&ptr_out, uint32_t &width_out,
+    uint32_t &height_out, uint32_t &pitch_out);
+
+  euler::syscall::file_result _syscall_open_file(
+    const char *path, uint64_t path_length, euler::syscall::file_handle &out);
+
+  euler::syscall::file_result _syscall_get_file_length(
+    euler::syscall::file_handle file, uint64_t &out);
+
+  euler::syscall::file_result _syscall_read_from_file(
+    euler::syscall::file_handle file,
+    uint64_t start_offset, uint64_t length, void *into);
+
+  [[noreturn]] void _syscall_end_this_process(euler::syscall::exit_code code);
+
+  [[nodiscard]] void *_syscall_get_new_pages(uint64_t count);
+
+  void _syscall_close_file(euler::syscall::file_handle file);
+
+}

libraries/euler/syscall.asm

@@ -0,0 +1,82 @@
+bits 64
+
+section .text
+
+global _syscall_encode_color
+_syscall_encode_color:
+  xor rax, rax
+  and edi, 0xff
+  and dx, 0xff
+  shl si, 8
+  shl edx, 16
+  or di, si
+  or edi, edx
+  syscall
+  ret
+
+global _syscall_get_framebuffer
+_syscall_get_framebuffer:
+  push rcx
+  push rdx
+  push rsi
+  push rdi
+  mov rax, 1
+  syscall
+  pop rcx
+  mov qword [rcx], rax
+  pop rcx
+  mov dword [rcx], edi
+  pop rcx
+  shr rdi, 32
+  mov dword [rcx], edi
+  pop rcx
+  mov dword [rcx], esi
+  ret
+
+global _syscall_open_file
+_syscall_open_file:
+  mov rax, 2
+  push rdx
+  syscall
+  pop rdx
+  mov qword [rdx], rdi
+  ret
+
+global _syscall_get_file_length
+_syscall_get_file_length:
+  mov rax, 3
+  push rsi
+  syscall
+  pop rsi
+  mov qword [rsi], rdi
+  ret
+
+global _syscall_read_from_file
+_syscall_read_from_file:
+  mov rax, 4
+  push rcx
+  push rdx
+  push rsi
+  push rdi
+  mov rdi, rsp
+  syscall
+  add rsp, 32
+  ret
+
+global _syscall_end_this_process
+_syscall_end_this_process:
+  mov rax, 5
+  syscall
+  ;does not return
+
+global _syscall_get_new_pages
+_syscall_get_new_pages:
+  mov rax, 6
+  syscall
+  ret
+
+global _syscall_close_file
+_syscall_close_file:
+  mov rax, 7
+  syscall
+  ret

makefile

@@ -1,7 +1,8 @@
-GPP_ARGS = -Wall -Wextra -O3 -ggdb -I include \
+GPP_ARGS = -std=c++17 -Wall -Wextra -O3 -ggdb -nostdinc \
-  -ffreestanding -fno-exceptions -fno-rtti -mno-sse
+  -fno-exceptions -ffreestanding -fno-rtti -mno-sse
-KGPP_ARGS = ${GPP_ARGS}
+KGPP_ARGS = ${GPP_ARGS} -I kernel/include -I mintsuki-freestanding-headers
-AGPP_ARGS = ${GPP_ARGS}
+AGPP_ARGS = ${GPP_ARGS} -I libraries/euler/include \
+  -I libraries/daguerre/include
 
 LD_ARGS = -z noexecstack
 KLD_ARGS = -T kernel/link.ld ${LD_ARGS}
@@ -17,21 +18,24 @@ clean:
 	rm -rf obj out
 
 dist-clean:
-	rm -rf limine
+	rm -rf limine mintsuki-freestanding-headers
-	rm -f include/hilbert/kernel/limine.hpp
 
 limine:
 	git clone --depth=1 -b v6.x-branch \
 	  https://github.com/limine-bootloader/limine.git limine
 	cd limine && ./bootstrap && ./configure -q --enable-bios --enable-bios-cd
 	+make -C limine
-	cp limine/limine.h include/hilbert/kernel/limine.hpp
 
-obj/kernel/entry.cpp.o: kernel/entry.cpp limine
+mintsuki-freestanding-headers:
+	git clone --depth=1 \
+	  https://github.com/mintsuki/freestanding-headers.git \
+	  mintsuki-freestanding-headers
+
+obj/kernel/entry.cpp.o: kernel/entry.cpp limine mintsuki-freestanding-headers
 	@mkdir -p $(@D)
 	g++ -c ${KGPP_ARGS} $< -o $@
 
-obj/kernel/%.cpp.o: kernel/%.cpp
+obj/kernel/%.cpp.o: kernel/%.cpp mintsuki-freestanding-headers
 	@mkdir -p $(@D)
 	g++ -c ${KGPP_ARGS} $< -o $@
 
@@ -46,29 +50,36 @@ KERNEL_OBJECTS = allocator.cpp application.cpp entry.cpp framebuffer.cpp \
 obj/kernel.elf: ${KERNEL_OBJECTS:%=obj/kernel/%.o}
 	ld ${KLD_ARGS} $^ -o $@
 
-obj/stdlib/%.asm.o: stdlib/%.asm
+obj/%.cpp.o: %.cpp mintsuki-freestanding-headers
+	@mkdir -p $(@D)
+	g++ -c ${AGPP_ARGS} $< -o $@
+
+obj/%.asm.o: %.asm
 	@mkdir -p $(@D)
 	nasm -f elf64 $< -o $@
 
-obj/stdlib/%.cpp.o: stdlib/%.cpp
+EULER_OBJECTS = entry.cpp syscall.asm cassert.cpp allocator.cpp cstdio.cpp \
-	@mkdir -p $(@D)
+  cctype.cpp
-	g++ -c ${AGPP_ARGS} $< -o $@
+obj/euler.o: ${EULER_OBJECTS:%=obj/libraries/euler/%.o}
-
-STDLIB_OBJECTS = entry.cpp syscall.asm
-obj/stdlib.o: ${STDLIB_OBJECTS:%=obj/stdlib/%.o}
 	ld -r ${LLD_ARGS} $^ -o $@
 
-obj/%.cpp.o: applications/%.cpp
+DAGUERRE_OBJECTS = ppm.cpp
-	@mkdir -p $(@D)
+obj/daguerre.o: ${DAGUERRE_OBJECTS:%=obj/libraries/daguerre/%.o}
-	g++ -c ${AGPP_ARGS} $< -o $@
+	ld -r ${LLD_ARGS} $^ -o $@
 
 INIT_OBJECTS = main.cpp
-obj/initfs/bin/init.elf: ${INIT_OBJECTS:%=obj/init/%.o} obj/stdlib.o
+obj/initfs/bin/init.elf: ${INIT_OBJECTS:%=obj/applications/init/%.o} \
+  obj/euler.o obj/daguerre.o
 	@mkdir -p $(@D)
 	ld ${ALD_ARGS} $^ -o $@
 
+obj/initfs/.skeleton:
+	@mkdir -p obj/initfs
+	cp -r skeleton/* obj/initfs/
+	@touch obj/initfs/.skeleton
+
 APPLICATIONS = init
-obj/initfs.tgz: ${APPLICATIONS:%=obj/initfs/bin/%.elf}
+obj/initfs.tgz: ${APPLICATIONS:%=obj/initfs/bin/%.elf} obj/initfs/.skeleton
 	tar czf obj/initfs.tgz -C obj/initfs .
 
 out/disk.iso: obj/kernel.elf obj/initfs.tgz limine

readme.txt

@@ -7,7 +7,42 @@ then, just run "make -jx", replacing x with the number of threads to use
 while building. this will create a bios-bootable disk image in out/disk.iso.
 you can then test it in qemu with gdb attached by running "make run".
 
-hilbert uses the limine bootloader, which is downloaded during the make process
+acknowledgements (* = downloaded during make):
-into the limine directory. once that happens, you can find its license in
+
-limine/COPYING. hilbert also uses the terminus font, which is in the terminus
+  - limine bootloader*
-directory. you can find its license in terminus/license.txt
+    homepage: https://limine-bootloader.org/
+    license: limine/COPYING (bsd two-clause)
+
+  - terminus font
+    homepage: https://terminus-font.sourceforge.net/
+    license: terminus/license.txt (sil open font license v1.1)
+
+  - photo at skeleton/assets/burdon.ppm
+    photographer: aaron burdon
+    source: https://unsplash.com/photos/selective-focus-photography-snowflakes-9yhy1FXlKwI
+    license: https://unsplash.com/license
+
+  - mintsuki's freestanding c headers*
+    homepage: https://github.com/mintsuki/freestanding-headers
+    license: mintsuki-freestanding-headers/LICENSE (bsd zero-clause)
+
+project structure:
+
+  - applications/init: the first application started by the kernel
+  - applications/link.ld: a common linker script used by every application
+  - documentation: documentation on the kernel (not very organized)
+  - kernel: the kernel of hilbert os
+  - libraries/daguerre: an image loading / rendering library
+  - libraries/euler: the c++ standard library and runtime for applications
+  - limine: the limine bootloader (see acknowledgements)
+  - mintsuki-freestanding-headers:
+      mintsuki's freestanding headers (see acknowledgements)
+  - obj: built object files
+  - out: completed builds
+  - skeleton: files that are directly copied to the initfs
+  - terminus: the terminus font (see acknowledgements)
+  - license.txt: the license that hilbert os is under
+  - limine.cfg: the limine configuration used by the built disk
+  - makefile: the makefile that is used to build the entire os
+  - qmeu.gdb: a file for gdb to include when doing make run
+  - readme.txt: this file

skeleton/assets/readme.txt

@@ -0,0 +1,3 @@
+the photo in burdon.ppm is by aaron burdon, and can be found online at
+https://unsplash.com/photos/selective-focus-photography-snowflakes-9yhy1FXlKwI.
+its license can be found at https://unsplash.com/license.

stdlib/syscall.asm

@@ -1,30 +0,0 @@
-bits 64
-
-global encode_color
-global get_framebuffer
-global draw_framebuffer
-
-section .text
-
-encode_color:
-  mov rax, 0
-  syscall
-  ret
-
-get_framebuffer:
-  push rcx
-  push rdx
-  push rsi
-  push rdi
-  mov rax, 1
-  syscall
-  pop rcx
-  mov qword [rcx], rax
-  pop rcx
-  mov dword [rcx], edi
-  shr rdi, 32
-  pop rcx
-  mov dword [rcx], edi
-  pop rcx
-  mov dword [rcx], esi
-  ret