benji/hilbert-os
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update

Browse source
This commit is contained in:
Benji Dial 2024-01-20 17:59:40 -05:00
parent 53135e2592
commit 7199e74aa2
44 changed files with 4914 additions and 406 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitignore vendored
View file

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

48
applications/init/main.cpp
View file

@ -1,29 +1,35 @@
#include <hilbert/syscall.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;
#include <daguerre/image.hpp>
int main(int, char **) {
hilbert::syscall::get_framebuffer(fb, fb_width, fb_height, fb_pitch);
for (uint32_t y = 0; y < fb_height; ++y)
for (uint32_t x = 0; x < fb_width; ++x) {
color c = {
.r = 0,
.g = (uint8_t)(y * 255 / fb_height),
.b = (uint8_t)(x * 255 / fb_width)
};
fb[y * fb_pitch + x] = hilbert::syscall::encode_color(c);
auto fb = daguerre::get_hilbert_framebuffer();
auto white = daguerre::to_hilbert_color({.r = 255, .g = 255, .b = 255});
auto gray = daguerre::to_hilbert_color({.r = 127, .g = 127, .b = 127});
for (unsigned y = 0; y < fb.get_height(); ++y)
for (unsigned x = 0; x < fb.get_width(); ++x) {
uint8_t v = (y / 16) % 2 == (x / 16) % 2;
fb.get(x, y) = v ? white : gray;
}
//*(int *)0x12345678 = 0;
//fb_width = *(uint32_t *)0xffffffffc0000000;
//return 100 / (uint8_t)(uint64_t)fb;
daguerre::image<daguerre::color24> img;
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;
}

46
documentation/syscalls.txt
View file

@ -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

27
include/hilbert/kernel/framebuffer.hpp
View file

@ -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

32
include/hilbert/kernel/storage/fs/tarfs.hpp
View file

@ -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

13
include/hilbert/kernel/syscall.hpp
View file

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

24
include/hilbert/syscall.hpp
View file

@ -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

2
kernel/allocator.cpp
View file

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

16
kernel/application.cpp
View file

@ -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;
}

29
kernel/entry.cpp
View file

@ -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);
storage::fs::tarfs_instance initfs_fs(&initfs_bd);
initfs_bd.mounted_as = &initfs_fs;
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 vfs_root;
vfs_root.bd = &initfs_bd;
vfs_root.dir_entry.type = storage::file_type::directory;
vfs_root.path.absolute = true;
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(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;
if (vfile::lookup_path(vfs_root, init_path, init_file) !=
storage::fs_result::success)
vfile::vfile init_file;
if (vfile::lookup_path(init_path, init_file) != 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.");

38
kernel/framebuffer.cpp
View file

@ -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;
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;
}
int dword_pitch;
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) {

23
include/hilbert/kernel/application.hpp → kernel/include/hilbert/kernel/application.hpp
View file

@ -1,13 +1,14 @@
#ifndef HILBERT_KERNEL_APPLICATION_HPP
#define HILBERT_KERNEL_APPLICATION_HPP
#pragma once
#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

31
kernel/include/hilbert/kernel/framebuffer.hpp Normal file
View file

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

7
include/hilbert/kernel/paging.hpp → kernel/include/hilbert/kernel/paging.hpp
View file

@ -1,7 +1,6 @@
#ifndef HILBERT_KERNEL_PAGING_HPP
#define HILBERT_KERNEL_PAGING_HPP
#pragma once
#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

22
include/hilbert/kernel/storage.hpp → kernel/include/hilbert/kernel/storage.hpp
View file

@ -1,8 +1,7 @@
#ifndef HILBERT_KERNEL_STORAGE_HPP
#define HILBERT_KERNEL_STORAGE_HPP
#pragma once
#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

8
include/hilbert/kernel/storage/bd/memory.hpp → kernel/include/hilbert/kernel/storage/bd/memory.hpp
View file

@ -1,5 +1,4 @@
#ifndef HILBERT_KERNEL_STORAGE_BD_MEMORY_HPP
#define HILBERT_KERNEL_STORAGE_BD_MEMORY_HPP
#pragma once
#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

33
kernel/include/hilbert/kernel/storage/fs/tarfs.hpp Normal file
View file

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

9
include/hilbert/kernel/terminal.hpp → kernel/include/hilbert/kernel/terminal.hpp
View file

@ -1,10 +1,9 @@
#ifndef HILBERT_KERNEL_TERMINAL_HPP
#define HILBERT_KERNEL_TERMINAL_HPP
#pragma once
#include <hilbert/kernel/framebuffer.hpp>
#include <hilbert/kernel/utility.hpp>
#include <cstddef>
#include <cstdint>
#include <stddef.h>
#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

103
include/hilbert/kernel/utility.hpp → kernel/include/hilbert/kernel/utility.hpp
View file

@ -1,20 +1,44 @@
#ifndef HILBERT_KERNEL_UTILITY_HPP
#define HILBERT_KERNEL_UTILITY_HPP
#pragma once
#include <optional>
#include <cstdint>
#include <stddef.h>
#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;
}
};
}

18
include/hilbert/kernel/vfile.hpp → kernel/include/hilbert/kernel/vfile.hpp
View file

@ -1,5 +1,4 @@
#ifndef HILBERT_KERNEL_VFILE_HPP
#define HILBERT_KERNEL_VFILE_HPP
#pragma once
#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(
const vfile &root, std::optional<vfile> &out) const;
storage::fs_result follow_symlinks(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 vfile &root, const canon_path &path, std::optional<vfile> &out);
storage::fs_result lookup_path(const canon_path &path, vfile &out);
}
#endif

102
kernel/storage/fs/tarfs.cpp
View file

@ -5,27 +5,25 @@
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 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; \
}
#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, std::optional<node_id_t> &out
) {
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))
@ -37,8 +35,7 @@ namespace hilbert::kernel::storage::fs {
if (sector[i] != 0)
return fs_result::success;
out = {};
return fs_result::success;
return fs_result::does_not_exist;
}
@ -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))
out = std::move(entry);
iter_out = (directory_iter_t)*child;
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, 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;
FS_TO_FS(first_child_starting_at(node, *start, child))
if (!child) {
out = {};
return fs_result::success;
}
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 = std::move(entry);
iter = (directory_iter_t)*child;
FS_TO_FS(get_dir_entry(child, entry))
out = utility::move(entry);
iter = (directory_iter_t)child;
return fs_result::success;
}

250
kernel/syscall.cpp
View file

@ -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() {
for (int i = 0; i < 256; ++i)
handlers[i] = 0;
bool is_range_owned_by_application(uint64_t start, uint64_t end) {
auto *app = application::running_app;
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) {
handlers[rax] = handler;
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 *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 {
rax = 0;
rdi = 0;
rsi = 0;
rdx = 0;
}
else
set_zero(rax, rdi, rsi, rdx);
}

6
kernel/utility.cpp
View file

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

85
kernel/vfile.cpp
View file

@ -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(
const vfile &root, std::optional<vfile> &out
) const {
storage::fs_result vfile::follow_symlinks(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;
RET_NOT_SUC(lookup_path(root, full_path, next))
if (!next) {
out = {};
return storage::fs_result::success;
}
vfile next;
RET_NOT_SUC(lookup_path(full_path, next))
next->path = path;
return next->follow_symlinks(root, out);
next.path = path;
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.dir_entry = std::move(*entry);
out.add_end(std::move(vf));
vf.path.segments.add_end(entry.name);
vf.dir_entry = utility::move(entry);
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(
const vfile &root, const canon_path &path, std::optional<vfile> &out
) {
//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) {
//assume path is absolute.
out = root;
out = *root;
for (unsigned i = 0; i < path.segments.count; ++i) {
std::optional<vfile> result;
RET_NOT_SUC(out->follow_symlinks(root, result))
out = std::move(result);
if (!out)
return storage::fs_result::success;
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 = std::move(result);
if (!out)
return storage::fs_result::success;
RET_NOT_SUC(out.get_child(result, path.segments.buffer[i]))
out = utility::move(result);
}

155
libraries/daguerre/include/daguerre/image.hpp Normal file
View file

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

52
libraries/daguerre/ppm.cpp Normal file
View file

@ -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;
}
}

147
libraries/euler/allocator.cpp Normal file
View file

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

16
libraries/euler/cassert.cpp Normal file
View file

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

11
libraries/euler/cctype.cpp Normal file
View file

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

102
libraries/euler/cstdio.cpp Normal file
View file

@ -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;
}
}

13
stdlib/entry.cpp → libraries/euler/entry.cpp
View file

@ -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.
(void)result;
while (1)
;
//TODO: static destructors
_syscall_end_this_process(result);
}

13
libraries/euler/include/cassert Normal file
View file

@ -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

7
libraries/euler/include/cctype Normal file
View file

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

1
libraries/euler/include/cstddef Symbolic link
View file

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

1
libraries/euler/include/cstdint Symbolic link
View file

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

19
libraries/euler/include/cstdio Normal file
View file

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

14
libraries/euler/include/cstring Normal file
View file

@ -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;
}
}

48
libraries/euler/include/euler/syscall.hpp Normal file
View file

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

82
libraries/euler/syscall.asm Normal file
View file

@ -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

53
makefile
View file

@ -1,7 +1,8 @@
GPP_ARGS = -Wall -Wextra -O3 -ggdb -I include \
-ffreestanding -fno-exceptions -fno-rtti -mno-sse
KGPP_ARGS = ${GPP_ARGS}
AGPP_ARGS = ${GPP_ARGS}
GPP_ARGS = -std=c++17 -Wall -Wextra -O3 -ggdb -nostdinc \
-fno-exceptions -ffreestanding -fno-rtti -mno-sse
KGPP_ARGS = ${GPP_ARGS} -I kernel/include -I mintsuki-freestanding-headers
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 -f include/hilbert/kernel/limine.hpp
rm -rf limine mintsuki-freestanding-headers
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
@mkdir -p $(@D)
g++ -c ${AGPP_ARGS} $< -o $@
STDLIB_OBJECTS = entry.cpp syscall.asm
obj/stdlib.o: ${STDLIB_OBJECTS:%=obj/stdlib/%.o}
EULER_OBJECTS = entry.cpp syscall.asm cassert.cpp allocator.cpp cstdio.cpp \
cctype.cpp
obj/euler.o: ${EULER_OBJECTS:%=obj/libraries/euler/%.o}
ld -r ${LLD_ARGS} $^ -o $@
obj/%.cpp.o: applications/%.cpp
@mkdir -p $(@D)
g++ -c ${AGPP_ARGS} $< -o $@
DAGUERRE_OBJECTS = ppm.cpp
obj/daguerre.o: ${DAGUERRE_OBJECTS:%=obj/libraries/daguerre/%.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

43
readme.txt
View file

@ -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
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
directory. you can find its license in terminus/license.txt
acknowledgements (* = downloaded during make):
- limine bootloader*
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

3536
skeleton/assets/burdon.ppm Normal file
View file

File diff suppressed because one or more lines are too long

3
skeleton/assets/readme.txt Normal file
View file

@ -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.

30
stdlib/syscall.asm
View file

@ -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