initial commit. working on tasking

58 files changed, 3025 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..71d7146
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+*.elf
+*.o
+*.d
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..c53a551
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,41 @@
+include $(CONFIG)
+include config.mk
+
+CDIRS := boot lib hal sys
+CDIRS += boot/$(TARGET_BOOTLOADER)
+
+CFILES := $(wildcard *.c)
+CFILES += $(wildcard arch/$(TARGET_MACHINE)/*.c)
+CFILES += $(foreach dir, $(CDIRS), $(wildcard $(dir)/*.c))
+CFILES += $(foreach dir, $(CDIRS), $(wildcard arch/$(TARGET_MACHINE)/$(dir)/*.c))
+
+SFILES := $(wildcard *.s)
+SFILES += $(wildcard arch/$(TARGET_MACHINE)/*.s)
+SFILES += $(foreach dir, $(CDIRS), $(wildcard $(dir)/*.s))
+SFILES += $(foreach dir, $(CDIRS), $(wildcard arch/$(TARGET_MACHINE)/$(dir)/*.s))
+
+OBJFILES := $(patsubst %.c,%.o,$(CFILES))
+OBJFILES += $(patsubst %.s,%.o,$(SFILES))
+
+DEPFILES := $(patsubst %.c,%.d,$(CFILES))
+
+BIN := jove.elf
+
+all: $(BIN)
+
+.PHONY: clean
+clean:
+	-rm $(OBJFILES)
+	-rm $(DEPFILES)
+	-rm $(BIN)
+
+$(BIN): ${OBJFILES}
+	$(LD) $(LDFLAGS) ${OBJFILES} -o $(BIN)
+
+-include ${DEPFILES}
+
+%.o:%.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+%.o:%.S
+	$(AS) -g -c $< -o $@
diff --git a/arch/x86_64/boot/limine/framebuffer.c b/arch/x86_64/boot/limine/framebuffer.c
new file mode 100644
index 0000000..aa93496
--- /dev/null
+++ b/arch/x86_64/boot/limine/framebuffer.c
@@ -0,0 +1,48 @@
+#include "arch/x86_64/hal/paging.h"
+#include "jove.h"
+#include "config.h"
+#include "hal/framebuffer.h"
+#include "lib/printf.h"
+
+/*We don't know the size of the framebuffer until runtime, but at the same
+ * time we don't want to dynamically allocate from physical memory. In this
+ * case we allocate memory for the maximum supported framebuffer at compile
+ * time and only use what we need at runtime.*/
+#define FRAMEBUFFER_MAX_BYTES (FRAMEBUFFER_MAX_WIDTH * FRAMEBUFFER_MAX_WIDTH * 4)
+#define FRAMEBUFFER_MAX_PAGES ((FRAMEBUFFER_MAX_BYTES + 4095) / 0x1000)
+#define FRAMEBUFFER_MAX_HUGEPAGES ((FRAMEBUFFER_MAX_PAGES + 511) / 512)
+#define FRAMEBUFFER_MAX_GIANTPAGES ((FRAMEBUFFER_MAX_HUGEPAGES + 511) / 512)
+
+PAGEALIGN static page_t fb_pml2[FRAMEBUFFER_MAX_GIANTPAGES][512];
+
+extern page_t _kernel_pml3[512];
+
+void*
+fb_remap(uintptr_t fb_address,
+         size_t fb_bytes)
+{
+    fb_address &= ~IDENT_VIRT_BASE;
+    size_t fb_pages = (fb_bytes + 4095) >> 12;
+    size_t fb_hugepages = (fb_pages + 511) >> 9;
+    size_t fb_giantpages = (fb_hugepages + 511) >> 9;
+
+    if(fb_pages > FRAMEBUFFER_MAX_PAGES) {
+        kprintf("Framebuffer is too big! Please recompile the kernel with a bigger framebuffer allowance!");
+        return NULL;
+    }
+
+    for(size_t pml2 = 0; pml2 < fb_giantpages; pml2++) {
+        uintptr_t fb_pml2_pptr = KPTR_TOPHYS((uintptr_t)fb_pml2[pml2]);
+        _kernel_pml3[pml2].value = fb_pml2_pptr | PAGE_PRESENT | PAGE_GLOBAL | PAGE_WRITEABLE;
+    }
+
+    for(size_t pml1 = 0; pml1 < fb_hugepages; pml1++) {
+        size_t pml2 = pml1 >> 9;
+        size_t pml1_mod = pml1 % 512;
+        uintptr_t fb_off = fb_address + (pml1 << 21);
+        fb_pml2[pml2][pml1_mod].value = fb_off | PAGE_PRESENT | PAGE_GLOBAL | PAGE_WRITEABLE | PAGE_PS;
+    }
+
+    uintptr_t fb_virt = IDENT_VIRT_BASE | (511ULL << PMLI_SHL(3));
+    return (void*)fb_virt;
+}
diff --git a/arch/x86_64/hal/gdt.c b/arch/x86_64/hal/gdt.c
new file mode 100644
index 0000000..a64bdc1
--- /dev/null
+++ b/arch/x86_64/hal/gdt.c
@@ -0,0 +1,81 @@
+#include "gdt.h"
+#include "smp.h"
+#include "lib/string.h"
+
+static struct gdt_entry _gdt[GDT_TSS_HI+1] = 
+{
+    [GDT_KERNEL_NULL] = { 0 },
+    [GDT_KERNEL_CODE] = (struct gdt_entry) {
+        .limit_0_15 = 0xFFFF,
+        .base_0_15 = 0x0,
+        .base_16_23 = 0x0,
+        .type_flg = 0b10011010,
+        .limit_flg = 0b10101111,
+        .base_24_31 = 0x0
+    },
+    [GDT_KERNEL_DATA] = (struct gdt_entry) {
+        .limit_0_15 = 0xFFFF,
+        .base_0_15 = 0x0,
+        .base_16_23 = 0x0,
+        .type_flg = 0b10010010,
+        .limit_flg = 0b10101111,
+        .base_24_31 = 0x0
+    },
+    [GDT_USER_NULL] = { 0 },
+    [GDT_USER_DATA] = (struct gdt_entry) {
+        .limit_0_15 = 0xFFFF,
+        .base_0_15 = 0x0,
+        .base_16_23 = 0x0,
+        .type_flg = 0b11110010,
+        .limit_flg = 0b10101111,
+        .base_24_31 = 0x0
+    },
+    [GDT_USER_CODE] = (struct gdt_entry) {
+        .limit_0_15 = 0xFFFF,
+        .base_0_15 = 0x0,
+        .base_16_23 = 0x0,
+        .type_flg = 0b11111010,
+        .limit_flg = 0b10101111,
+        .base_24_31 = 0x0
+    },
+    [GDT_TSS_LO] = (struct gdt_entry) {
+        .limit_0_15 = 0x0,
+        .base_0_15 = 0x0,
+        .base_16_23 = 0x0,
+        .type_flg = 0x89,
+        .limit_flg = 0x0,
+        .base_24_31 = 0x0       
+    },
+    [GDT_TSS_HI] = { 0 }
+};
+
+void
+gdt_setup(processor_t *processor)
+{
+    memcpy(processor->gdt, _gdt, sizeof(struct gdt_entry) * (GDT_TSS_HI+1));
+
+    struct gdt_descriptor gdtr;
+    gdtr.base = (uintptr_t)&processor->gdt;
+    gdtr.limit = sizeof(struct gdt_entry) * (GDT_TSS_HI+1) - 1;
+
+    extern void load_gdt(struct gdt_descriptor *gdtr);
+    load_gdt(&gdtr);
+
+    uintptr_t tss_base = (uintptr_t)&processor->tss;
+    size_t tss_limit = sizeof(struct tss);
+
+    struct gdt_entry *tss_lo = &processor->gdt[GDT_TSS_LO];
+    struct gdt_entry *tss_hi = &processor->gdt[GDT_TSS_HI];
+
+    tss_lo->base_0_15 = (uint16_t)(tss_base & 0xFFFF);
+    tss_lo->base_16_23 = (uint8_t)((tss_base >> 16) & 0xFF);
+    tss_lo->base_24_31 = (uint8_t)((tss_base >> 24) & 0xFF);
+    tss_hi->limit_0_15 = (uint16_t)((tss_base >> 32) & 0xFFFF);
+    tss_hi->base_0_15 = (uint16_t)((tss_base >> 48) & 0xFFFF);
+
+    tss_lo->limit_0_15 = (uint16_t)(tss_limit & 0xFFFF);
+    tss_lo->limit_flg |= (uint8_t)((tss_limit >> 16) & 0xF);
+
+    extern void load_tss(void);
+    load_tss();
+}
diff --git a/arch/x86_64/hal/gdt.h b/arch/x86_64/hal/gdt.h
new file mode 100644
index 0000000..7fb7dfc
--- /dev/null
+++ b/arch/x86_64/hal/gdt.h
@@ -0,0 +1,48 @@
+#ifndef _JOVE_x86_64_HAL_GDT_H
+#define _JOVE_x86_64_HAL_GDT_H 1
+
+#include <stddef.h>
+#include <stdint.h>
+#include "jove.h"
+
+enum {
+    GDT_KERNEL_NULL = 0,
+    GDT_KERNEL_CODE,
+    GDT_KERNEL_DATA,
+    GDT_USER_NULL,
+    GDT_USER_DATA,
+    GDT_USER_CODE,
+    GDT_TSS_LO,
+    GDT_TSS_HI
+};
+
+#define GDT_OFFSET(i) (i << 3)
+
+struct gdt_entry
+{
+    uint16_t limit_0_15;
+    uint16_t base_0_15;
+    uint8_t base_16_23;
+    uint8_t type_flg;
+    uint8_t limit_flg;
+    uint8_t base_24_31;
+};
+
+struct tss
+{
+    uint32_t rsv0;
+    uint64_t rsp[3];
+    uint64_t rsv1;
+    uint64_t ist[7];
+    uint64_t rsv2;
+    uint16_t rsv3;
+    uint16_t iopb;
+} PACKED;
+
+struct gdt_descriptor
+{
+    uint16_t limit;
+    uint64_t base;
+} PACKED;
+
+#endif
diff --git a/arch/x86_64/hal/idt.c b/arch/x86_64/hal/idt.c
new file mode 100644
index 0000000..b2251bd
--- /dev/null
+++ b/arch/x86_64/hal/idt.c
@@ -0,0 +1,53 @@
+#include "idt.h"
+#include "smp.h"
+#include "gdt.h"
+#include "jove.h"
+#include "lib/printf.h"
+
+ALIGN(8)
+static struct idt_entry s_idt[IDT_ENTRIES];
+
+typedef void (*isr_t)(void);
+extern isr_t __isrs[IDT_ENTRIES];
+
+typedef struct int_stackframe *(*int_handler_t)(struct int_stackframe*);
+int_handler_t __int_handles[IDT_ENTRIES];
+
+static struct int_stackframe*
+s_int_handle_stub(struct int_stackframe* frame)
+{
+    kprintf("Unhandled interrupt %i at %p\n", frame->int_num, frame->int_rip);
+    hcf();
+}
+
+void
+idt_init(void)
+{
+    for(size_t i = 0; i < IDT_ENTRIES; i++) {
+        uintptr_t isr = (uintptr_t)(__isrs[i]);
+
+        s_idt[i] = (struct idt_entry) {
+            .offset_0_15 = (uint16_t)(isr & 0xFFFF),
+            .segment_selector = GDT_KERNEL_CODE * 8,
+            .ist = 0,
+            .type = IDT_INTERRUPT_GATE,
+            .dpl = 0,
+            .p = 1,
+            .offset_16_31 = (uint16_t)((isr >> 16) & 0xFFFF),
+            .offset_32_63 = (uint32_t)(isr >> 32)
+        };
+
+        __int_handles[i] = s_int_handle_stub;
+    }
+}
+
+void
+idt_setup(processor_t *processor)
+{
+    struct idt_descriptor idtr = (struct idt_descriptor) {
+        .limit = sizeof(struct idt_entry) * IDT_ENTRIES - 1,
+        .base = (uint64_t)&s_idt
+    };
+
+    __asm__ volatile("lidt %0":: "m"(idtr));
+}
diff --git a/arch/x86_64/hal/idt.h b/arch/x86_64/hal/idt.h
new file mode 100644
index 0000000..961e720
--- /dev/null
+++ b/arch/x86_64/hal/idt.h
@@ -0,0 +1,66 @@
+#ifndef _JOVE_x86_64_HAL_IDT_H
+#define _JOVE_x86_64_HAL_IDT_H 1
+
+#include <stdint.h>
+#include "jove.h"
+#include "../x86_64.h"
+
+struct idt_entry
+{
+    uint16_t offset_0_15;
+    uint16_t segment_selector;
+    union {
+        struct {
+            uint8_t ist : 3;
+            uint8_t zero_1 : 5;
+            uint8_t type : 4;
+            uint8_t zero_2 : 1;
+            uint8_t dpl : 2;
+            uint8_t p : 1;
+        };
+        uint16_t flags;
+    };
+    uint16_t offset_16_31;
+    uint32_t offset_32_63;
+    uint32_t resv;
+};
+
+#define IDT_INTERRUPT_GATE 0xE
+
+struct idt_descriptor
+{
+    uint16_t limit;
+    uint64_t base;
+} PACKED;
+
+struct int_stackframe
+{
+    struct cpu_state state;
+    uint64_t int_num, int_err;
+    uint64_t int_rip, int_cs, int_flags, int_rsp, int_rss;
+};
+
+#define IDT_ENTRIES 48
+
+#define IDT_EXCEPT_DE 0
+#define IDT_EXCEPT_DB 1
+#define IDT_EXCEPT_NMI 2
+#define IDT_EXCEPT_BP 3
+#define IDT_EXCEPT_OF 4
+#define IDT_EXCEPT_BR 5
+#define IDT_EXCEPT_UD 6
+#define IDT_EXCEPT_NM 7
+#define IDT_EXCEPT_DF 8
+#define IDT_EXCEPT_TS 10
+#define IDT_EXCEPT_NP 11
+#define IDT_EXCEPT_SS 12
+#define IDT_EXCEPT_GP 13
+#define IDT_EXCEPT_PF 14
+#define IDT_EXCEPT_MF 16
+#define IDT_EXCEPT_AC 17
+#define IDT_EXCEPT_MC 18
+#define IDT_EXCEPT_XM 19
+#define IDT_EXCEPT_VE 20
+#define IDT_EXCEPT_CP 21
+
+#endif
diff --git a/arch/x86_64/hal/idt_entries.s b/arch/x86_64/hal/idt_entries.s
new file mode 100644
index 0000000..204fa93
--- /dev/null
+++ b/arch/x86_64/hal/idt_entries.s
@@ -0,0 +1,127 @@
+.section .text
+.macro push_state
+    pushq %rax
+    pushq %rbx
+    pushq %rcx
+    pushq %rdx
+    pushq %rsi
+    pushq %rdi
+    pushq %rbp
+    pushq %r8
+    pushq %r9
+    pushq %r10
+    pushq %r11
+    pushq %r12
+    pushq %r13
+    pushq %r14
+    pushq %r15
+.endm
+
+.macro pop_state
+    popq %r15
+    popq %r14
+    popq %r13
+    popq %r12
+    popq %r11
+    popq %r10
+    popq %r9
+    popq %r8
+    popq %rbp
+    popq %rdi
+    popq %rsi
+    popq %rdx
+    popq %rcx
+    popq %rbx
+    popq %rax
+.endm
+
+.macro swapgs_if_necessary
+    cmpq $0x08, 0x8(%rsp)
+    je 1f
+    swapgs
+1:
+.endm
+
+.extern __int_handles
+.type __isr_header @function
+__isr_header:
+    push_state
+    cld
+
+    movq %rsp, %rdi
+
+isr_break:
+    movq 0x78(%rdi), %rax
+    movq __int_handles(,%rax,8), %rbx
+    call %rbx
+
+    pop_state
+    addq $16, %rsp
+    swapgs_if_necessary
+    iretq
+.size __isr_header, . - __isr_header
+
+.macro defn_isr_err num:req
+.type __isr\num @function
+__isr\num:
+    swapgs_if_necessary
+    pushq $\num
+    jmp __isr_header
+.size __isr\num, . - __isr\num
+.endm
+
+.macro defn_isr num:req
+.type __isr\num @function
+__isr\num:
+    swapgs_if_necessary
+    pushq $0
+    pushq $\num
+    jmp __isr_header
+.size __isr\num, . - __isr\num
+.endm
+
+.macro decl_isr num:req
+.quad __isr\num
+.endm
+
+defn_isr 0
+defn_isr 1
+defn_isr 2
+defn_isr 3
+defn_isr 4
+defn_isr 5
+defn_isr 6
+defn_isr 7
+defn_isr_err 8
+defn_isr 9
+defn_isr_err 10
+defn_isr_err 11
+defn_isr_err 12
+defn_isr_err 13
+defn_isr_err 14
+defn_isr 15
+defn_isr 16
+defn_isr_err 17
+defn_isr 18
+defn_isr 19
+defn_isr 20
+defn_isr_err 21
+
+.altmacro
+.set i, 22
+.rept 48-22
+    defn_isr %i
+    .set i, i+1
+.endr
+
+.section .data
+
+.global __isrs
+.type __isrs @object
+__isrs:
+    .set i, 0
+    .rept 48
+        decl_isr %i
+        .set i, i+1
+    .endr
+.size __isrs, . - __isrs
diff --git a/arch/x86_64/hal/lxdt.s b/arch/x86_64/hal/lxdt.s
new file mode 100644
index 0000000..1591599
--- /dev/null
+++ b/arch/x86_64/hal/lxdt.s
@@ -0,0 +1,26 @@
+.global load_gdt
+.type load_gdt @function
+load_gdt:
+    lgdt (%rdi)
+.reload_segments:
+    pushq $0x8
+    leaq .reload_cs(%rip), %rax
+    pushq %rax
+    retfq
+.reload_cs:
+    movw $0x10, %ax
+    movw %ax, %ds
+    movw %ax, %es
+    movw %ax, %fs
+    movw %ax, %gs
+    movw %ax, %ss
+    retq
+.size load_gdt, . - load_gdt
+
+.global load_tss
+.type load_tss @function
+load_tss:
+    movw $0x30, %ax
+    ltr %ax
+    retq
+.size load_tss, . - load_tss
diff --git a/arch/x86_64/hal/msr.c b/arch/x86_64/hal/msr.c
new file mode 100644
index 0000000..f27e303
--- /dev/null
+++ b/arch/x86_64/hal/msr.c
@@ -0,0 +1,52 @@
+#include "msr.h"
+#include "gdt.h"
+
+void 
+msr_read(uint32_t msr, uint32_t *lo, uint32_t *hi)
+{
+    __asm__ volatile("rdmsr": "=a"(*lo), "=d"(*hi): "c"(msr));
+}
+
+void 
+msr_write(uint32_t msr, uint32_t lo, uint32_t hi)
+{
+    __asm__ volatile("wrmsr":: "a"(lo), "c"(msr), "d"(hi));
+}
+
+void
+msr_set_gs_base(uintptr_t gs)
+{
+    union msr_gs_base gs_base = { .gs = gs };
+    msr_write(MSR_GS_BASE, gs_base.v[0], gs_base.v[1]);
+}
+
+uintptr_t
+msr_get_gs_base(void)
+{
+    union msr_gs_base gs_base;
+    msr_read(MSR_GS_BASE, &gs_base.v[0], &gs_base.v[1]);
+    return gs_base.gs;
+}
+
+void
+msr_enable_sce(void)
+{
+    uint32_t efer[2];
+    msr_read(MSR_EFER, &efer[0], &efer[1]);
+
+    efer[0] |= MSR_EFER_SCE;
+    msr_write(MSR_EFER, efer[0], efer[1]);
+
+    union msr_star star;
+    star.kcs = GDT_OFFSET(GDT_KERNEL_CODE);
+    star.ucs = GDT_OFFSET(GDT_USER_CODE);
+    msr_write(MSR_STAR, star.v[0], star.v[1]);
+}
+
+void
+msr_set_lstar(void *lstar_value)
+{
+    union msr_lstar lstar;
+    lstar.rip = lstar_value;
+    msr_write(MSR_LSTAR, lstar.v[0], lstar.v[1]);
+}
diff --git a/arch/x86_64/hal/msr.h b/arch/x86_64/hal/msr.h
new file mode 100644
index 0000000..69d96be
--- /dev/null
+++ b/arch/x86_64/hal/msr.h
@@ -0,0 +1,48 @@
+#ifndef _JOVE_x86_64_HAL_MSR_H
+#define _JOVE_x86_64_HAL_MSR_H 1
+
+#include <stdint.h>
+
+#define MSR_FS_BASE     0xC0000100
+#define MSR_GS_BASE     0xC0000101
+#define MSR_KGS_BASE    0xC0000102
+
+#define MSR_EFER        0xC0000080
+#define MSR_EFER_SCE 0b1
+
+#define MSR_STAR        0xC0000081
+#define MSR_LSTAR       0xC0000082
+#define MSR_SFMASK      0xC0000084
+
+union msr_gs_base
+{
+    uintptr_t gs;
+    uint32_t v[2];
+};
+
+union msr_star
+{
+    struct {
+        uint32_t eip;
+        uint16_t kcs;
+        uint16_t ucs;
+    };
+    uint16_t v[2];
+};
+
+union msr_lstar
+{
+    void *rip;
+    uint32_t v[2];
+};
+
+void msr_set_gs_base(uintptr_t gs_base);
+uintptr_t msr_get_gs_base(void);
+
+void msr_enable_sce(void);
+void msr_set_lstar(void *syscall_entry);
+
+void msr_read(uint32_t msr, uint32_t *lo, uint32_t *hi);
+void msr_write(uint32_t msr, uint32_t lo, uint32_t hi);
+
+#endif
diff --git a/arch/x86_64/hal/obj.c b/arch/x86_64/hal/obj.c
new file mode 100644
index 0000000..783d2f4
--- /dev/null
+++ b/arch/x86_64/hal/obj.c
@@ -0,0 +1,87 @@
+#include "obj.h"
+#include "arch/x86_64/lock.h"
+#include "hal/obj.h"
+#include "jove.h"
+
+jove_owned_obj_t*
+obj_take(jove_obj_t *obj)
+{
+    take_mutex(&obj->lock);
+    return (jove_owned_obj_t*)obj;
+}
+
+jove_obj_t*
+obj_release(jove_owned_obj_t *obj)
+{
+    release_mutex((atomic_flag*)&obj->lock);
+    return (jove_obj_t*)obj;
+}
+
+void*
+obj_deref(jove_owned_obj_t *obj)
+{
+    return (void*)(((uintptr_t)obj_getvalue(obj)) | 0xFFFF800000000000ULL);
+}
+
+uint8_t
+obj_gettype(jove_owned_obj_t *obj)
+{
+    return obj->type;
+}
+
+void
+obj_settype(jove_owned_obj_t *obj, uint8_t type)
+{
+    obj->type = type;
+}
+
+uintmax_t
+obj_getvalue(jove_owned_obj_t *obj)
+{
+    return obj->value;
+}
+
+void
+obj_setvalue(jove_owned_obj_t *obj, uintmax_t value)
+{
+    obj->value = value & 0x00007FFFFFFFFFFFULL;
+}
+
+jove_obj_t*
+objdir_getlocal(
+        jove_owned_obj_t *objdir_obj, 
+        uint16_t entry)
+{
+    if(objdir_obj->type != JOVE_OBJ_OBJDIR) {
+        reterr(EBADOBJ);
+    }
+    if(entry >= JOVE_OBJDIR_ENTRIES) {
+        reterr(EOOB);
+    }
+
+    jove_objdir_t *objtab = obj_deref(objdir_obj);
+    return &objtab->entries[entry];
+}
+
+jove_owned_obj_t*
+objdir_getobj(
+        jove_owned_obj_t *objdir_obj, 
+        const uint16_t *path, 
+        size_t path_len)
+{
+    if(path_len == 0) {
+        return objdir_obj;
+    }
+    {
+        jove_obj_t *child_locked_objdir = objdir_getlocal(objdir_obj, path[0]);
+        if(child_locked_objdir == NULL) {
+            return 0;
+        }
+
+        jove_owned_obj_t *child_objdir = obj_take(child_locked_objdir);
+        jove_owned_obj_t *target_obj = objdir_getobj(child_objdir, path + 1, path_len - 1);
+        obj_release(child_objdir);
+        return target_obj;
+    }
+}
+
diff --git a/arch/x86_64/hal/obj.h b/arch/x86_64/hal/obj.h
new file mode 100644
index 0000000..645727d
--- /dev/null
+++ b/arch/x86_64/hal/obj.h
@@ -0,0 +1,79 @@
+#ifndef _JOVE_ARCH_HAL_OBJ_H
+#define _JOVE_ARCH_HAL_OBJ_H 1
+
+#include <stdatomic.h>
+#include <stdint.h>
+#include <stddef.h>
+
+enum
+{
+    JOVE_OBJ_SERIAL_COM = 0x81,
+    JOVE_OBJ_PAGE_FRAME,
+    JOVE_OBJ_PAGE_MAPPING,
+};
+
+/*Represents a locked kernel object pointer inside of a object directory.*/
+typedef union jove_obj
+{
+    struct {
+        uint8_t type;
+        atomic_flag lock;
+        /*Raw value or pointer to a data-structure located in kernel memory.*/
+        uint64_t value : 48;
+    };
+    uintmax_t data;
+} jove_obj_t;
+
+/*Represents an unlocked kernel object pointer.
+ *This object should only exist temporarily while accessing the underlying
+ *structure this object points to.*/
+typedef union jove_obj_locked
+{
+    struct {
+        uint8_t type;
+        uint8_t lock;
+        uint64_t value : 48;
+    };
+    uintmax_t data;
+} jove_owned_obj_t;
+
+/*Object directories are always 1 page wide. Since an object inside the directory
+ * is a pointer width, on x86_64 that is 512 entries per directory.*/
+#define JOVE_OBJDIR_SIZE 0x1000
+#define JOVE_OBJDIR_ENTRIES (JOVE_OBJDIR_SIZE / sizeof(jove_obj_t))
+
+typedef struct jove_objdir
+{
+    jove_obj_t entries[JOVE_OBJDIR_ENTRIES];
+} jove_objdir_t;
+/*Locks the mutex of the kernel object provided. Returns the locked version. */
+jove_owned_obj_t *obj_take(jove_obj_t *obj);
+/*Unlocks the mutex of the kernel object provided. Returns the unlocked version. */
+jove_obj_t *obj_release(jove_owned_obj_t *obj);
+
+/*Converts the value pointer of the object into a pointer to kernel memory.*/
+void *obj_deref(jove_owned_obj_t *obj);
+
+/*Getters and setters for accessing the type field of the kernel object. */
+uint8_t obj_gettype(jove_owned_obj_t *obj);
+void obj_settype(jove_owned_obj_t *obj, uint8_t type);
+
+/*Getters and setters for accessing the value field of the kernel object. */
+uintmax_t obj_getvalue(jove_owned_obj_t *obj);
+void obj_setvalue(jove_owned_obj_t *obj, uintmax_t value);
+
+/*Returns the n'th entry of the object directory passed.
+ * If the passed object is not an objdir, returns NULL and sets errno to EBADOBJ.
+ * If the passed entry index is out of bounds, returns NULL and sets errno to EOOB.*/
+jove_obj_t *objdir_getlocal(jove_owned_obj_t *objdir_obj, uint16_t entry);
+
+/*Recursively seeks through an object directory for an object following the passed
+ * path variable.
+ * If the path length is zero, returns the passed object.
+ * If the passed object is not an objdir, returns NULL and sets errno to EBADOBJ.
+ * If any object excluding the object at the end of the path is not an objdir,
+ * returns NULL and sets errno to EBADOBJ.
+ * If any entry in the path is out of bounds, returns NULL and sets errno to EBADOBJ.*/
+jove_owned_obj_t *objdir_getobj(jove_owned_obj_t *objdir_obj, const uint16_t *path, size_t path_len);
+
+#endif
diff --git a/arch/x86_64/hal/paging.c b/arch/x86_64/hal/paging.c
new file mode 100644
index 0000000..c1a22a2
--- /dev/null
+++ b/arch/x86_64/hal/paging.c
@@ -0,0 +1,174 @@
+#include "paging.h"
+#include "arch/x86_64/x86_64.h"
+#include "jove.h"
+#include "config.h"
+#include "smp.h"
+#include "lib/string.h"
+#include "lib/printf.h"
+#include "lib/panic.h"
+#include "idt.h"
+
+PAGEALIGN page_t _kernel_pml4[512];
+PAGEALIGN page_t _kernel_pml3[512];
+PAGEALIGN page_t _kernel_pml2[512];
+PAGEALIGN page_t _kernel_pml1[512];
+
+#define IDENT_HUGEPAGES ((PHYS_BIGPAGES_MAX + 511) / 512)
+#define IDENT_GIANTPAGES ((IDENT_HUGEPAGES + 511) / 512)
+
+PAGEALIGN static page_t ident_pml3[IDENT_GIANTPAGES][512];
+PAGEALIGN static page_t ident_pml2[IDENT_HUGEPAGES][512];
+
+void*
+phys_tovirt(uintptr_t phys)
+{
+    return (void*)(phys | IDENT_VIRT_BASE);
+}
+
+uintptr_t
+paging_get_pml4(void)
+{
+    uintptr_t ret = 0;
+    __asm__ volatile("movq %%cr3, %0": "=r"(ret));
+    return ret;
+}
+
+void
+paging_pml4_switch(uintptr_t pml4)
+{
+    __asm__ volatile("movq %0, %%cr3":: "r"(pml4));
+}
+
+static struct int_stackframe*
+s_int_handle_pf_early(struct int_stackframe *frame)
+{
+    extern int _kernel_panic_unlock;
+    _kernel_panic_unlock = 1;
+
+    union {
+        struct {
+            uint8_t p : 1;
+            uint8_t wr : 1;
+            uint8_t us : 1;
+            uint8_t rsvd : 1;
+            uint8_t id : 1;
+            uint8_t pk : 1;
+        };
+        uint64_t value;
+    } pf_error = { .value = frame->int_err };
+    
+    kprintf("Kernel has encountered a page fault exception early in initializaiton\n");
+    kprintf("%s %s during %s\n", 
+            pf_error.wr ? "Wrote to" : "Read from",
+            pf_error.p ? "Present" : "Non-present",
+            pf_error.id ? "Instruction fetch" : "Data access");
+    uintptr_t cr2 = 0;
+    __asm__ volatile("movq %%cr2, %0": "=r"(cr2));
+    kprintf("Faulting address: %p\n", cr2);
+    kprintf("RIP: %p | RSP: %p\n", frame->int_rip, frame->int_rsp);
+    print_state(&frame->state);
+
+    hcf();
+}
+
+void
+paging_pml4_init(void)
+{
+    //Setup kernel pages
+    memset(_kernel_pml4, 0, 0x1000);
+    memset(_kernel_pml3, 0, 0x1000);
+    memset(_kernel_pml2, 0, 0x1000);
+    memset(_kernel_pml1, 0, 0x1000);
+
+    /*Paging entries depend on physical addresses to properly map.
+     * Since the virtual kernel address differs from the physical memory address,
+     * we need to convert the pointers using the physical memory pointer passed
+     * to us by the bootloader.*/
+    uintptr_t kernel_pml4_pptr = KPTR_TOPHYS((uintptr_t)_kernel_pml4);
+    uintptr_t kernel_pml3_pptr = KPTR_TOPHYS((uintptr_t)_kernel_pml3);
+    uintptr_t kernel_pml2_pptr = KPTR_TOPHYS((uintptr_t)_kernel_pml2);
+    uintptr_t kernel_pml1_pptr = KPTR_TOPHYS((uintptr_t)_kernel_pml1);
+
+    /*Maps pml4-2 as global writeable pages.*/
+    _kernel_pml4[511].value = kernel_pml3_pptr | PAGE_PRESENT | PAGE_WRITEABLE | PAGE_GLOBAL;
+    _kernel_pml3[510].value = kernel_pml2_pptr | PAGE_PRESENT | PAGE_WRITEABLE | PAGE_GLOBAL;
+    _kernel_pml2[0].value =   kernel_pml1_pptr | PAGE_PRESENT | PAGE_WRITEABLE | PAGE_GLOBAL;
+
+    /*text*/
+    extern void *_kernel_text_start;
+    extern void *_kernel_text_end;
+    uintptr_t kernel_text_start_pptr = KPTR_TOPHYS((uintptr_t)&_kernel_text_start);
+    uintptr_t kernel_text_end_pptr = KPTR_TOPHYS((uintptr_t)&_kernel_text_end);
+    size_t kernel_text_pages = ((kernel_text_end_pptr - kernel_text_start_pptr) / 0x1000) + 1;
+    
+    uintptr_t kernel_text_off = (((uintptr_t)&_kernel_text_start) - KERNEL_VIRT_BASE) >> 12;
+
+    for(size_t i = 0; i < kernel_text_pages; i++) {
+        size_t off = i + kernel_text_off;
+        uintptr_t page_off = kernel_text_start_pptr + (i << 12);
+        _kernel_pml1[off].value = page_off | PAGE_PRESENT | PAGE_GLOBAL;
+    }
+
+    /*rodata*/
+    extern void *_kernel_rodata_start;
+    extern void *_kernel_rodata_end;
+    uintptr_t kernel_rodata_start_pptr = KPTR_TOPHYS((uintptr_t)&_kernel_rodata_start);
+    uintptr_t kernel_rodata_end_pptr = KPTR_TOPHYS((uintptr_t)&_kernel_rodata_end);
+    size_t kernel_rodata_pages = ((kernel_rodata_end_pptr - kernel_rodata_start_pptr) / 0x1000) + 1;
+
+    uintptr_t kernel_rodata_off = kernel_text_off + kernel_text_pages;
+    for(size_t i = 0; i < kernel_rodata_pages; i++) {
+        size_t off = i + kernel_rodata_off;
+        uintptr_t page_off = kernel_text_start_pptr + (off << 12);
+        _kernel_pml1[off].value = page_off | PAGE_PRESENT | PAGE_GLOBAL | PAGE_XD;
+    }
+
+    /*data/bss*/
+    extern void *_kernel_data_start;
+    extern void *_kernel_bss_end;
+    uintptr_t kernel_data_start_pptr = KPTR_TOPHYS((uintptr_t)&_kernel_data_start);
+    uintptr_t kernel_data_end_pptr = KPTR_TOPHYS((uintptr_t)&_kernel_bss_end);
+    size_t kernel_data_pages = ((kernel_data_end_pptr - kernel_data_start_pptr) / 0x1000) + 1;
+
+    uintptr_t kernel_data_off = kernel_rodata_off + kernel_rodata_pages;
+    for(size_t i = 0; i < kernel_data_pages; i++) {
+        size_t off = i + kernel_data_off;
+        uintptr_t page_off = kernel_text_start_pptr + (off << 12);
+        _kernel_pml1[off].value = page_off | PAGE_PRESENT | PAGE_WRITEABLE | PAGE_GLOBAL | PAGE_XD;
+    }
+
+    /*Identity pages are mapped as huge pages starting at the 256'th PML3 entry.
+     *We want to support any range of physical memory up to several TiB, so
+     *the mapper has to consider multiple heirarchies of huge pages.*/
+    for(size_t l3 = 0; l3 < IDENT_GIANTPAGES; l3++) {
+        memset(ident_pml3[l3], 0, 0x1000);
+        uintptr_t ident_pml3_pptr = KPTR_TOPHYS((uintptr_t)ident_pml3[l3]);
+
+        _kernel_pml4[256 + l3].value = ident_pml3_pptr | PAGE_PRESENT | PAGE_WRITEABLE | PAGE_GLOBAL;
+    }
+
+    for(size_t l2 = 0; l2 < IDENT_HUGEPAGES; l2++) {
+        size_t l3 = l2 / 512;
+        size_t l2_mod = l2 % 512;
+
+        memset(ident_pml2[l2], 0, 0x1000);
+        uintptr_t ident_pml2_pptr = KPTR_TOPHYS((uintptr_t)ident_pml2[l2]);
+
+        ident_pml3[l3][l2_mod].value = ident_pml2_pptr | PAGE_PRESENT | PAGE_WRITEABLE | PAGE_GLOBAL;
+    }
+
+    for(size_t l1 = 0; l1 < PHYS_BIGPAGES_MAX; l1++) {
+        size_t l2 = l1 / 512;
+        size_t l1_mod = l1 % 512;
+
+        ident_pml2[l2][l1_mod].value = (l1 << 21) | PAGE_PRESENT | PAGE_WRITEABLE | PAGE_PS | PAGE_GLOBAL;
+        ident_pml2[l2][l1_mod].xd = 1;
+    }
+
+    paging_pml4_switch(kernel_pml4_pptr);
+
+    /*Before tasking, if the kernel has a bug and crashes we need some
+     * information about what happened.*/
+    extern struct int_stackframe *(*__int_handles[])(struct int_stackframe*);
+    __int_handles[IDT_EXCEPT_PF] = s_int_handle_pf_early;
+}
diff --git a/arch/x86_64/hal/paging.h b/arch/x86_64/hal/paging.h
new file mode 100644
index 0000000..54df1eb
--- /dev/null
+++ b/arch/x86_64/hal/paging.h
@@ -0,0 +1,52 @@
+#ifndef _JOVE_x86_64_HAL_PAGING_H
+#define _JOVE_x86_64_HAL_PAGING_H 1
+
+#include "jove.h"
+#include <stdint.h>
+
+typedef union page_table_entry
+{
+    struct {
+        uint8_t p : 1;
+        uint8_t rw : 1;
+        uint8_t u : 1;
+        uint8_t pwt : 1;
+        uint8_t pcd : 1;
+        uint8_t a : 1;
+        uint8_t d : 1;
+        uint8_t ps : 1;
+        uint8_t g : 1;
+        uint8_t ign_0 : 2;
+        uint8_t r : 1;
+        uint64_t paddr : 35;
+        uint8_t ign_1 : 4;
+        uint8_t pkey : 4;
+        uint8_t xd : 1;
+    };
+    uint64_t value;
+} PACKED page_t;
+
+#define PAGE_PRESENT        0b1
+#define PAGE_WRITEABLE      0b10
+#define PAGE_USER           0b100
+#define PAGE_WRITETHROUGH   0b1000
+#define PAGE_CACHEDISABLE   0b10000
+#define PAGE_ACCESSED       0b100000
+#define PAGE_DIRTY          0b1000000
+#define PAGE_PS             0b10000000
+#define PAGE_GLOBAL         0b100000000
+#define PAGE_XD             (1ULL << 63)
+
+extern void *_kernel_physptr;
+
+#define PMLI_SHL(l) (12 + (l * 9))
+#define PMLI_MASK(l) (~0xFFFF << PMLI_SHL(l))
+
+#define IDENT_VIRT_BASE 0xFFFF800000000000ULL
+#define KERNEL_VIRT_BASE 0xFFFFFFFF80000000ULL
+#define KPTR_TOPHYS(v) (v - KERNEL_VIRT_BASE + (uintptr_t)_kernel_physptr)
+
+uintptr_t paging_get_pml4(void);
+void paging_pml4_init(void);
+
+#endif
diff --git a/arch/x86_64/hal/port.h b/arch/x86_64/hal/port.h
new file mode 100644
index 0000000..6dbc27c
--- /dev/null
+++ b/arch/x86_64/hal/port.h
@@ -0,0 +1,12 @@
+#ifndef _JOVE_PORT_H
+#define _JOVE_PORT_H 1
+
+#include <stdint.h>
+
+static inline uint8_t inb(uint16_t port)
+{ uint8_t r; __asm__ volatile("inb %w1, %b0": "=a"(r): "Nd"(port): "memory"); return r; }
+
+static inline void outb(uint16_t port, uint8_t v)
+{ __asm__ volatile("outb %b0, %w1":: "a"(v), "Nd"(port): "memory"); }
+
+#endif
diff --git a/arch/x86_64/hal/process.c b/arch/x86_64/hal/process.c
new file mode 100644
index 0000000..dd49456
--- /dev/null
+++ b/arch/x86_64/hal/process.c
@@ -0,0 +1,35 @@
+#include "process.h"
+#include "arch/x86_64/hal/obj.h"
+#include "hal/obj.h"
+#include "init.h"
+#include "smp.h"
+#include "paging.h"
+#include "jove.h"
+
+PAGEALIGN char s_init_pcb_bytes[0x1000] = { 0 };
+static pcb_t *s_init_pcb = (pcb_t*)&s_init_pcb_bytes;
+
+void
+processing_setup(void (*process_main))
+{
+    uintptr_t ksp = (uintptr_t)&s_init_pcb_bytes + 8;
+    s_init_pcb->ksp = (void*)ksp;
+    s_init_pcb->pml4 = paging_get_pml4();
+
+    processor_t *proc = processor_current();
+    proc->pcb = s_init_pcb;
+    proc->tss.rsp[0] = (uintptr_t)s_init_pcb->ksp;
+
+    {
+        jove_owned_obj_t *process_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_PCB_I));
+        obj_settype(process_obj, JOVE_OBJ_PROCESS);
+        obj_setvalue(process_obj, (uintptr_t)s_init_pcb);
+        obj_release(process_obj);
+    }
+
+    __asm__ volatile("\
+            movq %0, %%rsp; \
+            movq $0, %%rbp; \
+            jmpq %1"::
+            "r"(s_init_pcb->ksp), "r"(process_main));
+}
diff --git a/arch/x86_64/hal/process.h b/arch/x86_64/hal/process.h
new file mode 100644
index 0000000..0c0fb5b
--- /dev/null
+++ b/arch/x86_64/hal/process.h
@@ -0,0 +1,34 @@
+#ifndef _JOVE_x86_64_HAL_PROCESS_H
+#define _JOVE_x86_64_HAL_PROCESS_H 1
+
+#include "hal/obj.h"
+#include "arch/x86_64/x86_64.h"
+
+enum pcb_state
+{
+    PCB_DEAD, PCB_READY, PCB_RUNNING, PCB_BLOCKED
+};
+
+struct pcb_mailbox
+{
+    jove_obj_t *obj;
+    uintmax_t pcbid;
+};
+
+typedef struct process_control_block
+{
+    jove_obj_t *rootdir;
+    uintptr_t pml4;
+
+    enum pcb_state state;
+    int killed;
+    struct pcb_mailbox send, recv;
+    
+    struct cpu_context context;
+    void *ksp;
+    char kstack[];
+} pcb_t;
+
+#define PCB_KSTACK_SIZE (0x1000 - sizeof(pcb_t))
+
+#endif
diff --git a/arch/x86_64/hal/serial_com.c b/arch/x86_64/hal/serial_com.c
new file mode 100644
index 0000000..3967cd7
--- /dev/null
+++ b/arch/x86_64/hal/serial_com.c
@@ -0,0 +1,92 @@
+#include "serial_com.h"
+#include "port.h"
+#include "jove.h"
+#include "hal/obj.h"
+#include "init.h"
+#include "lib/printf.h"
+
+static int
+serial_com_recv(uint16_t port)
+{
+    return inb(SERIAL_COM_LSR(port)) & 1;
+}
+
+static char
+serial_com_getc(uint16_t port)
+{
+    while(serial_com_recv(port) == 0);
+    return inb(port);
+}
+
+static int
+serial_com_put_ready(uint16_t port)
+{
+    return inb(SERIAL_COM_LSR(port)) & 0x20;
+}
+
+static void 
+serial_com_putc(uint16_t port, char c)
+{
+    while(serial_com_put_ready(port) == 0);
+    outb(port, c);
+}
+
+int
+serial_com_init_port(
+        uint16_t port,
+        uint16_t baud_divisor)
+{
+    uint8_t div_low = (uint8_t)baud_divisor;
+    uint8_t div_high = (uint8_t)(baud_divisor >> 8);
+
+    outb(SERIAL_COM_IER(port), 0x00); // Disable all interrupts
+    outb(SERIAL_COM_LCR(port), 0x80); // Enable DLAB mode.
+    outb(SERIAL_COM_DLAB_BAUD_LO(port), div_low);
+    outb(SERIAL_COM_DLAB_BAUD_HI(port), div_high);
+    outb(SERIAL_COM_LCR(port), 0x03); // 8 bits, no parity, one stop bit.
+    outb(SERIAL_COM_FIFO(port), 0xC7); // Enable FIFO, clear them, 14 byte threshold.
+    outb(SERIAL_COM_MCR(port), 0x0B); // Enable IRQs, set RTS/DSR.
+ 
+    //Test to check if the serial port actually works.
+    outb(SERIAL_COM_MCR(port), 0x1E); // Set loopback mode.
+    outb(port, 0xAE); // Send test byte.
+    if(inb(port) != 0xAE) {
+        return 1;
+    }
+
+    //Set the port to normal operation mode.
+    //(no loopback, IRQs enabled, OUT#1 and OUT#2 enabled.)
+    outb(SERIAL_COM_MCR(port), 0x0F);
+    return 0;
+}
+
+void
+serial_com_init(void)
+{
+    if(serial_com_init_port(SERIAL_COM1, 3)) {
+        hcf();
+    }
+    
+    {
+        jove_owned_obj_t *com_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_SERIAL_COM_I));
+        obj_settype(com_obj, JOVE_OBJ_SERIAL_COM);
+        obj_setvalue(com_obj, SERIAL_COM1);
+        obj_release(com_obj);
+    }
+
+    kprintf("Initialized COM1 on port %X for obj %X\n", SERIAL_COM1, ROOTDIR_SERIAL_COM_I);
+}
+
+int
+serial_com_write(
+        jove_owned_obj_t *obj, 
+        const char *s, size_t len)
+{
+    if(obj->type != JOVE_OBJ_SERIAL_COM) {
+        reterr(EBADOBJ);
+    }
+    for(size_t i = 0; i < len; i++) {
+        serial_com_putc((uint16_t)obj->value, s[i]);
+    }
+    return len;
+}
diff --git a/arch/x86_64/hal/serial_com.h b/arch/x86_64/hal/serial_com.h
new file mode 100644
index 0000000..2dbb0cd
--- /dev/null
+++ b/arch/x86_64/hal/serial_com.h
@@ -0,0 +1,26 @@
+#ifndef _JOVE_SERIAL_COM_H
+#define _JOVE_SERIAL_COM_H 1
+
+#include <stdint.h>
+#include "obj.h"
+
+#define SERIAL_COM1 0x3F8
+
+#define SERIAL_COM_TR(com) (com)
+#define SERIAL_COM_IER(com) (com + 1)
+#define SERIAL_COM_II(com) (com + 2)
+#define SERIAL_COM_FIFO(com) (com + 2)
+#define SERIAL_COM_LCR(com) (com + 3)
+#define SERIAL_COM_MCR(com) (com + 4)
+#define SERIAL_COM_LSR(com) (com + 5)
+#define SERIAL_COM_MSR(com) (com + 6)
+#define SERIAL_COM_SR(com) (com + 7)
+
+#define SERIAL_COM_DLAB_BAUD_LO(com) (com)
+#define SERIAL_COM_DLAB_BAUD_HI(com) (com + 1)
+
+void serial_com_init(void);
+
+int serial_com_write(jove_owned_obj_t *obj, const char *s, size_t len);
+
+#endif
diff --git a/arch/x86_64/hal/smp.c b/arch/x86_64/hal/smp.c
new file mode 100644
index 0000000..a28fdc1
--- /dev/null
+++ b/arch/x86_64/hal/smp.c
@@ -0,0 +1,65 @@
+#include "smp.h"
+#include "init.h"
+#include "hal/obj.h"
+#include "config.h"
+#include "jove.h"
+#include "lib/printf.h"
+#include "paging.h"
+#include "msr.h"
+
+processor_t s_processors[SMP_PROCESSORS_MAX] = { 0 };
+
+PAGEALIGN
+jove_objdir_t s_processor_objdir = { 0 };
+
+extern void
+gdt_setup(processor_t *processor);
+
+extern void
+idt_init(void);
+
+extern void
+idt_setup(processor_t *processor);
+
+static void
+init_processor(processor_t *processor, jove_owned_obj_t *obj)
+{
+    gdt_setup(processor);
+    idt_setup(processor);
+
+    msr_set_gs_base((uintptr_t)processor);
+
+    obj_settype(obj, JOVE_OBJ_PROCESSOR);
+    obj_setvalue(obj, (uintptr_t)processor);
+}
+
+void
+smp_init_bsp(void)
+{
+    idt_init();
+    paging_pml4_init();
+
+    kprintf("%p\n", _rootdir_obj);
+    processor_t *bsp = &s_processors[0];
+    {
+        jove_owned_obj_t *processor_objdir_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_PROCESSORS_I));
+        obj_settype(processor_objdir_obj, JOVE_OBJ_OBJDIR);
+        obj_setvalue(processor_objdir_obj, (uintptr_t)&s_processor_objdir);
+
+        jove_owned_obj_t *bsp_obj = obj_take(objdir_getlocal(processor_objdir_obj, 0));
+        init_processor(bsp, bsp_obj);
+
+        obj_release(bsp_obj);
+        obj_release(processor_objdir_obj);
+    }
+}
+
+void *processor_current(void)
+{
+    return (processor_t*)msr_get_gs_base();
+}
+
+jove_obj_t *processor_objdir(void *processor)
+{
+    return ((processor_t*)processor)->pcb->rootdir;
+}
diff --git a/arch/x86_64/hal/smp.h b/arch/x86_64/hal/smp.h
new file mode 100644
index 0000000..68e420f
--- /dev/null
+++ b/arch/x86_64/hal/smp.h
@@ -0,0 +1,18 @@
+#ifndef _JOVE_x86_64_HAL_SMP_H
+#define _JOVE_x86_64_HAL_SMP_H 1
+
+#include "gdt.h"
+#include "process.h"
+#include "hal/smp.h"
+
+typedef struct processor
+{
+    struct gdt_entry gdt[GDT_TSS_HI+1];
+    struct tss tss;
+    
+    pcb_t *pcb;
+} processor_t;
+
+void smp_init_bsp(void);
+
+#endif
diff --git a/arch/x86_64/lib/printf.c b/arch/x86_64/lib/printf.c
new file mode 100644
index 0000000..42ee568
--- /dev/null
+++ b/arch/x86_64/lib/printf.c
@@ -0,0 +1,25 @@
+#include "../hal/serial_com.h"
+#include "lib/printf.h"
+#include "lib/virtterm.h"
+#include "init.h"
+
+int
+kvprintf(const char *fmt, va_list ap)
+{
+    char buffer[256] = { 0 };
+    int r = vsnprintf(buffer, 256, fmt, ap);
+    int wlen = (r > 256 ? 256 : r);
+
+    {
+        jove_owned_obj_t *serial_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_SERIAL_COM_I));
+        serial_com_write(serial_obj, buffer, wlen);
+        obj_release(serial_obj);
+
+        jove_owned_obj_t *vt_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_VIRTTERM_I));
+        vt_write(vt_obj, buffer, wlen);
+
+        obj_release(vt_obj);
+    }
+
+    return r;
+}
diff --git a/arch/x86_64/lock.c b/arch/x86_64/lock.c
new file mode 100644
index 0000000..b010ee6
--- /dev/null
+++ b/arch/x86_64/lock.c
@@ -0,0 +1,18 @@
+#include "lock.h"
+
+extern int _kernel_panic_unlock;
+
+void
+take_mutex(atomic_flag *lock)
+{
+    if(_kernel_panic_unlock) return;
+    while(atomic_flag_test_and_set(lock)) {
+        __builtin_ia32_pause();
+    }
+}
+
+void
+release_mutex(atomic_flag *lock)
+{
+    atomic_flag_clear(lock);
+}
diff --git a/arch/x86_64/lock.h b/arch/x86_64/lock.h
new file mode 100644
index 0000000..609ea39
--- /dev/null
+++ b/arch/x86_64/lock.h
@@ -0,0 +1,9 @@
+#ifndef _JOVE_x86_64_LOCK_H
+#define _JOVE_x86_64_LOCK_H 1
+
+#include <stdatomic.h>
+
+void take_mutex(atomic_flag *lock);
+void release_mutex(atomic_flag *lock);
+
+#endif
diff --git a/arch/x86_64/main.c b/arch/x86_64/main.c
new file mode 100644
index 0000000..44591a5
--- /dev/null
+++ b/arch/x86_64/main.c
@@ -0,0 +1,48 @@
+#include "jove.h"
+#include "lib/printf.h"
+#include "lib/virtterm.h"
+#include "lib/panic.h"
+#include "../../hal/obj.h"
+#include "hal/serial_com.h"
+#include "hal/smp.h"
+#include "hal/memory.h"
+#include "hal/framebuffer.h"
+#include "hal/process.h"
+#include "boot/initrd.h"
+#include "boot/cmdline.h"
+
+int errno = 0;
+
+PAGEALIGN jove_objdir_t _rootdir = { 0 };
+
+void *_rootdir_obj = &_rootdir;
+
+static void kernel_process_entry(void);
+
+void
+kernel_entry(void)
+{
+    obj_settype(_rootdir_obj, JOVE_OBJ_OBJDIR);
+    serial_com_init();
+
+    smp_init_bsp();
+
+    initrd_setup();
+
+    fb_init();
+    vt_init();
+
+    cmdline_print();
+
+    mem_setup_untyped();
+
+    extern void processing_setup(void*);
+    processing_setup(kernel_process_entry);
+    hcf();
+}
+
+static void
+kernel_process_entry(void)
+{
+    kpanic("Reached the end of kernel main!\n");
+}
diff --git a/arch/x86_64/x86_64.c b/arch/x86_64/x86_64.c
new file mode 100644
index 0000000..a478ce1
--- /dev/null
+++ b/arch/x86_64/x86_64.c
@@ -0,0 +1,13 @@
+#include "x86_64.h"
+#include "lib/printf.h"
+
+void
+print_state(struct cpu_state *state)
+{
+    kprintf("RAX: %p | RBX: %p | RCX: %p\n", state->rax, state->rbx, state->rcx);
+    kprintf("RDX: %p | RSI: %p | RDI: %p\n", state->rdx, state->rsi, state->rdi);
+    kprintf("RBP: %p\n", state->rbp);
+    kprintf("R8 : %p | R9 : %p | R10: %p\n", state->r8, state->r9, state->r10);
+    kprintf("R11: %p | R12: %p | R13: %p\n", state->r11, state->r12, state->r13);
+    kprintf("R14: %p | R15: %p\n", state->r14, state->r15);
+}
diff --git a/arch/x86_64/x86_64.h b/arch/x86_64/x86_64.h
new file mode 100644
index 0000000..9a0311b
--- /dev/null
+++ b/arch/x86_64/x86_64.h
@@ -0,0 +1,20 @@
+#ifndef _JOVE_x86_64_H
+#define _JOVE_x86_64_H 1
+
+#include <stdint.h>
+
+struct cpu_state
+{
+    uint64_t r15, r14, r13, r12, r11, r10, r9, r8;
+    uint64_t rbp, rdi, rsi, rdx, rcx, rbx, rax;
+};
+
+struct cpu_context
+{
+    struct cpu_state state;
+    uint64_t rsp, rip;
+};
+
+void print_state(struct cpu_state *state);
+
+#endif
diff --git a/boot/cmdline.c b/boot/cmdline.c
new file mode 100644
index 0000000..06a6169
--- /dev/null
+++ b/boot/cmdline.c
@@ -0,0 +1,65 @@
+#include "config.h"
+#include "cmdline.h"
+#include <stddef.h>
+#include "lib/string.h"
+#include "lib/printf.h"
+
+const char *s_cmdline = NULL;
+
+struct kvpair
+{
+    const char *key, *value;
+} s_arguments[CMDLINE_MAX_ARGUMENTS] = { 0 };
+size_t s_numargs = 0;
+
+void
+cmdline_init(char *cmdline)
+{
+    s_cmdline = cmdline;
+    size_t last_arg = 0;
+    const char *arg = cmdline;
+
+    for(char *s = cmdline; *s; s++) {
+        if(*s == '=') {
+            *(s++) = 0;
+            s_arguments[last_arg].key = arg;
+            arg = s;
+            for(; *s && (*s != ' '); s++) {
+                if(*s == '"') {
+                    s++;
+                    for(; *s && (*s != '"'); s++);
+                    s++;
+                }
+            }
+            *(s++) = 0;
+            s_arguments[last_arg++].value = arg;
+            arg = s;
+        }
+    }
+    s_numargs = last_arg;
+}
+
+void
+cmdline_print()
+{
+    for(size_t i = 0; i < s_numargs; i++) {
+        const char *arg_key = s_arguments[i].key;
+        const char *arg_value = s_arguments[i].value;
+
+        kprintf("cmdline: %s=%s\n", arg_key, arg_value);
+    }
+}
+
+const char*
+cmdline_getarg(const char *key)
+{
+    for(size_t i = 0; i < s_numargs; i++) {
+        const char *arg_key = s_arguments[i].key;
+        const char *arg_value = s_arguments[i].value;
+
+        if(strncmp(arg_key, key, strlen(arg_key)) == 0) {
+            return arg_value;
+        }
+    }
+    return NULL;
+}
diff --git a/boot/cmdline.h b/boot/cmdline.h
new file mode 100644
index 0000000..aa5da43
--- /dev/null
+++ b/boot/cmdline.h
@@ -0,0 +1,9 @@
+#ifndef _JOVE_BOOT_CMDLINE_H
+#define _JOVE_BOOT_CMDLINE_H 1
+
+void cmdline_init(char *cmdline);
+
+void cmdline_print(void);
+const char *cmdline_getarg(const char *key);
+
+#endif
diff --git a/boot/initrd.c b/boot/initrd.c
new file mode 100644
index 0000000..dc16d98
--- /dev/null
+++ b/boot/initrd.c
@@ -0,0 +1,72 @@
+#include "initrd.h"
+#include "init.h"
+#include "jove.h"
+#include "lib/printf.h"
+#include "lib/tar.h"
+#include "hal/obj.h"
+#include "hal/memory.h"
+
+extern uintptr_t _initrd_module;
+
+PAGEALIGN jove_objdir_t s_initrd_objdir = { 0 };
+
+#define CHECK_IF_INITRD(obj) \
+    if(obj_gettype(obj) != JOVE_OBJ_INITRD_FILE) { \
+        reterr(EBADOBJ); \
+    }
+
+int 
+initrd_file_name(jove_owned_obj_t *obj, const char **nameptr)
+{
+    CHECK_IF_INITRD(obj);
+    struct tar_header *file = obj_deref(obj);
+    *nameptr = tar_filename(file);
+    return 0;
+}
+
+int 
+initrd_file_size(jove_owned_obj_t *obj, size_t *sizeptr)
+{
+    CHECK_IF_INITRD(obj);
+    struct tar_header *file = obj_deref(obj);
+    *sizeptr = tar_filesize(file);
+    return 0;
+}
+
+int
+initrd_file_data(jove_owned_obj_t *obj, uintptr_t *dataptr)
+{
+    CHECK_IF_INITRD(obj);
+    union tar_block *file = obj_deref(obj);
+    *dataptr = (uintptr_t)&file[1];
+    return 0;
+}
+
+void initrd_setup(void)
+{
+    kprintf("Loading initrd from bootloader:\n");
+    {
+        jove_owned_obj_t *initrd_objdir_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_INITRD_I));
+        obj_settype(initrd_objdir_obj, JOVE_OBJ_OBJDIR);
+        obj_setvalue(initrd_objdir_obj, (uintmax_t)&s_initrd_objdir);
+
+        size_t initrd_files = 0;
+        union tar_block *block = phys_tovirt(_initrd_module);
+        for(;;) { 
+            struct tar_header *header = &block->header;
+            if(*header->filename == 0) break;
+
+            size_t file_size = tar_filesize(header);
+            kprintf("File: %s, Size: %i\n", tar_filename(header), file_size);
+            {
+                jove_owned_obj_t *initrd_file_obj = obj_take(objdir_getlocal(initrd_objdir_obj, initrd_files++));
+                obj_settype(initrd_file_obj, JOVE_OBJ_INITRD_FILE);
+                obj_setvalue(initrd_file_obj, (uintmax_t)block);
+                obj_release(initrd_file_obj);
+            }
+
+            block = &block[((file_size + 511) / 512) + 1];
+        }
+        obj_release(initrd_objdir_obj);
+    }
+}
diff --git a/boot/initrd.h b/boot/initrd.h
new file mode 100644
index 0000000..9b3bba9
--- /dev/null
+++ b/boot/initrd.h
@@ -0,0 +1,12 @@
+#ifndef _JOVE_BOOT_INITRD_H
+#define _JOVE_BOOT_INITRD_H 1
+
+#include "hal/obj.h"
+
+int initrd_file_name(jove_owned_obj_t *obj, const char **nameptr);
+int initrd_file_size(jove_owned_obj_t *obj, size_t *sizeptr);
+int initrd_file_data(jove_owned_obj_t *obj, uintptr_t *dataptr);
+
+void initrd_setup(void);
+
+#endif
diff --git a/boot/limine/framebuffer.c b/boot/limine/framebuffer.c
new file mode 100644
index 0000000..b4330bb
--- /dev/null
+++ b/boot/limine/framebuffer.c
@@ -0,0 +1,79 @@
+#include "arch/x86_64/hal/obj.h"
+#include "jove.h"
+#include "lib/printf.h"
+#include "limine.h"
+#include "init.h"
+#include "hal/framebuffer.h"
+
+extern struct limine_framebuffer_response *_limine_framebuffers;
+
+#define CHECK_IF_FB(obj) \
+    if(obj_gettype(obj) != JOVE_OBJ_FRAMEBUFFER) { \
+        reterr(EBADOBJ); \
+    }
+
+size_t
+fb_width(jove_owned_obj_t *obj)
+{
+    CHECK_IF_FB(obj);
+    struct limine_framebuffer *fb = obj_deref(obj);
+    return fb->width;
+}
+
+size_t
+fb_height(jove_owned_obj_t *obj)
+{
+    CHECK_IF_FB(obj);
+    struct limine_framebuffer *fb = obj_deref(obj);
+    return fb->height;
+}
+
+int
+fb_blit(jove_owned_obj_t *obj,
+        uint32_t *data,
+        size_t x, size_t y,
+        size_t width, size_t height)
+{
+    CHECK_IF_FB(obj);
+    struct limine_framebuffer *fb = obj_deref(obj);
+    
+    uint32_t *fb_address = fb->address;
+    for(size_t oline = 0; oline < height; oline++) {
+        size_t line = oline + y;
+        uint32_t *line_data = &data[oline * width];
+        for(size_t ocol = 0; ocol < width; ocol++) {
+            size_t col = ocol + x;
+            fb_address[line * (fb->pitch >> 2) + col] = line_data[ocol];
+        }
+    }
+    return 0;
+}
+
+void
+fb_init()
+{
+    if(_limine_framebuffers->framebuffer_count == 0) {
+        return;
+    }
+    struct limine_framebuffer *fb = _limine_framebuffers->framebuffers[0];
+    size_t fb_bytes = fb->width * fb->height * (fb->bpp / 8);
+    void *fb_virt = fb_remap((uintptr_t)fb->address, fb_bytes);
+    if(fb_virt == NULL) {
+        kprintf("Unable to remap framebuffer.\n");
+        return;
+    }
+
+    kprintf("framebuffer: phys address %p\n", (uintptr_t)fb->address);
+    kprintf("framebuffer: virt address %p\n", fb_virt);
+    kprintf("framebuffer: width %ipx\n", fb->width);
+    kprintf("framebuffer: height %ipx\n", fb->height);
+    kprintf("framebuffer: %i bpp\n", fb->bpp);
+
+    fb->address = fb_virt;
+    {
+        jove_owned_obj_t *fb_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_FRAMEBUFFER_I));
+        obj_settype(fb_obj, JOVE_OBJ_FRAMEBUFFER);
+        obj_setvalue(fb_obj, (uintptr_t)fb);
+        obj_release(fb_obj);
+    }
+}
diff --git a/boot/limine/limine.h b/boot/limine/limine.h
new file mode 100644
index 0000000..785d89a
--- /dev/null
+++ b/boot/limine/limine.h
@@ -0,0 +1,575 @@
+/* BSD Zero Clause License */
+
+/* Copyright (C) 2022-2025 Mintsuki and contributors.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+ * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef LIMINE_H
+#define LIMINE_H 1
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Misc */
+
+#ifdef LIMINE_NO_POINTERS
+#  define LIMINE_PTR(TYPE) uint64_t
+#else
+#  define LIMINE_PTR(TYPE) TYPE
+#endif
+
+#define LIMINE_REQUESTS_START_MARKER { 0xf6b8f4b39de7d1ae, 0xfab91a6940fcb9cf, \
+                                       0x785c6ed015d3e316, 0x181e920a7852b9d9 }
+#define LIMINE_REQUESTS_END_MARKER { 0xadc0e0531bb10d03, 0x9572709f31764c62 }
+
+#define LIMINE_BASE_REVISION(N) { 0xf9562b2d5c95a6c8, 0x6a7b384944536bdc, (N) }
+
+#define LIMINE_BASE_REVISION_SUPPORTED(VAR) ((VAR)[2] == 0)
+
+#define LIMINE_LOADED_BASE_REVISION_VALID(VAR) ((VAR)[1] != 0x6a7b384944536bdc)
+#define LIMINE_LOADED_BASE_REVISION(VAR) ((VAR)[1])
+
+#define LIMINE_COMMON_MAGIC 0xc7b1dd30df4c8b88, 0x0a82e883a194f07b
+
+struct limine_uuid {
+    uint32_t a;
+    uint16_t b;
+    uint16_t c;
+    uint8_t d[8];
+};
+
+#define LIMINE_MEDIA_TYPE_GENERIC 0
+#define LIMINE_MEDIA_TYPE_OPTICAL 1
+#define LIMINE_MEDIA_TYPE_TFTP 2
+
+struct limine_file {
+    uint64_t revision;
+    LIMINE_PTR(void *) address;
+    uint64_t size;
+    LIMINE_PTR(char *) path;
+    LIMINE_PTR(char *) string;
+    uint32_t media_type;
+    uint32_t unused;
+    uint32_t tftp_ip;
+    uint32_t tftp_port;
+    uint32_t partition_index;
+    uint32_t mbr_disk_id;
+    struct limine_uuid gpt_disk_uuid;
+    struct limine_uuid gpt_part_uuid;
+    struct limine_uuid part_uuid;
+};
+
+/* Boot info */
+
+#define LIMINE_BOOTLOADER_INFO_REQUEST_ID { LIMINE_COMMON_MAGIC, 0xf55038d8e2a1202f, 0x279426fcf5f59740 }
+
+struct limine_bootloader_info_response {
+    uint64_t revision;
+    LIMINE_PTR(char *) name;
+    LIMINE_PTR(char *) version;
+};
+
+struct limine_bootloader_info_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_bootloader_info_response *) response;
+};
+
+/* Executable command line */
+
+#define LIMINE_EXECUTABLE_CMDLINE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x4b161536e598651e, 0xb390ad4a2f1f303a }
+
+struct limine_executable_cmdline_response {
+    uint64_t revision;
+    LIMINE_PTR(char *) cmdline;
+};
+
+struct limine_executable_cmdline_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_executable_cmdline_response *) response;
+};
+
+/* Firmware type */
+
+#define LIMINE_FIRMWARE_TYPE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x8c2f75d90bef28a8, 0x7045a4688eac00c3 }
+
+#define LIMINE_FIRMWARE_TYPE_X86BIOS 0
+#define LIMINE_FIRMWARE_TYPE_EFI32 1
+#define LIMINE_FIRMWARE_TYPE_EFI64 2
+#define LIMINE_FIRMWARE_TYPE_SBI 3
+
+struct limine_firmware_type_response {
+    uint64_t revision;
+    uint64_t firmware_type;
+};
+
+struct limine_firmware_type_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_firmware_type_response *) response;
+};
+
+/* Stack size */
+
+#define LIMINE_STACK_SIZE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x224ef0460a8e8926, 0xe1cb0fc25f46ea3d }
+
+struct limine_stack_size_response {
+    uint64_t revision;
+};
+
+struct limine_stack_size_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_stack_size_response *) response;
+    uint64_t stack_size;
+};
+
+/* HHDM */
+
+#define LIMINE_HHDM_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x48dcf1cb8ad2b852, 0x63984e959a98244b }
+
+struct limine_hhdm_response {
+    uint64_t revision;
+    uint64_t offset;
+};
+
+struct limine_hhdm_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_hhdm_response *) response;
+};
+
+/* Framebuffer */
+
+#define LIMINE_FRAMEBUFFER_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x9d5827dcd881dd75, 0xa3148604f6fab11b }
+
+#define LIMINE_FRAMEBUFFER_RGB 1
+
+struct limine_video_mode {
+    uint64_t pitch;
+    uint64_t width;
+    uint64_t height;
+    uint16_t bpp;
+    uint8_t memory_model;
+    uint8_t red_mask_size;
+    uint8_t red_mask_shift;
+    uint8_t green_mask_size;
+    uint8_t green_mask_shift;
+    uint8_t blue_mask_size;
+    uint8_t blue_mask_shift;
+};
+
+struct limine_framebuffer {
+    LIMINE_PTR(void *) address;
+    uint64_t width;
+    uint64_t height;
+    uint64_t pitch;
+    uint16_t bpp;
+    uint8_t memory_model;
+    uint8_t red_mask_size;
+    uint8_t red_mask_shift;
+    uint8_t green_mask_size;
+    uint8_t green_mask_shift;
+    uint8_t blue_mask_size;
+    uint8_t blue_mask_shift;
+    uint8_t unused[7];
+    uint64_t edid_size;
+    LIMINE_PTR(void *) edid;
+    /* Response revision 1 */
+    uint64_t mode_count;
+    LIMINE_PTR(struct limine_video_mode **) modes;
+};
+
+struct limine_framebuffer_response {
+    uint64_t revision;
+    uint64_t framebuffer_count;
+    LIMINE_PTR(struct limine_framebuffer **) framebuffers;
+};
+
+struct limine_framebuffer_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_framebuffer_response *) response;
+};
+
+/* Paging mode */
+
+#define LIMINE_PAGING_MODE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x95c1a0edab0944cb, 0xa4e5cb3842f7488a }
+
+#define LIMINE_PAGING_MODE_X86_64_4LVL 0
+#define LIMINE_PAGING_MODE_X86_64_5LVL 1
+#define LIMINE_PAGING_MODE_X86_64_MIN LIMINE_PAGING_MODE_X86_64_4LVL
+#define LIMINE_PAGING_MODE_X86_64_DEFAULT LIMINE_PAGING_MODE_X86_64_4LVL
+
+#define LIMINE_PAGING_MODE_AARCH64_4LVL 0
+#define LIMINE_PAGING_MODE_AARCH64_5LVL 1
+#define LIMINE_PAGING_MODE_AARCH64_MIN LIMINE_PAGING_MODE_AARCH64_4LVL
+#define LIMINE_PAGING_MODE_AARCH64_DEFAULT LIMINE_PAGING_MODE_AARCH64_4LVL
+
+#define LIMINE_PAGING_MODE_RISCV_SV39 0
+#define LIMINE_PAGING_MODE_RISCV_SV48 1
+#define LIMINE_PAGING_MODE_RISCV_SV57 2
+#define LIMINE_PAGING_MODE_RISCV_MIN LIMINE_PAGING_MODE_RISCV_SV39
+#define LIMINE_PAGING_MODE_RISCV_DEFAULT LIMINE_PAGING_MODE_RISCV_SV48
+
+#define LIMINE_PAGING_MODE_LOONGARCH_4LVL 0
+#define LIMINE_PAGING_MODE_LOONGARCH_MIN LIMINE_PAGING_MODE_LOONGARCH_4LVL
+#define LIMINE_PAGING_MODE_LOONGARCH_DEFAULT LIMINE_PAGING_MODE_LOONGARCH_4LVL
+
+struct limine_paging_mode_response {
+    uint64_t revision;
+    uint64_t mode;
+};
+
+struct limine_paging_mode_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_paging_mode_response *) response;
+    uint64_t mode;
+    uint64_t max_mode;
+    uint64_t min_mode;
+};
+
+/* MP */
+
+#define LIMINE_MP_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x95a67b819a1b857e, 0xa0b61b723b6a73e0 }
+
+struct limine_mp_info;
+
+typedef void (*limine_goto_address)(struct limine_mp_info *);
+
+#if defined (__x86_64__) || defined (__i386__)
+
+#define LIMINE_MP_RESPONSE_X86_64_X2APIC (1 << 0)
+
+struct limine_mp_info {
+    uint32_t processor_id;
+    uint32_t lapic_id;
+    uint64_t reserved;
+    LIMINE_PTR(limine_goto_address) goto_address;
+    uint64_t extra_argument;
+};
+
+struct limine_mp_response {
+    uint64_t revision;
+    uint32_t flags;
+    uint32_t bsp_lapic_id;
+    uint64_t cpu_count;
+    LIMINE_PTR(struct limine_mp_info **) cpus;
+};
+
+#elif defined (__aarch64__)
+
+struct limine_mp_info {
+    uint32_t processor_id;
+    uint32_t reserved1;
+    uint64_t mpidr;
+    uint64_t reserved;
+    LIMINE_PTR(limine_goto_address) goto_address;
+    uint64_t extra_argument;
+};
+
+struct limine_mp_response {
+    uint64_t revision;
+    uint64_t flags;
+    uint64_t bsp_mpidr;
+    uint64_t cpu_count;
+    LIMINE_PTR(struct limine_mp_info **) cpus;
+};
+
+#elif defined (__riscv) && (__riscv_xlen == 64)
+
+struct limine_mp_info {
+    uint64_t processor_id;
+    uint64_t hartid;
+    uint64_t reserved;
+    LIMINE_PTR(limine_goto_address) goto_address;
+    uint64_t extra_argument;
+};
+
+struct limine_mp_response {
+    uint64_t revision;
+    uint64_t flags;
+    uint64_t bsp_hartid;
+    uint64_t cpu_count;
+    LIMINE_PTR(struct limine_mp_info **) cpus;
+};
+
+#elif defined (__loongarch__) && (__loongarch_grlen == 64)
+
+struct limine_mp_info {
+    uint64_t reserved;
+};
+
+struct limine_mp_response {
+    uint64_t cpu_count;
+    LIMINE_PTR(struct limine_mp_info **) cpus;
+};
+
+#else
+#error Unknown architecture
+#endif
+
+#define LIMINE_MP_REQUEST_X86_64_X2APIC (1 << 0)
+
+struct limine_mp_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_mp_response *) response;
+    uint64_t flags;
+};
+
+/* Memory map */
+
+#define LIMINE_MEMMAP_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x67cf3d9d378a806f, 0xe304acdfc50c3c62 }
+
+#define LIMINE_MEMMAP_USABLE                 0
+#define LIMINE_MEMMAP_RESERVED               1
+#define LIMINE_MEMMAP_ACPI_RECLAIMABLE       2
+#define LIMINE_MEMMAP_ACPI_NVS               3
+#define LIMINE_MEMMAP_BAD_MEMORY             4
+#define LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE 5
+#define LIMINE_MEMMAP_EXECUTABLE_AND_MODULES 6
+#define LIMINE_MEMMAP_FRAMEBUFFER            7
+#define LIMINE_MEMMAP_ACPI_TABLES            8
+
+struct limine_memmap_entry {
+    uint64_t base;
+    uint64_t length;
+    uint64_t type;
+};
+
+struct limine_memmap_response {
+    uint64_t revision;
+    uint64_t entry_count;
+    LIMINE_PTR(struct limine_memmap_entry **) entries;
+};
+
+struct limine_memmap_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_memmap_response *) response;
+};
+
+/* Entry point */
+
+#define LIMINE_ENTRY_POINT_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x13d86c035a1cd3e1, 0x2b0caa89d8f3026a }
+
+typedef void (*limine_entry_point)(void);
+
+struct limine_entry_point_response {
+    uint64_t revision;
+};
+
+struct limine_entry_point_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_entry_point_response *) response;
+    LIMINE_PTR(limine_entry_point) entry;
+};
+
+/* Executable File */
+
+#define LIMINE_EXECUTABLE_FILE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0xad97e90e83f1ed67, 0x31eb5d1c5ff23b69 }
+
+struct limine_executable_file_response {
+    uint64_t revision;
+    LIMINE_PTR(struct limine_file *) executable_file;
+};
+
+struct limine_executable_file_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_executable_file_response *) response;
+};
+
+/* Module */
+
+#define LIMINE_MODULE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x3e7e279702be32af, 0xca1c4f3bd1280cee }
+
+#define LIMINE_INTERNAL_MODULE_REQUIRED (1 << 0)
+#define LIMINE_INTERNAL_MODULE_COMPRESSED (1 << 1)
+
+struct limine_internal_module {
+    LIMINE_PTR(const char *) path;
+    LIMINE_PTR(const char *) string;
+    uint64_t flags;
+};
+
+struct limine_module_response {
+    uint64_t revision;
+    uint64_t module_count;
+    LIMINE_PTR(struct limine_file **) modules;
+};
+
+struct limine_module_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_module_response *) response;
+
+    /* Request revision 1 */
+    uint64_t internal_module_count;
+    LIMINE_PTR(struct limine_internal_module **) internal_modules;
+};
+
+/* RSDP */
+
+#define LIMINE_RSDP_REQUEST_ID { LIMINE_COMMON_MAGIC, 0xc5e77b6b397e7b43, 0x27637845accdcf3c }
+
+struct limine_rsdp_response {
+    uint64_t revision;
+    LIMINE_PTR(void *) address;
+};
+
+struct limine_rsdp_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_rsdp_response *) response;
+};
+
+/* SMBIOS */
+
+#define LIMINE_SMBIOS_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x9e9046f11e095391, 0xaa4a520fefbde5ee }
+
+struct limine_smbios_response {
+    uint64_t revision;
+    uint64_t entry_32;
+    uint64_t entry_64;
+};
+
+struct limine_smbios_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_smbios_response *) response;
+};
+
+/* EFI system table */
+
+#define LIMINE_EFI_SYSTEM_TABLE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x5ceba5163eaaf6d6, 0x0a6981610cf65fcc }
+
+struct limine_efi_system_table_response {
+    uint64_t revision;
+    uint64_t address;
+};
+
+struct limine_efi_system_table_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_efi_system_table_response *) response;
+};
+
+/* EFI memory map */
+
+#define LIMINE_EFI_MEMMAP_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x7df62a431d6872d5, 0xa4fcdfb3e57306c8 }
+
+struct limine_efi_memmap_response {
+    uint64_t revision;
+    LIMINE_PTR(void *) memmap;
+    uint64_t memmap_size;
+    uint64_t desc_size;
+    uint64_t desc_version;
+};
+
+struct limine_efi_memmap_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_efi_memmap_response *) response;
+};
+
+/* Date at boot */
+
+#define LIMINE_DATE_AT_BOOT_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x502746e184c088aa, 0xfbc5ec83e6327893 }
+
+struct limine_date_at_boot_response {
+    uint64_t revision;
+    int64_t timestamp;
+};
+
+struct limine_date_at_boot_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_date_at_boot_response *) response;
+};
+
+/* Executable address */
+
+#define LIMINE_EXECUTABLE_ADDRESS_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x71ba76863cc55f63, 0xb2644a48c516a487 }
+
+struct limine_executable_address_response {
+    uint64_t revision;
+    uint64_t physical_base;
+    uint64_t virtual_base;
+};
+
+struct limine_executable_address_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_executable_address_response *) response;
+};
+
+/* Device Tree Blob */
+
+#define LIMINE_DTB_REQUEST_ID { LIMINE_COMMON_MAGIC, 0xb40ddb48fb54bac7, 0x545081493f81ffb7 }
+
+struct limine_dtb_response {
+    uint64_t revision;
+    LIMINE_PTR(void *) dtb_ptr;
+};
+
+struct limine_dtb_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_dtb_response *) response;
+};
+
+/* RISC-V Boot Hart ID */
+
+#define LIMINE_RISCV_BSP_HARTID_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x1369359f025525f9, 0x2ff2a56178391bb6 }
+
+struct limine_riscv_bsp_hartid_response {
+    uint64_t revision;
+    uint64_t bsp_hartid;
+};
+
+struct limine_riscv_bsp_hartid_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_riscv_bsp_hartid_response *) response;
+};
+
+/* Bootloader Performance */
+
+#define LIMINE_BOOTLOADER_PERFORMANCE_REQUEST_ID { LIMINE_COMMON_MAGIC, 0x6b50ad9bf36d13ad, 0xdc4c7e88fc759e17 }
+
+struct limine_bootloader_performance_response {
+    uint64_t revision;
+    uint64_t reset_usec;
+    uint64_t init_usec;
+    uint64_t exec_usec;
+};
+
+struct limine_bootloader_performance_request {
+    uint64_t id[4];
+    uint64_t revision;
+    LIMINE_PTR(struct limine_bootloader_performance_response *) response;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/boot/limine/memorymap.c b/boot/limine/memorymap.c
new file mode 100644
index 0000000..905ff3a
--- /dev/null
+++ b/boot/limine/memorymap.c
@@ -0,0 +1,73 @@
+#include "hal/obj.h"
+#include "limine.h"
+#include "hal/memory.h"
+#include "hal/obj.h"
+#include "lib/panic.h"
+#include "init.h"
+#include "lib/printf.h"
+
+extern struct limine_memmap_response *_limine_memmap_resp;
+static jove_objdir_t s_untyped_objdir;
+
+#define MEMMAP_MAX_ENTRIES 255
+
+static const char *limine_mmap_entry_type_str[9] = {
+    "USABLE",
+    "RESERVED",
+    "ACPI RECLAIMABLE",
+    "ACPI NVS",
+    "BAD",
+    "LIMINE RECLAIMABLE",
+    "KERNEL",
+    "FRAMEBUFFER",
+    "ACPI TABLES"
+};
+
+void
+mem_setup_untyped(void)
+{
+    {
+        jove_owned_obj_t *untyped_objdir_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_UNTYPED_I));
+        obj_settype(untyped_objdir_obj, JOVE_OBJ_OBJDIR);
+        obj_setvalue(untyped_objdir_obj, (uintptr_t)&s_untyped_objdir);
+        obj_release(untyped_objdir_obj);
+    }
+
+    if(_limine_memmap_resp == NULL) {
+        kpanic("Limine failed to provide memory map.\n");
+    }
+
+    kprintf("Memory map provided by Limine:\n");
+
+    size_t untyped_i = 0;
+    uintptr_t highest_phys = 0;
+    for(size_t i = 0; i < _limine_memmap_resp->entry_count; i++) {
+        struct limine_memmap_entry *entry = _limine_memmap_resp->entries[i];
+        kprintf("Limine: %p : %p %s\n", entry->base, entry->length, limine_mmap_entry_type_str[entry->type]);
+
+        if(entry->type == LIMINE_MEMMAP_USABLE ||
+           entry->type == LIMINE_MEMMAP_ACPI_RECLAIMABLE ||
+           entry->type == LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE)
+        {
+
+            if(entry->base == 0) continue;
+            if(entry->base + entry->length > highest_phys) highest_phys = entry->base + entry->length;
+
+            {
+                jove_owned_obj_t *untyped_obj = obj_take(&s_untyped_objdir.entries[untyped_i++]);
+                obj_settype(untyped_obj, JOVE_OBJ_UNTYPED);
+                obj_setvalue(untyped_obj, entry->base);
+
+                jove_untyped_t *untyped_data = obj_deref(untyped_obj);
+                untyped_data->limit = entry->length;
+                obj_release(untyped_obj);
+            }
+
+            if(untyped_i > MEMMAP_MAX_ENTRIES){
+                kprintf("!!!Provided memory map exceeds kernel limits. Some memory may not be accessable!!!");
+                break;
+            }
+        }
+    }
+    kprintf("Highest physical address: %p\n", highest_phys);
+}
diff --git a/boot/limine/start.c b/boot/limine/start.c
new file mode 100644
index 0000000..b371f92
--- /dev/null
+++ b/boot/limine/start.c
@@ -0,0 +1,81 @@
+#include <stdint.h>
+#include <stddef.h>
+
+#include "boot/cmdline.h"
+#include "hal/framebuffer.h"
+#include "limine.h"
+
+void _start(void);
+
+#define LIMINE_REQUEST_SECTION __attribute__((section(".limine_requests")))
+
+LIMINE_REQUEST_SECTION
+static volatile uint64_t limine_base_revision[] = LIMINE_BASE_REVISION(4);
+
+LIMINE_REQUEST_SECTION
+static volatile uint64_t limine_requests_start_marker[] = LIMINE_REQUESTS_START_MARKER;
+
+LIMINE_REQUEST_SECTION
+static volatile struct limine_executable_cmdline_request cmdline_req = {
+    .id = LIMINE_EXECUTABLE_CMDLINE_REQUEST_ID,
+    .revision = 0, .response = NULL
+};
+
+LIMINE_REQUEST_SECTION
+static volatile struct limine_entry_point_request entry_point_req = {
+    .id = LIMINE_ENTRY_POINT_REQUEST_ID,
+    .revision = 0, .response = NULL,
+    .entry = _start
+};
+
+LIMINE_REQUEST_SECTION
+static volatile struct limine_executable_address_request executable_address_req = {
+    .id = LIMINE_EXECUTABLE_ADDRESS_REQUEST_ID,
+    .revision = 0, .response = NULL
+};
+
+LIMINE_REQUEST_SECTION
+static volatile struct limine_memmap_request memmap_req = {
+    .id = LIMINE_MEMMAP_REQUEST_ID,
+    .revision = 0, .response = NULL
+};
+
+LIMINE_REQUEST_SECTION
+static volatile struct limine_module_request module_req = {
+    .id = LIMINE_MODULE_REQUEST_ID,
+    .revision = 0, .response = NULL
+};
+
+LIMINE_REQUEST_SECTION
+static volatile struct limine_framebuffer_request framebuffer_request = {
+    .id = LIMINE_FRAMEBUFFER_REQUEST_ID,
+    .revision = 0, .response = NULL
+};
+
+LIMINE_REQUEST_SECTION
+static volatile uint64_t limine_requests_end_marker[] = LIMINE_REQUESTS_END_MARKER;
+
+void *_kernel_physptr = NULL;
+void *_initrd_module = NULL;
+struct limine_framebuffer_response *_limine_framebuffers;
+struct limine_memmap_response *_limine_memmap_resp = NULL;
+
+__attribute__((noreturn))
+void
+_start(void)
+{
+    _kernel_physptr = (void*)executable_address_req.response->physical_base;
+    _limine_memmap_resp = memmap_req.response;
+    _limine_framebuffers = framebuffer_request.response;
+    
+    if(module_req.response->module_count > 0) {
+        _initrd_module = module_req.response->modules[0]->address;
+    }
+
+    cmdline_init(cmdline_req.response->cmdline);
+
+    __attribute__((noreturn))
+    extern void kernel_entry(void);
+
+    kernel_entry();
+}
diff --git a/config.h b/config.h
new file mode 100644
index 0000000..35f4896
--- /dev/null
+++ b/config.h
@@ -0,0 +1,12 @@
+#ifndef _JOVE_CONFIG_H
+#define _JOVE_CONFIG_H 1
+
+#define CMDLINE_MAX_ARGUMENTS 128
+
+#define SMP_PROCESSORS_MAX 8
+#define PHYS_BIGPAGES_MAX 512
+
+#define FRAMEBUFFER_MAX_WIDTH 1920
+#define FRAMEBUFFER_MAX_HEIGHT 1080
+
+#endif
diff --git a/config.mk b/config.mk
new file mode 100644
index 0000000..16e3859
--- /dev/null
+++ b/config.mk
@@ -0,0 +1,21 @@
+CFLAGS = \
+		  -ffreestanding \
+		  -nostdlib \
+		  -fno-pie \
+		  -fno-pic \
+		  -g \
+		  -MD \
+		  -D__$(TARGET_MACHINE)__ \
+		  -D__$(TARGET_BOOTLOADER)__ \
+		  -Iinclude \
+		  -I.
+
+LDFLAGS = -nostdlib \
+		   -T link/$(TARGET_TRIPLET).ld
+
+ifeq "$(TARGET_MACHINE)" "x86_64"
+	CFLAGS += -m64 \
+			  -mno-red-zone \
+			  -mcmodel=kernel \
+			  -mfsgsbase
+endif
diff --git a/hal/framebuffer.h b/hal/framebuffer.h
new file mode 100644
index 0000000..e070889
--- /dev/null
+++ b/hal/framebuffer.h
@@ -0,0 +1,14 @@
+#ifndef _JOVE_HAL_FRAMEBUFFER_H
+#define _JOVE_HAL_FRAMEBUFFER_H 1
+
+#include <stddef.h>
+#include "hal/obj.h"
+
+size_t fb_width(jove_owned_obj_t *fb);
+size_t fb_height(jove_owned_obj_t *fb);
+int fb_blit(jove_owned_obj_t *obj, uint32_t *data, size_t x, size_t y, size_t width, size_t height);
+
+void *fb_remap(uintptr_t fb_address, size_t fb_size);
+void fb_init(void);
+
+#endif
diff --git a/hal/memory.h b/hal/memory.h
new file mode 100644
index 0000000..4d866d0
--- /dev/null
+++ b/hal/memory.h
@@ -0,0 +1,16 @@
+#ifndef _JOVE_HAL_MEMORY_H
+#define _JOVE_HAL_MEMORY_H 1
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct jove_obj_untyped
+{
+    size_t limit;
+} jove_untyped_t;
+
+void mem_setup_untyped(void);
+
+void *phys_tovirt(uintptr_t phys);
+
+#endif
diff --git a/hal/obj.h b/hal/obj.h
new file mode 100644
index 0000000..c0b2a4d
--- /dev/null
+++ b/hal/obj.h
@@ -0,0 +1,22 @@
+#ifndef _JOVE_HAL_OBJ_H
+#define _JOVE_HAL_OBJ_H 1
+
+#include <stddef.h>
+
+enum
+{
+    JOVE_OBJ_NONE = 0,
+    JOVE_OBJ_UNTYPED,
+    JOVE_OBJ_OBJDIR,
+    JOVE_OBJ_PROCESSOR,
+    JOVE_OBJ_PROCESS,
+    JOVE_OBJ_INITRD_FILE,
+    JOVE_OBJ_FRAMEBUFFER,
+    JOVE_OBJ_VIRTTERM
+};
+
+#ifdef __x86_64__
+#include "arch/x86_64/hal/obj.h"
+#endif
+
+#endif
diff --git a/hal/smp.h b/hal/smp.h
new file mode 100644
index 0000000..3718f46
--- /dev/null
+++ b/hal/smp.h
@@ -0,0 +1,10 @@
+#ifndef _JOVE_HAL_SMP_H
+#define _JOVE_HAL_SMP_H 1
+
+#include "obj.h"
+
+void *processor_current(void);
+
+jove_obj_t *processor_objdir(void *processor);
+
+#endif
diff --git a/init.h b/init.h
new file mode 100644
index 0000000..c361d0b
--- /dev/null
+++ b/init.h
@@ -0,0 +1,15 @@
+#ifndef _JOVE_INIT_H
+#define _JOVE_INIT_H 1
+
+extern void *_rootdir_obj;
+
+#define ROOTDIR_PROCESSORS_I 0x0
+#define ROOTDIR_UNTYPED_I 0x01
+#define ROOTDIR_PCB_I 0x02
+#define ROOTDIR_INITRD_I 0x03
+
+#define ROOTDIR_SERIAL_COM_I 0x80
+#define ROOTDIR_FRAMEBUFFER_I 0x81
+#define ROOTDIR_VIRTTERM_I 0x82
+
+#endif
diff --git a/jove.h b/jove.h
new file mode 100644
index 0000000..9c21039
--- /dev/null
+++ b/jove.h
@@ -0,0 +1,20 @@
+#ifndef _JOVE_H
+#define _JOVE_H 1
+
+#define NORETURN __attribute__((noreturn))
+#define PACKED __attribute__((packed))
+
+#define ALIGN(n) __attribute__((aligned(n)))
+#define PAGEALIGN __attribute__((aligned(0x1000)))
+
+NORETURN void hcf(void);
+
+extern int errno;
+#define reterr(e) \
+    errno = e; \
+    return 0
+
+#define EBADOBJ -1
+#define EOOB -2
+
+#endif
diff --git a/lib/panic.c b/lib/panic.c
new file mode 100644
index 0000000..3b39fbf
--- /dev/null
+++ b/lib/panic.c
@@ -0,0 +1,18 @@
+#include "panic.h"
+#include "lib/printf.h"
+
+int _kernel_panic_unlock = 0;
+
+void
+kpanic(const char *fmt, ...)
+{
+    _kernel_panic_unlock = 1;
+
+    va_list ap;
+    va_start(ap, fmt);
+
+    kvprintf(fmt, ap);
+
+    va_end(ap);
+    hcf();
+}
diff --git a/lib/panic.h b/lib/panic.h
new file mode 100644
index 0000000..8f3b409
--- /dev/null
+++ b/lib/panic.h
@@ -0,0 +1,8 @@
+#ifndef _JOVE_LIB_PANIC_H
+#define _JOVE_LIB_PANIC_H 1
+
+#include "jove.h"
+
+NORETURN void kpanic(const char *fmt, ...);
+
+#endif
diff --git a/lib/printf.c b/lib/printf.c
new file mode 100644
index 0000000..4c26fe4
--- /dev/null
+++ b/lib/printf.c
@@ -0,0 +1,138 @@
+#include "printf.h"
+#include "string.h"
+#include "init.h"
+#include "hal/obj.h"
+#include <stdint.h>
+
+int kprintf(const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    int r = kvprintf(fmt, ap);
+    va_end(ap);
+    return r;
+}
+
+#define SPRINTF_PUTC(str, size, i, c) \
+    if(str && i < size) str[i] = (c); \
+    i++
+
+static int
+convert_as_int(
+        char *str,
+        size_t size,
+        int stri,
+        int field_width,
+        uintmax_t value,
+        int radix,
+        int unsign)
+{
+    unsigned digits = 0;
+    int ostri = stri;
+    if((intmax_t)value < 0 && !unsign) {
+        SPRINTF_PUTC(str, size, stri, '-');
+        value = 0 - (intmax_t)value;
+    }
+
+    for(uintmax_t i = value; i != 0; i /= radix) digits++;
+    if(value == 0) digits++;
+
+    if(field_width < digits) field_width = digits;
+    for(uintmax_t i = value, digiti = 0; digiti < digits; i /= radix) {
+        char i_mod = (char)(i % radix);
+        int stri_digiti = stri + (field_width - digiti) - 1;
+
+        SPRINTF_PUTC(str, size, stri_digiti,
+                (i_mod > 9 ? (i_mod + 'a' - 10) : (i_mod + '0')));
+        digiti++;
+    }
+
+    return field_width + (stri - ostri) + 1;
+}
+
+int 
+vsnprintf(
+        char *str, size_t size, 
+        const char *fmt, va_list ap)
+{
+    int stri = 0;
+    for(const char *fmtc = fmt; *fmtc; fmtc++) {
+        if(*fmtc != '%') {
+            SPRINTF_PUTC(str, size, stri, *fmtc);
+            continue;
+        }
+        fmtc++;
+
+        //TODO: other format specifiers.
+        int field_width = 0;
+        char field_pad = ' ';
+
+        int lenspec = 4;
+        
+        int radix = 10;
+        int unsign = 0;
+        int caps = 0;
+        switch(*fmtc) {
+            case 's':
+                goto string_conversion;
+            case 'b':
+                radix = 2;
+                goto int_conversion;
+                break;
+            case 'o':
+                radix = 8;
+                goto int_conversion;
+                break;
+            case 'p':
+                lenspec = sizeof(uintptr_t);
+                field_width = lenspec * 2;
+                field_pad = '0';
+            case 'X':
+                caps = 1;
+            case 'x':
+                unsign = 1;
+                radix = 16;
+                goto int_conversion;
+                break;
+            case 'u':
+                unsign = 1;
+            case 'd':
+            case 'i':
+                goto int_conversion;
+                break;
+        }
+string_conversion:
+        {
+            const char *strarg = va_arg(ap, const char*);
+            for(const char *strargc = strarg; *strargc; strargc++) {
+                SPRINTF_PUTC(str, size, stri, *strargc);
+            }
+        } continue;
+int_conversion: 
+        {
+            uintmax_t value = 0;
+            switch(lenspec) {
+                case 1: value = (uintmax_t)(int8_t)va_arg(ap, int); break;
+                case 2: value = (uintmax_t)(int16_t)va_arg(ap, int); break;
+                default:
+                case 4: value = (uintmax_t)va_arg(ap, unsigned int); break;
+                case 8: value = (uintmax_t)va_arg(ap, uintmax_t); break;
+            }
+            size_t pad_stri = stri;
+            for(size_t i = 0; i < field_width; i++) {
+                SPRINTF_PUTC(str, size, pad_stri, field_pad);
+            }
+
+            int advance = convert_as_int(str, size, stri, field_width, value, radix, unsign);
+            if(caps && str) {
+                for(int i = 0; i < advance; i++) {
+                    int stra = stri + i;
+                    if(stra < size) str[stra] = c_toupper(str[stra]);
+                }
+            }
+            stri += advance;
+        } continue;
+    }
+    if(str && stri < size) str[stri] = 0;
+    return stri;
+}
diff --git a/lib/printf.h b/lib/printf.h
new file mode 100644
index 0000000..a132b39
--- /dev/null
+++ b/lib/printf.h
@@ -0,0 +1,12 @@
+#ifndef _JOVE_LIB_PRINTF_H
+#define _JOVE_LIB_PRINTF_H 1
+
+#include <stdarg.h>
+#include <stddef.h>
+
+int kprintf(const char *fmt, ...);
+int kvprintf(const char *fmt, va_list ap);
+
+int vsnprintf(char *str, size_t size, const char *fmt, va_list ap);
+
+#endif
diff --git a/lib/psf.c b/lib/psf.c
new file mode 100644
index 0000000..407420e
--- /dev/null
+++ b/lib/psf.c
@@ -0,0 +1,8 @@
+#include "psf.h"
+
+uint8_t*
+psf_glyph(struct psf1_header *header, uint8_t glyph)
+{
+    uint8_t *glyph_bitmap = header->bitmap;
+    return &glyph_bitmap[(size_t)glyph * header->char_height];
+}
diff --git a/lib/psf.h b/lib/psf.h
new file mode 100644
index 0000000..b6b8cec
--- /dev/null
+++ b/lib/psf.h
@@ -0,0 +1,19 @@
+#ifndef _JOVE_LIB_PSF_H
+#define _JOVE_LIB_PSF_H 1
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define PSF1_FONT_MAGIC 0x0436
+
+struct psf1_header
+{
+    uint16_t magic;
+    uint8_t mode;
+    uint8_t char_height;
+    uint8_t bitmap[];
+};
+
+uint8_t *psf_glyph(struct psf1_header *header, uint8_t glyph);
+
+#endif
diff --git a/lib/string.c b/lib/string.c
new file mode 100644
index 0000000..28436d5
--- /dev/null
+++ b/lib/string.c
@@ -0,0 +1,50 @@
+#include "string.h"
+
+void *memset(void *s, int c, size_t n)
+{
+    for(size_t i = 0; i < n; i++) {
+        ((char*)s)[i] = c;
+    }
+    return s;
+}
+void *memcpy(void *a, const void *b, size_t n)
+{
+    for(size_t i = 0; i < n; i++) {
+        ((char*)a)[i] = ((const char*)b)[i];
+    }
+    return a;
+}
+
+int memcmp(const void *a, const void *b, size_t n)
+{
+    const char *ca = a;
+    const char *cb = b;
+    for(size_t i = 0; i < n; i++) {
+        if(ca[i] != cb[i]) return ca[i] - cb[i];
+    }
+    return 0;
+}
+
+size_t strlen(const char *s)
+{
+    size_t i = 0;
+    for(; s[i]; i++);
+    return i;
+}
+
+char c_toupper(char c) {
+    return (c > 0x60 && c < 0x7B) ? (c - 0x20) : c;
+}
+
+char *str_toupper(char *s, size_t n)
+{
+    for(size_t i = 0; i < n; i++) {
+        s[i] = c_toupper(s[i]);
+    }
+    return s;
+}
+
+int strncmp(const char *s1, const char *s2, size_t n)
+{
+    return memcmp(s1, s2, n);
+}
diff --git a/lib/string.h b/lib/string.h
new file mode 100644
index 0000000..bdcb0dd
--- /dev/null
+++ b/lib/string.h
@@ -0,0 +1,16 @@
+#ifndef _JOVE_STRING_H
+#define _JOVE_STRING_H 1
+
+#include <stddef.h>
+
+void *memset(void *s, int c, size_t n);
+void *memcpy(void *a, const void *b, size_t n);
+int memcmp(const void *a, const void *b, size_t n);
+
+size_t strlen(const char *s);
+char c_toupper(char c);
+char *str_toupper(char *s, size_t n);
+
+int strncmp(const char *s1, const char *s2, size_t n);
+
+#endif
diff --git a/lib/tar.c b/lib/tar.c
new file mode 100644
index 0000000..58b94b4
--- /dev/null
+++ b/lib/tar.c
@@ -0,0 +1,16 @@
+#include "tar.h"
+
+const char*
+tar_filename(struct tar_header *file)
+{
+    return file->filename;
+}
+
+int
+tar_filesize(struct tar_header *file)
+{
+    int r = 0;
+    const char *oct = file->size;
+    for(; *oct; oct++) r = (r * 8) + (*oct - '0');
+    return r;
+}
diff --git a/lib/tar.h b/lib/tar.h
new file mode 100644
index 0000000..d2435ac
--- /dev/null
+++ b/lib/tar.h
@@ -0,0 +1,25 @@
+#ifndef _JOVE_HAL_TAR_H
+#define _JOVE_HAL_TAR_H 1
+
+struct tar_header
+{
+    char filename[100];
+    char mode[8];
+    char uid[8];
+    char gid[8];
+    char size[12];
+    char modtime[12];
+    char checksum[8];
+    char type;
+};
+
+union tar_block
+{
+    struct tar_header header;
+    char data[512];
+};
+
+const char *tar_filename(struct tar_header *header);
+int tar_filesize(struct tar_header *header);
+
+#endif
diff --git a/lib/virtterm.c b/lib/virtterm.c
new file mode 100644
index 0000000..de43c51
--- /dev/null
+++ b/lib/virtterm.c
@@ -0,0 +1,131 @@
+#include "virtterm.h"
+#include "boot/cmdline.h"
+#include "boot/initrd.h"
+#include "hal/obj.h"
+#include "init.h"
+#include "jove.h"
+#include "hal/framebuffer.h"
+#include "lib/printf.h"
+#include "lib/psf.h"
+#include "lib/string.h"
+
+struct psf1_header *s_font = NULL;
+
+struct virtterm s_init_vtty = { 0 };
+
+static void
+vt_blit(struct virtterm *vtty, jove_owned_obj_t *fb, const uint8_t *glyph)
+{
+    uint32_t buffer[s_font->char_height << 3];
+    size_t cursor_x = vtty->cursor_col * 9;
+    size_t cursor_y = vtty->cursor_row * s_font->char_height;
+
+    for(size_t y = 0; y < s_font->char_height; y++) {
+        uint8_t mask = 1 << 7;
+        for(size_t x = 0; x < 8; x++) {
+            buffer[x + (y << 3)] = glyph[y] & mask ? vtty->cursor_fg : vtty->cursor_bg;
+            mask >>=1;
+        }
+    }
+    fb_blit(fb, buffer, cursor_x, cursor_y, 8, s_font->char_height);
+    vtty->cursor_col++;
+}
+
+static void
+vt_putc(struct virtterm *vtty, jove_owned_obj_t *fb, char c)
+{
+    const uint8_t *glyph = &s_font->bitmap[(size_t)c * s_font->char_height];
+    
+    switch(c) {
+        case '\n':
+            vtty->cursor_col = 0;
+            vtty->cursor_row++;
+        break;
+        default:
+            vt_blit(vtty, fb, glyph);
+        break;
+    }
+
+    if(vtty->cursor_col >= vtty->width) {
+        vtty->cursor_col = 0;
+        vtty->cursor_row++;
+    }
+    if(vtty->cursor_row >= vtty->height) {
+        vtty->cursor_row = 0;
+    }
+}
+
+int
+vt_write(jove_owned_obj_t *obj, const char *s, size_t n)
+{
+    if(obj_gettype(obj) != JOVE_OBJ_VIRTTERM) {
+        reterr(EBADOBJ);
+    }
+
+    struct virtterm *vtty = obj_deref(obj);
+    jove_owned_obj_t *fb_obj = obj_take(objdir_getlocal(_rootdir_obj, vtty->fb_obj));
+    if(obj_gettype(fb_obj) != JOVE_OBJ_FRAMEBUFFER) {
+        obj_release(fb_obj);
+        reterr(EBADOBJ);
+    }
+
+    for(size_t i = 0; i < n; i++) {
+        vt_putc(vtty, fb_obj, s[i]);
+    }
+
+    obj_release(fb_obj);
+    return 0;
+}
+
+void
+vt_init()
+{
+    const char *font_path = cmdline_getarg("font");
+    if(font_path == NULL) {
+        kprintf("Kernel commandline is missing 'font' argument. VTT is disabled.");
+        return;
+    }
+
+    jove_owned_obj_t *initrd_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_INITRD_I));
+    if(obj_gettype(initrd_obj) != JOVE_OBJ_OBJDIR) {
+        kprintf("Initrd is not present. VTT is disabled.\n");
+        obj_release(initrd_obj);
+        return;
+    }
+
+    jove_owned_obj_t *file_obj;
+    size_t file_i = 0;
+    while((file_obj = obj_take(objdir_getlocal(initrd_obj, file_i++)))) {
+        const char *filename = NULL;
+        if(initrd_file_name(file_obj, &filename) != 0) {
+            break;
+        }
+        if(strncmp(font_path, filename, strlen(font_path)) == 0) {
+            initrd_file_data(file_obj, (uintptr_t*)&s_font);
+            break;
+        }
+        obj_release(file_obj);
+    }
+    obj_release(file_obj);
+    obj_release(initrd_obj);
+
+    if(s_font == NULL) {
+        kprintf("Could not find file %s in initrd. VTT is disabled.\n", font_path);
+        return;
+    }
+    s_init_vtty.fb_obj = ROOTDIR_FRAMEBUFFER_I;
+    s_init_vtty.cursor_fg = 0x00FFFFFF;
+
+
+    {
+        jove_owned_obj_t *fb_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_FRAMEBUFFER_I));
+        s_init_vtty.width = fb_width(fb_obj) / 9;
+        s_init_vtty.height = fb_height(fb_obj) / s_font->char_height;
+        obj_release(fb_obj);
+
+        jove_owned_obj_t *vt_obj = obj_take(objdir_getlocal(_rootdir_obj, ROOTDIR_VIRTTERM_I));
+        obj_settype(vt_obj, JOVE_OBJ_VIRTTERM);
+        obj_setvalue(vt_obj, (uintmax_t)&s_init_vtty);
+        obj_release(vt_obj);
+    }
+}
diff --git a/lib/virtterm.h b/lib/virtterm.h
new file mode 100644
index 0000000..08e22e9
--- /dev/null
+++ b/lib/virtterm.h
@@ -0,0 +1,19 @@
+#ifndef _JOVE_LIB_VIRTTERM_H
+#define _JOVE_LIB_VIRTTERM_H 1
+
+#include <stddef.h>
+#include "hal/obj.h"
+
+struct virtterm
+{
+    size_t fb_obj;
+    size_t cursor_col, cursor_row;
+    size_t width, height;
+    uint32_t cursor_fg, cursor_bg;
+};
+
+int vt_write(jove_owned_obj_t *obj, const char *s, size_t n);
+
+void vt_init(void);
+
+#endif
diff --git a/link/x86_64-elf.ld b/link/x86_64-elf.ld
new file mode 100644
index 0000000..6c38b47
--- /dev/null
+++ b/link/x86_64-elf.ld
@@ -0,0 +1,60 @@
+OUTPUT_FORMAT(elf64-x86-64)
+OUTPUT_ARCH(i386:x86-64)
+
+ENTRY(_start)
+
+PAGESIZE = CONSTANT(MAXPAGESIZE);
+
+PHDRS
+{
+    limine_requests PT_LOAD;
+    text    PT_LOAD;
+    rodata  PT_LOAD;
+    data    PT_LOAD;
+    bss     PT_LOAD;
+}
+
+SECTIONS
+{
+    . = 0xFFFFFFFF80000000;
+    _kernel_start = .;
+
+    _kernel_text_start = .;
+    .text : {
+        *(.init)
+        *(.text .text.*)
+        *(.fini)
+    } :text
+    _kernel_text_end = .;
+    . = ALIGN(PAGESIZE);
+
+    _kernel_rodata_start = .;
+    .rodata : {
+        *(.rodata .rodata.*)
+    } :rodata
+    _kernel_rodata_end = .;
+    . = ALIGN(PAGESIZE);
+
+    _kernel_data_start = .;
+    .data : {
+        *(.data .data.*)
+        *(.limine_requests)
+    } :data
+    _kernel_data_end = .;
+    . = ALIGN(PAGESIZE);
+
+    _kernel_bss_start = .;
+    .bss : {
+        *(COMMON)
+        *(.bss .bss.*)
+    } :bss
+    _kernel_bss_end = .;
+
+    /DISCARD/ : {
+        *(.eh_frame*)
+        *(.note .note.*)
+    }
+
+    _kernel_end = .;
+}
+
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..a0eb0e7
--- /dev/null
+++ b/main.c
@@ -0,0 +1,9 @@
+#include "jove.h"
+
+void
+hcf(void)
+{
+    for(;;) {
+        __asm__("hlt");
+    }
+}