massive refactor for mp and organizationHEADmaster

35 files changed, 815 insertions, 893 deletions

diff --git a/arch/arch.h b/arch/arch.h
deleted file mode 100644
index 6e569fd..0000000
--- a/arch/arch.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef JOVE_ARCH_H
-#define JOVE_ARCH_H 1
-
-extern void serial_setup(void);
-
-extern void arch_tables_setup(void);
-
-#endif
diff --git a/arch/x86_64/cpu.c b/arch/x86_64/cpu.c
new file mode 100644
index 0000000..d088fcd
--- /dev/null
+++ b/arch/x86_64/cpu.c
@@ -0,0 +1,35 @@
+#include "arch/cpu.h"
+#include "arch/x86_64/msr.h"
+
+extern void _syscall_entry(void);
+
+extern void idt_init();
+
+void
+cpu_setup(void)
+{
+    idt_init();
+
+    cpu_arch_enable_sce();
+    cpu_set_syscall_entry((void*)_syscall_entry);
+}
+
+void cpu_arch_enable_sce(void)
+{
+    msr_efer_t feat = msr_efer_read();
+    feat.sce = 1;
+    msr_efer_write(feat);
+
+    msr_star_t star = msr_star_read();
+    star.kcs = 0x08;
+    star.ucs = 0x18;
+    msr_star_write(star);
+}
+
+void
+cpu_set_syscall_entry(void *ptr)
+{
+    msr_lstar_t lstar = (msr_lstar_t)ptr;
+    msr_lstar_write(lstar);
+}
+
diff --git a/arch/x86_64/cpu.h b/arch/x86_64/cpu.h
deleted file mode 100644
index 942c8d9..0000000
--- a/arch/x86_64/cpu.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef ARCH_x86_64_CPU_H
-#define ARCH_x86_64_CPU_H 1
-
-#include <stdint.h>
-
-struct Registers
-{
-    uint64_t r15, r14, r13, r12, r11, r10, r9, r8;
-    uint64_t bp, di, si, dx, cx, bx, ax;
-    uint64_t ip, cs, flags, sp, ss;
-};
-
-#endif
diff --git a/arch/x86_64/elf.c b/arch/x86_64/elf.c
deleted file mode 100644
index 969cbf0..0000000
--- a/arch/x86_64/elf.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "elf.h"
-#include "lib/string.h"
-#include "usr/elf.h"
-#include "io/log.h"
-#include "mem/memory.h"
-
-void*
-elf_load(const void *data, size_t len)
-{
-    if(data == NULL) return NULL;
-    if(len < 4) return NULL;
-
-    struct ELF_header *ehdr = (struct ELF_header*)data;
-    if(ehdr->e_ident[EI_MAG0] != E_IDENT_MAG0 &&
-            ehdr->e_ident[EI_MAG1] != E_IDENT_MAG1 &&
-            ehdr->e_ident[EI_MAG2] != E_IDENT_MAG2 &&
-            ehdr->e_ident[EI_MAG3] != E_IDENT_MAG3)
-        return NULL;
-
-    if(ehdr->e_ident[EI_CLASS] != E_IDENT_CLASS64) {
-        klogf("Jove does not support ELF files of class CLASS32\n");
-        return NULL;
-    }
-
-    if(ehdr->e_type != ET_EXEC) {
-        klogf("Jove does not support ELF files other than ET_EXEC\n");
-        return NULL;
-    }
-
-    uint64_t entry = ehdr->e_entry;
-    
-    size_t phdrc = ehdr->e_phnum;
-    struct ELF_phdr *phdrs = (struct ELF_phdr*)((uintptr_t)data + ehdr->e_phoff);
-    
-    for(size_t phdri = 0; phdri < phdrc; phdri++)
-    {
-        struct ELF_phdr *phdr = &phdrs[phdri];
-        void *pdata = (void*)phdr->p_vaddr;
-            
-        mem_ensure_range(
-                phdr->p_vaddr,
-                phdr->p_vaddr + phdr->p_memsz, 
-                (page_flags_t) {
-                    .present = true,
-                    .writeable = true,
-                    .useraccess = true,
-                    .executable = true
-                });
-        if(phdr->p_type == PT_LOAD)
-        {
-            memcpy(pdata, (void*)((uintptr_t)data + phdr->p_offset), phdr->p_filesz);
-        }
-    }
-    return (void*)entry;
-}
diff --git a/arch/x86_64/elf.h b/arch/x86_64/elf.h
deleted file mode 100644
index ebcd228..0000000
--- a/arch/x86_64/elf.h
+++ /dev/null
@@ -1,78 +0,0 @@
-#ifndef JOVE_ARCH_x86_64_ELF_H
-#define JOVE_ARCH_x86_64_ELF_H 1
-
-#include <stdint.h>
-
-#define EI_MAG0 0
-#define EI_MAG1 1
-#define EI_MAG2 2
-#define EI_MAG3 3
-#define EI_CLASS 4
-#define EI_DATA 5
-#define EI_VERSION 6
-#define EI_OSABI 7
-#define EI_ABIVERSION 8
-#define EI_PAD 9
-
-#define E_IDENT_MAG0 0x7F
-#define E_IDENT_MAG1 'E'
-#define E_IDENT_MAG2 'L'
-#define E_IDENT_MAG3 'F'
-
-#define E_IDENT_CLASS32 1
-#define E_IDENT_CLASS64 2
-
-#define ET_EXEC 0x02
-
-struct ELF_header
-{
-    uint8_t e_ident[15];
-    uint16_t e_type;
-    uint16_t e_machine;
-    uint32_t e_version;
-    uint64_t e_entry;
-    uint64_t e_phoff;
-    uint64_t e_shoff;
-    uint32_t e_flags;
-    uint16_t e_ehsize;
-    uint16_t e_phentsize;
-    uint16_t e_phnum;
-    uint16_t e_shentsize;
-    uint16_t e_shnum;
-    uint16_t e_shstrndx;
-};
-
-#define PT_NULL 0
-#define PT_LOAD 1
-
-#define PF_X 1
-#define PF_W 2
-#define PF_R 4
-
-struct ELF_phdr
-{
-    uint32_t p_type;
-    uint32_t p_flags;
-    uint64_t p_offset;
-    uint64_t p_vaddr;
-    uint64_t p_paddr;
-    uint64_t p_filesz;
-    uint64_t p_memsz;
-    uint64_t p_align;
-};
-
-struct ELF_shdr
-{
-    uint32_t sh_name;
-    uint32_t sh_type;
-    uint64_t sh_flags;
-    uint64_t sh_addr;
-    uint64_t sh_offset;
-    uint64_t sh_size;
-    uint32_t sh_link;
-    uint32_t sh_info;
-    uint64_t sh_addralign;
-    uint64_t sh_entsize;
-};
-
-#endif
diff --git a/arch/x86_64/elf_load.c b/arch/x86_64/elf_load.c
new file mode 100644
index 0000000..d7d1b29
--- /dev/null
+++ b/arch/x86_64/elf_load.c
@@ -0,0 +1,58 @@
+#include "arch/elf.h"
+#include "string.h"
+#include "memory.h"
+#include "print.h"
+
+uintptr_t
+elf_load(const void *data, size_t len)
+{
+    if(data == NULL) return 0;
+    if(len < 4) return 0;
+
+    elf_header_t *ehdr = (elf_header_t*)data;
+    if(ehdr->ei_mag[0] != EI_MAG0 ||
+       ehdr->ei_mag[1] != EI_MAG1 ||
+       ehdr->ei_mag[2] != EI_MAG2 ||
+       ehdr->ei_mag[3] != EI_MAG3) return 0;
+
+    if(ehdr->ei_class != EI_CLASS_64) {
+        kerrf("Jove does not support ELF files of class CLASS32\n");
+        return 0;
+    }
+
+    if(ehdr->e_type != ET_EXEC) {
+        kerrf("Jove does not support ELF files other than ET_EXEC\n");
+        return 0;
+    }
+
+    uint64_t entry = ehdr->e_entry;
+    
+    size_t phdrc = ehdr->e_phnum;
+    elf_phdr_t *phdrs = (elf_phdr_t*)((uintptr_t)data + ehdr->e_phoff);
+    
+    for(size_t phdri = 0; phdri < phdrc; phdri++)
+    {
+        elf_phdr_t *phdr = &phdrs[phdri];
+        void *pdata = (void*)phdr->p_vaddr;
+            
+        vm_ensure(
+                phdr->p_vaddr,
+                phdr->p_vaddr + phdr->p_memsz, 
+                (page_flags_t) {
+                    .present = true,
+                    .writeable = true,
+                    .useraccess = true,
+                    .executable = true
+                });
+
+        if(phdr->p_type == PT_LOAD)
+        {
+            kdbgf("PT_LOAD %#016X [%#016X] -> %#016X\n",
+                    (uintptr_t)data + phdr->p_offset,
+                    phdr->p_filesz,
+                    pdata);
+            memcpy(pdata, (void*)((uintptr_t)data + phdr->p_offset), phdr->p_filesz);
+        }
+    }
+    return entry;
+}
diff --git a/arch/x86_64/gdt.c b/arch/x86_64/gdt.c
index 07a8097..614ec30 100644
--- a/arch/x86_64/gdt.c
+++ b/arch/x86_64/gdt.c
@@ -1,24 +1,10 @@
-#include "tables.h"
-#include "tss.h"
+#include "arch/x86_64/gdt.h"
+#include "arch/x86_64/tss.h"
+#include "arch/processor.h"
+#include "string.h"
+#include "print.h"
 
-enum
-{
-    GDT_SEGMENT_KERNEL_NULL = 0,
-    GDT_SEGMENT_KERNEL_CODE,
-    GDT_SEGMENT_KERNEL_DATA,
-
-    GDT_SEGMENT_USER_NULL,
-    GDT_SEGMENT_USER_DATA,
-    GDT_SEGMENT_USER_CODE,
-
-    GDT_SEGMENT_TSS_LOW,
-    GDT_SEGMENT_TSS_HIGH,
-
-    GDT_SEGMENT_COUNT
-};
-
-__attribute__((aligned(0x1000)))
-static struct SegmentDescriptor s_gdtd[GDT_SEGMENT_COUNT] =
+static gdt_t s_baseline_gdt =
 {
     { 0 },  /* Kernel NULL */
     {       /* Kernel Code (64-bit RO EX DPL0) */
@@ -99,43 +85,40 @@ static struct SegmentDescriptor s_gdtd[GDT_SEGMENT_COUNT] =
     },
     { 0 }
 };
-static struct XDTR s_gdtr = {
-    .length = sizeof(s_gdtd) - 1,
-    .address = (uintptr_t)&s_gdtd
-};
 
-static struct TSS s_tss = {
-    
-};
-
-extern void x86_64_lgdt(struct XDTR *gdtr);
-extern void x86_64_flush_tss(void);
 void
-x86_64_load_gdt(void)
+gdt_setup(processor_t *proc)
 {
-    {
-        struct SegmentDescriptor *tss_lo = &s_gdtd[GDT_SEGMENT_TSS_LOW];
-        struct SegmentDescriptor *tss_hi = &s_gdtd[GDT_SEGMENT_TSS_HIGH];
-        uintptr_t tssb = (uintptr_t)&s_tss;
-        tss_lo->base_0_15 = tssb & 0xFFFF;
-        tss_lo->base_16_23 = (tssb >> 16) & 0xFF;
-        tss_lo->base_24_31 = (tssb >> 24) & 0xFF;
-        tss_hi->limit_0_15 = (tssb >> 32) & 0xFFFF;
-        tss_hi->base_0_15 = (tssb >> 48) & 0xFFFF;
+    memcpy(proc->_gdt, s_baseline_gdt, sizeof(gdt_t));
+    proc->_gdtr = (struct XDTR) {
+        .length = sizeof(gdt_t) - 1,
+        .address = (uintptr_t)&proc->_gdt
+    };
+    klogf("Processor %i GDT %#016X L%i\n", proc->id, proc->_gdt, proc->_gdtr.length);
+}
 
-        size_t tssl = sizeof(struct TSS) - 1;
-        tss_lo->limit_0_15 = tssl & 0xFFFF;
-        tss_lo->limit_16_19 = (tssl >> 16) & 0xF;
+void
+tss_setup(processor_t *proc)
+{
+    segment_descriptor_t *tss_lo = &proc->_gdt[GDT_SEGMENT_TSS_LOW];
+    segment_descriptor_t *tss_hi = &proc->_gdt[GDT_SEGMENT_TSS_HIGH];
+    uintptr_t tssb = (uintptr_t)&(proc->_tss);
+    tss_lo->base_0_15 = tssb & 0xFFFF;
+    tss_lo->base_16_23 = (tssb >> 16) & 0xFF;
+    tss_lo->base_24_31 = (tssb >> 24) & 0xFF;
+    tss_hi->limit_0_15 = (tssb >> 32) & 0xFFFF;
+    tss_hi->base_0_15 = (tssb >> 48) & 0xFFFF;
 
-        s_tss.iobp = sizeof(struct TSS);
-    }
+    size_t tssl = sizeof(struct TSS) - 1;
+    tss_lo->limit_0_15 = tssl & 0xFFFF;
+    tss_lo->limit_16_19 = (tssl >> 16) & 0xF;
 
-    x86_64_lgdt(&s_gdtr);
-    x86_64_flush_tss();
+    proc->_tss.iobp = sizeof(struct TSS);
 }
 
-void tss_set_rsp(uint8_t dpl, uintptr_t rsp)
+void
+tss_set_rsp(struct TSS *tss, uint8_t dpl, uintptr_t rsp)
 {
-    s_tss.rsp[dpl][0] = rsp & 0xFFFFFFFF;
-    s_tss.rsp[dpl][1] = (rsp >> 32) & 0xFFFFFFFF;
+    tss->rsp[dpl][0] = rsp & 0xFFFFFFFF;
+    tss->rsp[dpl][1] = (rsp >> 32) & 0xFFFFFFFF;
 }
diff --git a/arch/x86_64/idt.c b/arch/x86_64/idt.c
index 05dcf43..5ddda50 100644
--- a/arch/x86_64/idt.c
+++ b/arch/x86_64/idt.c
@@ -1,64 +1,25 @@
-#include "tables.h"
-#include "cpu.h"
-#include "lib/jove.h"
-#include "io/log.h"
+#include <stddef.h>
+#include "arch/x86_64/tables.h"
+#include "arch/x86_64/idt.h"
+#include "arch/processor.h"
+#include "print.h"
+#include "jove.h"
 
 PAGEALIGN
-static struct InterruptTrapGate s_idtd[48];
-static struct Registers *(*s_int_handlers[48])(struct Registers*);
-static struct XDTR s_idtr = {
-    .length = sizeof(s_idtd) - 1,
-    .address = (uintptr_t)&s_idtd
-};
+static interrupt_gate_t s_idtd[48];
 
 uint64_t __isr_err;
 uint64_t __isr_num;
 
-void
-int_set_handler(uint8_t code, struct Registers *(*handler)(struct Registers*))
-{
-    if(code >= 48) return;
-    s_int_handlers[code] = handler;
-}
-
-struct Registers*
-irq_handle(struct Registers *state)
-{
-    if(__isr_num < 48) {
-        if(s_int_handlers[__isr_num] != NULL) {
-            return s_int_handlers[__isr_num](state);
-        }
-    }
-    klogf("Interrupt %i\nerror code %#016X\n", __isr_num, __isr_err);
-    klogf("IP:  %#016X\n", state->ip);
-    klogf("AX:  %#016X\n", state->ax);
-    klogf("BX:  %#016X\n", state->bx);
-    klogf("CX:  %#016X\n", state->cx);
-    klogf("DX:  %#016X\n", state->dx);
-    klogf("SI:  %#016X\n", state->si);
-    klogf("DI:  %#016X\n", state->di);
-    klogf("BP:  %#016X\n", state->bp);
-    klogf("R8:  %#016X\n", state->r8);
-    klogf("R9:  %#016X\n", state->r9);
-    klogf("R10: %#016X\n", state->r10);
-    klogf("R11: %#016X\n", state->r11);
-    klogf("R12: %#016X\n", state->r12);
-    klogf("R13: %#016X\n", state->r13);
-    klogf("R14: %#016X\n", state->r14);
-    klogf("R15: %#016X\n", state->r15);
-    kpanic("Unhandled exception\n");
-    return state;
-}
-
 extern void x86_64_lidt(struct XDTR *idtr);
 void
-x86_64_load_idt(void)
+idt_init(void)
 {
     extern uintptr_t __isr_stubs[22];
     for(int i = 0; i < 22; i++)
     {
         uintptr_t base = __isr_stubs[i];
-        s_idtd[i] = (struct InterruptTrapGate){
+        s_idtd[i] = (interrupt_gate_t){
             .base_0_15 = (base & 0xFFFF),
             .segment_selector = 0x8,
             .ist = 0,
@@ -71,7 +32,14 @@ x86_64_load_idt(void)
             .base_32_63 = (base >> 32) & 0xFFFFFFFF,
             .resv = 0
         };
-        klogf("INT %2i : %#016X (%016X)\n", i, base, s_idtd[i]);
     }
-    x86_64_lidt(&s_idtr);
+}
+
+void
+idt_setup(processor_t *proc)
+{
+    proc->_idtr = (struct XDTR){
+        .length = sizeof(s_idtd) - 1,
+        .address = (uintptr_t)s_idtd
+    };
 }
diff --git a/arch/x86_64/int_handler.c b/arch/x86_64/int_handler.c
new file mode 100644
index 0000000..3674d1c
--- /dev/null
+++ b/arch/x86_64/int_handler.c
@@ -0,0 +1,52 @@
+#include "arch/x86_64/idt.h"
+#include "arch/processor.h"
+#include "print.h"
+#include "jove.h"
+#include "assert.h"
+#include <stddef.h>
+
+static int_handler_t s_handlers[48];
+
+int_state_t*
+irq_handle(int_state_t *state)
+{
+    if(__isr_num < 48) {
+        if(s_handlers[__isr_num] != NULL) {
+            return s_handlers[__isr_num](state);
+        }
+    }
+
+    klogf("Interrupt %i\nerror code %#016X\n", __isr_num, __isr_err);
+    int_state_print(state);
+    kpanic("Unhandled exception\n");
+    return state;
+}
+
+void 
+int_handler_set(uint8_t i, int_handler_t handler)
+{
+    assert(i < 48);
+    s_handlers[i] = handler;
+}
+
+int_handler_t 
+int_handler_get(uint8_t i)
+{
+    assert(i < 48);
+    return s_handlers[i];
+}
+
+void 
+int_state_print(int_state_t *state)
+{
+    if(!state) return;
+    klogf("IP:  %016p\n", state->ip);
+    klogf("AX:  %016p BX:  %016p\n", state->ax, state->bx);
+    klogf("CX:  %016p DX:  %016p\n", state->cx, state->dx);
+    klogf("SI:  %016p DI:  %016p\n", state->si, state->di);
+    klogf("SP:  %016p BP:  %016p\n", state->sp, state->bp);
+    klogf("R8:  %016p R9:  %016p\n", state->r8, state->r9);
+    klogf("R10: %016p R11: %016p\n", state->r10, state->r11);
+    klogf("R12: %016p R13: %016p\n", state->r12, state->r13);
+    klogf("R14: %016p R15: %016p\n", state->r14, state->r15);
+}
diff --git a/arch/x86_64/interrupt.h b/arch/x86_64/interrupt.h
deleted file mode 100644
index 9ae63f9..0000000
--- a/arch/x86_64/interrupt.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef JOVE_ARCH_INTERRUPT_H
-#define JOVE_ARCH_INTERRUPT_H 1
-
-#include "cpu.h"
-
-/**Register a handler for a specified interrupt code.
- * @param code interrupt to handle.
- * @param handler to call.*/
-void int_set_handler(unsigned char code, struct Registers *(*handler)(struct Registers*));
-
-#endif
diff --git a/arch/x86_64/kexec.c b/arch/x86_64/kexec.c
new file mode 100644
index 0000000..406e8e7
--- /dev/null
+++ b/arch/x86_64/kexec.c
@@ -0,0 +1,50 @@
+#include "tasking.h"
+#include "memory.h"
+#include "string.h"
+#include "arch/cpu.h"
+
+#define UMODE_STACK_TOP (USERLAND_MEMORY_LIMIT)
+#define UMODE_STACKW PAGE_SIZE
+
+static void*
+s_umode_stack(void)
+{
+    uintptr_t top = UMODE_STACK_TOP;
+    uintptr_t bottom = top - (UMODE_STACKW - 1);
+
+    vm_ensure(bottom, top, (page_flags_t) {
+        .present = true,
+        .writeable = true,
+        .useraccess = true,
+        .executable = false
+            });
+    return (void*)top;
+}
+
+static inline void*
+s_stack_push(void *sp, void *data, size_t len)
+{
+    sp = (void*)((uintptr_t)sp - len);
+    memcpy(sp, data, len);
+    return sp;
+}
+
+void
+kexec(void *ip, int kargc, char **kargv, int kenvc, char **kenvp)
+{
+    /* Allocate a page for the user stack. */
+    void *sp = s_umode_stack();
+    
+    intmax_t argc = kargc;
+    sp = s_stack_push(sp, &argc, sizeof(intmax_t));
+
+    /* TODO: Proper argv, envp*/
+    sp = s_stack_push(sp, &kargv, sizeof(char**));
+    
+    intmax_t envc = kenvc;
+    sp = s_stack_push(sp, &envc, sizeof(intmax_t));
+
+    sp = s_stack_push(sp, &kenvp, sizeof(char**));
+
+    umode_enter(ip, sp);
+}
diff --git a/arch/x86_64/msr.c b/arch/x86_64/msr.c
new file mode 100644
index 0000000..1891126
--- /dev/null
+++ b/arch/x86_64/msr.c
@@ -0,0 +1,67 @@
+#include "arch/x86_64/msr.h"
+
+void
+msr_write(uint32_t msr, uint64_t v)
+{
+    __asm__ volatile("wrmsr":: "a"(v), "d"(v >> 32), "c"(msr));
+}
+
+uint64_t
+msr_read(uint32_t msr)
+{
+    uint32_t lo, hi;
+    __asm__ volatile("rdmsr": "=a"(lo), "=d"(hi): "c"(msr));
+    uint64_t v = hi;
+    v = (v << 32) | lo;
+    return v;
+}
+
+void 
+msr_efer_write(msr_efer_t v)
+{
+    msr_write(MSR_EFER, *((uintptr_t*)&v));
+}
+
+msr_efer_t 
+msr_efer_read(void)
+{
+    uint64_t rawv = msr_read(MSR_EFER);
+    return *((msr_efer_t*)&rawv);
+}
+
+void 
+msr_star_write(msr_star_t v)
+{
+    msr_write(MSR_STAR, *((uintptr_t*)&v));
+}
+
+msr_star_t 
+msr_star_read(void)
+{
+    uint64_t rawv = msr_read(MSR_STAR);
+    return *((msr_star_t*)&rawv);
+}
+
+void 
+msr_lstar_write(msr_lstar_t v)
+{
+    msr_write(MSR_LSTAR, v);
+}
+
+msr_lstar_t 
+msr_lstar_read(void)
+{
+    return msr_read(MSR_LSTAR);
+}
+
+void
+msr_gsbase_write(uintptr_t gsbase)
+{
+    msr_write(MSR_GSBASE, gsbase);
+}
+
+uintptr_t
+msr_gsbase_read(void)
+{
+    return msr_read(MSR_GSBASE);
+}
diff --git a/arch/x86_64/page.c b/arch/x86_64/page.c
new file mode 100644
index 0000000..d816f66
--- /dev/null
+++ b/arch/x86_64/page.c
@@ -0,0 +1,173 @@
+#include "arch/x86_64/page.h"
+#include "klib/rbtree.h"
+#include "arch/processor.h"
+#include "string.h"
+#include "jove.h"
+#include "memory.h"
+#include "print.h"
+
+extern void *_kernel_end;
+
+struct PageDirectoryListEntry {
+    struct PageDirectoryListEntry *next;
+    page_directory_t pd;
+};
+
+struct PageStateCache {
+    page_directory_t *pd;
+    size_t pmli[4];
+    pmle_t *pml[4];
+} s_state_cache;
+
+const uintptr_t USERLAND_MEMORY_BASE = KiB;
+const uintptr_t USERLAND_MEMORY_LIMIT = 0x00007FFFFFFFFFFFULL;
+
+const uintptr_t PHYSMAP_MEMORY_BASE = 0xFFFF800000000000ULL;
+const uintptr_t PHYSMAP_MEMORY_LIMIT = PHYSMAP_MEMORY_BASE + (1 * GiB);
+
+const uintptr_t KERNEL_MEMORY_BASE = 0xFFFF800000000000ULL;
+const uintptr_t KERNEL_MEMORY_LIMIT = 0xFFFFFFFFFFFFFFFFULL;
+
+static size_t
+s_paging_pmli(size_t l, uintptr_t addr)
+{
+    size_t shift = (PAGE_SHIFT + (9 * l));
+    return (addr & (0x1FFULL << shift)) >> shift;
+}
+
+static pmle_t*
+s_paging_fetch_table(pmle_t *pml, size_t l, uintptr_t virt)
+{
+    size_t pmli = s_paging_pmli(l, virt);
+    if(s_state_cache.pmli[l] == pmli && s_state_cache.pml[l] != NULL)
+        return s_state_cache.pml[l];
+
+    pmle_t entry = pml[pmli];
+    bool entry_new = false;
+    if(!entry.p) {
+        entry_new = true;
+        entry.value = pm_alloc(1);
+        entry.p = 1;
+        entry.rw = 1;
+        entry.us = 1;
+        pml[pmli] = entry;
+    }
+    pmle_t *table = (pmle_t*)(pm_tovirt(entry.paddr << PAGE_SHIFT));
+    if(entry_new) memset(table, 0, PAGE_SIZE);
+
+    s_state_cache.pmli[l] = pmli;
+    s_state_cache.pml[l] = table;
+    return table;
+}
+
+static void
+s_paging_cache_tables(page_directory_t *pd, uintptr_t virt)
+{
+    pmle_t *pml4 = pd->pml;
+    if(s_state_cache.pd != pd) memset(&s_state_cache, 0, sizeof(s_state_cache));
+
+    pmle_t *pml3 = s_paging_fetch_table(pml4, 3, virt);
+    pmle_t *pml2 = s_paging_fetch_table(pml3, 2, virt);
+    pmle_t *pml1 = s_paging_fetch_table(pml2, 1, virt);
+}
+
+static pmle_t*
+s_paging_get_table(pmle_t *pt, size_t l, uintptr_t virt)
+{
+    if(pt == NULL) return NULL;
+    size_t pmli = s_paging_pmli(l, virt);
+    if(s_state_cache.pmli[l] == pmli && s_state_cache.pml[l] != NULL)
+        return s_state_cache.pml[l];
+
+    pmle_t entry = pt[pmli];
+    if(!entry.p) return NULL;
+    return (pmle_t*)(pm_tovirt(entry.paddr << PAGE_SHIFT));
+}
+
+page_mapping_t
+vm_pd_mapping_get(page_directory_t *pd, uintptr_t addr)
+{
+    spinlock_acquire(pd->lock);
+    page_mapping_t mapping = { 0 };
+    
+    pmle_t *pml4 = pd->pml;
+    if(s_state_cache.pd != pd) memset(&s_state_cache, 0, sizeof(s_state_cache));
+
+    pmle_t *pml3 = s_paging_get_table(pml4, 3, addr);
+    pmle_t *pml2 = s_paging_get_table(pml3, 2, addr);
+    pmle_t *pml1 = s_paging_get_table(pml2, 1, addr);
+    if(pml1 == NULL) goto release_return;
+
+    size_t pml1i = s_paging_pmli(0, addr);
+    pmle_t pml1e = pml1[pml1i];
+
+    mapping = (page_mapping_t) {
+        .phys = (pml1e.paddr << PAGE_SHIFT) & ~PAGE_MASK,
+        .pf = {
+            .present = pml1e.p,
+            .writeable = pml1e.rw,
+            .useraccess = pml1e.us,
+            .executable = !pml1e.xd
+        }
+    };
+release_return:
+    spinlock_release(pd->lock);
+    return mapping;
+}
+
+page_mapping_t vm_mapping_get(uintptr_t addr)
+{ return vm_pd_mapping_get(pd_current(), addr); }
+
+void
+mem_set_mapping_as(page_directory_t *pd, page_mapping_t mapping, uintptr_t virt)
+{
+    spinlock_acquire(pd->lock);
+    s_paging_cache_tables(pd, virt);
+    pmle_t *pml1 = s_state_cache.pml[0];
+    size_t pml1i = s_paging_pmli(0, virt);
+
+    pml1[pml1i] = (pmle_t) {
+        .p = mapping.pf.present,
+        .rw = mapping.pf.writeable,
+        .us = mapping.pf.useraccess,
+        .xd = !mapping.pf.executable,
+        .paddr = mapping.phys >> PAGE_SHIFT
+    };
+    spinlock_release(pd->lock);
+}
+
+void mem_set_mapping(page_mapping_t mapping, uintptr_t virt)
+{ mem_set_mapping_as(pd_current(), mapping, virt); }
+
+void
+vm_pd_ensure(page_directory_t *pd, uintptr_t from, uintptr_t to, page_flags_t flg)
+{
+    spinlock_acquire(pd->lock);
+    from &= ~(PAGE_SIZE - 1);
+    to += (to % PAGE_SIZE > 0 ? (PAGE_SIZE - (to % PAGE_SIZE)) : 0);
+
+    if(to < from) to = from;
+    size_t pages = (to - from) >> PAGE_SHIFT;
+    if(pages == 0) pages = 1;
+    for(size_t i = 0; i < pages; i++) {
+        uintptr_t waddr = from + (i << PAGE_SHIFT);
+        s_paging_cache_tables(pd, waddr);
+        pmle_t *pml1 = s_state_cache.pml[1];
+        size_t pml1i = s_paging_pmli(0, waddr);
+
+        if(!pml1[pml1i].p) {
+            physptr_t phys = pm_alloc(1);
+            pml1[pml1i] = (pmle_t) {
+                .p = flg.present,
+                .rw = flg.writeable,
+                .us = flg.useraccess,
+                .xd = !flg.executable,
+                .paddr = phys >> PAGE_SHIFT
+            };
+        }
+    }
+    spinlock_release(pd->lock);
+}
+
+void vm_ensure(uintptr_t from, uintptr_t to, page_flags_t flg)
+{ vm_pd_ensure(pd_current(), from, to, flg); }
diff --git a/arch/x86_64/paging.h b/arch/x86_64/page.h
index 28dfad2..28dfad2 100644
--- a/arch/x86_64/paging.h
+++ b/arch/x86_64/page.h
diff --git a/arch/x86_64/pagedirectory.c b/arch/x86_64/pagedirectory.c
new file mode 100644
index 0000000..cdfffeb
--- /dev/null
+++ b/arch/x86_64/pagedirectory.c
@@ -0,0 +1,138 @@
+#include "arch/page.h"
+#include "arch/processor.h"
+#include "klib/rbtree.h"
+#include "boot.h"
+#include "memory.h"
+#include "string.h"
+#include "print.h"
+
+PAGEALIGN static uint64_t s_kernel_initial_pml4[512];
+PAGEALIGN static uint64_t s_kernel_initial_pml3[2][512];
+PAGEALIGN static uint64_t s_kernel_initial_pml2[2][512];
+PAGEALIGN static uint64_t s_kernel_initial_pml1[2][512];
+static page_directory_t s_kernel_initial_pd;
+
+static rbtree_t s_page_directories;
+static intmax_t s_next_pdid = 0;
+
+page_directory_t*
+pd_new()
+{
+    page_directory_t newpd = {
+        .id = s_next_pdid++,
+        .phys = pm_alloc(1),
+    };
+    newpd.pml = (void*)pm_tovirt(newpd.phys);
+    for(size_t i = 256; i < 512; i++) {
+        pmle_t *kpe = &(s_kernel_initial_pd.pml)[i];
+        pmle_t *ppe = &(newpd.pml)[i];
+        *ppe = *kpe;
+    }
+
+    return rbtree_insert(&s_page_directories, newpd.id, &newpd);
+}
+
+static void
+s_pd_dup_pml(pmle_t *src, pmle_t *dest, size_t l, size_t i)
+{
+    pmle_t srce = src[i];
+    if(!srce.p) return;
+
+    dest[i] = srce;
+    dest[i].paddr = pm_alloc(1);
+    pmle_t dste = dest[i];
+
+    pmle_t *srct = (pmle_t*)pm_tovirt(srce.paddr << PAGE_SHIFT);
+    pmle_t *dstt = (pmle_t*)pm_tovirt(dste.paddr << PAGE_SHIFT);
+
+    if(l == 0) {
+        memcpy(dstt, srct, PAGE_SIZE);
+        return;
+    }
+
+    for(i = 0; i < 512; i++) {
+        dstt[i] = srct[i];
+        if(!srct[i].p) continue;
+        s_pd_dup_pml(srct, dstt, l - 1, i);
+    }
+}
+
+page_directory_t*
+pd_dup(page_directory_t *pd)
+{
+    page_directory_t *newpd = pd_new();
+    for(size_t i = 0; i < 256; i++) {
+        s_pd_dup_pml(pd->pml, newpd->pml, 3, i);
+    }
+    return newpd;
+}
+
+page_directory_t*
+pd_get(pdid_t pdid)
+{
+    return rbtree_find(&s_page_directories, pdid);
+}
+
+void 
+pd_switch(page_directory_t *pd)
+{
+    processor_t *pc = processor_current();
+    if(pc->pd == pd) return;
+    pc->pd = pd;
+    __asm__ volatile("movq %0, %%cr3":: "r"(pd->phys));
+}
+
+void
+vm_setup_early(void)
+{
+    memset(s_kernel_initial_pml4, 0, PAGE_SIZE);
+    memset(s_kernel_initial_pml3, 0, 2 * PAGE_SIZE);
+    memset(s_kernel_initial_pml2, 0, 2 * PAGE_SIZE);
+    memset(s_kernel_initial_pml1, 0, PAGE_SIZE);
+    s_kernel_initial_pd = (page_directory_t){
+        .phys = vm_tophys_koff((uintptr_t)&s_kernel_initial_pml4),
+        .pml = (pmle_t*)&s_kernel_initial_pml4,
+        .id = s_next_pdid++
+    };
+    processor_current()->pd = &s_kernel_initial_pd;
+
+    /* Map first few GiBs */
+    s_kernel_initial_pml4[256] =
+        vm_tophys_koff((uintptr_t)&s_kernel_initial_pml3[0])
+        | 3;
+    s_kernel_initial_pml3[0][0] =
+        vm_tophys_koff((uintptr_t)&s_kernel_initial_pml2[0])
+        | 3;
+    for(int i = 0; i < 512; i++) {
+        s_kernel_initial_pml2[0][i] = (i * (PAGE_SIZE * 512)) | 0x80 | 3;
+    }
+
+    size_t kernel_pml3e = (_kernel_virtual_base >> (30)) % 512;
+    size_t kernel_pml2e = (_kernel_virtual_base >> (21)) % 512;
+    size_t kernel_npages = ((((uintptr_t)&_kernel_end) - _kernel_virtual_base) >> 12) + 1;
+    klogf("Kernel has %i pages\n", kernel_npages);
+
+    /* Map kernel pages */
+    s_kernel_initial_pml4[511] =
+        vm_tophys_koff((uintptr_t)&s_kernel_initial_pml3[1]) | 3;
+    s_kernel_initial_pml3[1][kernel_pml3e] =
+        vm_tophys_koff((uintptr_t)&s_kernel_initial_pml2[1]) | 3;
+    s_kernel_initial_pml2[1][kernel_pml2e] =
+        vm_tophys_koff((uintptr_t)&s_kernel_initial_pml1[0]) | 3;
+    for(size_t i = 0; i < kernel_npages; i++) {
+        s_kernel_initial_pml1[0][i] = (i * PAGE_SIZE) + boot_kernel_physical_address | 3;
+    }
+ 
+    extern int_state_t *_pagefault_handler(int_state_t*);
+    int_handler_set(14, _pagefault_handler);
+    __asm__ volatile("mov %0, %%cr3":: "r"(s_kernel_initial_pd.phys));
+}
+
+void
+vm_setup(void)
+{
+    rbtree_new(&s_page_directories, page_directory_t);
+
+    processor_t *proc = processor_current();
+    pd_switch(pd_new());
+}
diff --git a/arch/x86_64/pagefault.c b/arch/x86_64/pagefault.c
new file mode 100644
index 0000000..5bba20b
--- /dev/null
+++ b/arch/x86_64/pagefault.c
@@ -0,0 +1,39 @@
+#include "arch/x86_64/idt.h"
+#include "arch/processor.h"
+#include "memory.h"
+#include "print.h"
+#include "jove.h"
+
+#include <stdbool.h>
+
+int_state_t*
+_pagefault_handler(int_state_t *state)
+{
+    extern uint64_t __isr_err;
+
+    uintptr_t fault_addr = 0;
+    __asm__ volatile("movq %%cr2, %0": "=r"(fault_addr));
+
+    if(fault_addr < USERLAND_MEMORY_LIMIT) {
+        // Check if there is an entry in the exception return table.
+        processor_t *proc = processor_current();
+        if(proc->ert_i > 0) {
+            state->ip = (uintptr_t)_exrtab_pop();
+            return state;
+        }
+    }
+
+    bool present = __isr_err & 1;
+    bool write = __isr_err & 2;
+    bool user = __isr_err & 4;
+
+    klogf("Page fault at %016X\n", fault_addr);
+    klogf("%s %s from a %s address\n", 
+            user ? "user" : "kernel",
+            write ? "wrote" : "read",
+            present ? "present" : "non-present");
+
+    int_state_print(state);
+    kpanic("Unhandled page fault\n");
+    return state;
+}
diff --git a/arch/x86_64/paging.c b/arch/x86_64/paging.c
deleted file mode 100644
index dc27ca2..0000000
--- a/arch/x86_64/paging.c
+++ /dev/null
@@ -1,257 +0,0 @@
-#include "paging.h"
-#include "interrupt.h"
-#include "io/log.h"
-#include "lib/jove.h"
-#include "lib/string.h"
-#include "lib/hashtable.h"
-#include "mem/memory.h"
-#include "boot/boot.h"
-
-extern void *_kernel_end;
-
-PAGEALIGN static uint64_t s_kernel_initial_pml4[512];
-PAGEALIGN static uint64_t s_kernel_initial_pml3[2][512];
-PAGEALIGN static uint64_t s_kernel_initial_pml2[2][512];
-PAGEALIGN static uint64_t s_kernel_initial_pml1[2][512];
-static intmax_t s_next_pdid = 0;
-static page_directory_t s_kernel_initial_pd;
-
-page_directory_t *current_page_directory;
-
-struct PageStateCache {
-    page_directory_t *pd;
-    size_t pmli[4];
-    pmle_t *pml[4];
-} s_state_cache;
-
-physptr_t
-mem_linear_tophys_koffset(uintptr_t virt)
-{
-    return (virt - boot_kernel_virtual_base) + boot_kernel_physical_address;
-}
-
-uintptr_t
-mem_phys_tolinear(physptr_t phys)
-{
-    return (uintptr_t)(phys + 0xFFFF800000000000ULL);
-}
-
-static size_t
-s_paging_pmli(size_t l, uintptr_t addr)
-{
-    size_t shift = (12 + (9 * l));
-    return (addr & (0x1FFULL << shift)) >> shift;
-}
-
-static pmle_t*
-s_paging_fetch_table(pmle_t *pml, size_t l, uintptr_t virt)
-{
-    size_t pmli = s_paging_pmli(l, virt);
-    if(s_state_cache.pmli[l] == pmli && s_state_cache.pml[l] != NULL)
-        return s_state_cache.pml[l];
-
-    pmle_t entry = pml[pmli];
-    bool entry_new = false;
-    if(!entry.p) {
-        entry_new = true;
-        entry.value = mem_phys_alloc(1);
-        entry.p = 1;
-        entry.rw = 1;
-        entry.us = 1;
-        pml[pmli] = entry;
-    }
-    pmle_t *table = (pmle_t*)(mem_phys_tolinear(entry.paddr << 12));
-    if(entry_new) memset(table, 0, PAGE_SIZE);
-
-    s_state_cache.pmli[l] = pmli;
-    s_state_cache.pml[l] = table;
-    return table;
-}
-
-static void
-s_paging_cache_tables(page_directory_t *pd, uintptr_t virt)
-{
-    pmle_t *pml4 = (pmle_t*)pd->virt;
-    if(s_state_cache.pd != pd) memset(&s_state_cache, 0, sizeof(s_state_cache));
-
-    pmle_t *pml3 = s_paging_fetch_table(pml4, 3, virt);
-    pmle_t *pml2 = s_paging_fetch_table(pml3, 2, virt);
-    pmle_t *pml1 = s_paging_fetch_table(pml2, 1, virt);
-}
-
-static pmle_t*
-s_paging_get_table(pmle_t *pt, size_t l, uintptr_t virt)
-{
-    if(pt == NULL) return NULL;
-    size_t pmli = s_paging_pmli(l, virt);
-    if(s_state_cache.pmli[l] == pmli && s_state_cache.pml[l] != NULL)
-        return s_state_cache.pml[l];
-
-    pmle_t entry = pt[pmli];
-    if(!entry.p) return NULL;
-    return (pmle_t*)(mem_phys_tolinear(entry.paddr << 12));
-}
-
-page_mapping_t
-mem_get_mapping_as(page_directory_t *pd, uintptr_t addr)
-{
-    spinlock_acquire(pd->lock);
-    page_mapping_t mapping = { 0 };
-    
-    pmle_t *pml4 = (pmle_t*)pd->virt;
-    if(s_state_cache.pd != pd) memset(&s_state_cache, 0, sizeof(s_state_cache));
-
-    pmle_t *pml3 = s_paging_get_table(pml4, 3, addr);
-    pmle_t *pml2 = s_paging_get_table(pml3, 2, addr);
-    pmle_t *pml1 = s_paging_get_table(pml2, 1, addr);
-    if(pml1 == NULL) goto release_return;
-
-    size_t pml1i = s_paging_pmli(0, addr);
-    pmle_t pml1e = pml1[pml1i];
-
-    mapping = (page_mapping_t) {
-        .phys = (pml1e.paddr << 12) & ~PAGE_MASK,
-        .pf = {
-            .present = pml1e.p,
-            .writeable = pml1e.rw,
-            .useraccess = pml1e.us,
-            .executable = !pml1e.xd
-        }
-    };
-release_return:
-    spinlock_release(pd->lock);
-    return mapping;
-}
-
-page_mapping_t mem_get_mapping(uintptr_t addr)
-{ return mem_get_mapping_as(current_page_directory, addr); }
-
-
-bool
-mem_check_ptr(const void *ptr)
-{
-    return mem_get_mapping((uintptr_t)ptr).pf.present != 0;
-}
-
-void
-mem_set_mapping_as(page_directory_t *pd, page_mapping_t mapping, uintptr_t virt)
-{
-    spinlock_acquire(pd->lock);
-    s_paging_cache_tables(pd, virt);
-    pmle_t *pml1 = s_state_cache.pml[0];
-    size_t pml1i = s_paging_pmli(0, virt);
-
-    pml1[pml1i] = (pmle_t) {
-        .p = mapping.pf.present,
-        .rw = mapping.pf.writeable,
-        .us = mapping.pf.useraccess,
-        .xd = !mapping.pf.executable,
-        .paddr = mapping.phys >> 12
-    };
-    spinlock_release(pd->lock);
-}
-
-void mem_set_mapping(page_mapping_t mapping, uintptr_t virt)
-{ mem_set_mapping_as(current_page_directory, mapping, virt); }
-
-void
-mem_ensure_range_as(page_directory_t *pd, uintptr_t from, uintptr_t to, page_flags_t flg)
-{
-    spinlock_acquire(pd->lock);
-    from &= ~(PAGE_SIZE - 1);
-
-    if(to < from) to = from;
-    size_t pages = (to - from) >> 12;
-    if(pages == 0) pages = 1;
-    for(size_t i = 0; i < pages; i++) {
-        uintptr_t waddr = from + (i << 12);
-        s_paging_cache_tables(pd, waddr);
-        pmle_t *pml1 = s_state_cache.pml[1];
-        size_t pml1i = s_paging_pmli(0, waddr);
-
-        if(!pml1[pml1i].p) {
-            physptr_t phys = mem_phys_alloc(1);
-            pml1[pml1i] = (pmle_t) {
-                .p = flg.present,
-                .rw = flg.writeable,
-                .us = flg.useraccess,
-                .xd = !flg.executable,
-                .paddr = phys >> 12
-            };
-        }
-    }
-    spinlock_release(pd->lock);
-}
-
-void mem_ensure_range(uintptr_t from, uintptr_t to, page_flags_t flg)
-{ mem_ensure_range_as(current_page_directory, from, to, flg); }
-
-struct Registers*
-s_pagefault_handler(struct Registers *state)
-{
-    extern uint64_t __isr_err;
-    
-    uintptr_t fault_addr = 0;
-    __asm__ volatile("movq %%cr2, %0": "=r"(fault_addr));
-
-    bool present = __isr_err & 1;
-    bool write = __isr_err & 2;
-    bool user = __isr_err & 4;
-    bool fetch = __isr_err & 16;
-
-    klogf("Page fault at %016X\n", fault_addr);
-    klogf("%s %s from a %s address\n", 
-            user ? "user" : "kernel",
-            write ? "wrote" : "read",
-            present ? "present" : "non-present");
-
-    kpanic("Unhandled page fault at %016X\n", state->ip);
-    return state;
-}
-
-void
-mem_paging_setup(void)
-{
-    memset(s_kernel_initial_pml4, 0, PAGE_SIZE);
-    memset(s_kernel_initial_pml3, 0, 2 * PAGE_SIZE);
-    memset(s_kernel_initial_pml2, 0, 2 * PAGE_SIZE);
-    memset(s_kernel_initial_pml1, 0, PAGE_SIZE);
-    s_kernel_initial_pd = (page_directory_t){
-        .phys = mem_linear_tophys_koffset((uintptr_t)&s_kernel_initial_pml4),
-        .virt = (union PageEntry*)&s_kernel_initial_pml4,
-        .ref = 1,
-        .id = s_next_pdid++
-    };
-    current_page_directory = &s_kernel_initial_pd;
-
-    /* Map first few GiBs */
-    s_kernel_initial_pml4[256] =
-        mem_linear_tophys_koffset((uintptr_t)&s_kernel_initial_pml3[0])
-        | 3;
-    s_kernel_initial_pml3[0][0] =
-        mem_linear_tophys_koffset((uintptr_t)&s_kernel_initial_pml2[0])
-        | 3;
-    for(int i = 0; i < 512; i++) {
-        s_kernel_initial_pml2[0][i] = (i * (PAGE_SIZE * 512)) | 0x80 | 3;
-    }
-
-    size_t kernel_pml4e = (boot_kernel_virtual_base >> (39));
-    size_t kernel_pml3e = (boot_kernel_virtual_base >> (30)) % 512;
-    size_t kernel_pml2e = (boot_kernel_virtual_base >> (21)) % 512;
-    size_t kernel_npages = ((((uintptr_t)&_kernel_end) - boot_kernel_virtual_base) >> 12) + 1;
-    klogf("Kernel has %i pages\n", kernel_npages);
-
-    /* Map kernel pages */
-    s_kernel_initial_pml4[511] =
-        mem_linear_tophys_koffset((uintptr_t)&s_kernel_initial_pml3[1]) | 3;
-    s_kernel_initial_pml3[1][kernel_pml3e] =
-        mem_linear_tophys_koffset((uintptr_t)&s_kernel_initial_pml2[1]) | 3;
-    s_kernel_initial_pml2[1][kernel_pml2e] =
-        mem_linear_tophys_koffset((uintptr_t)&s_kernel_initial_pml1[0]) | 3;
-    for(int i = 0; i < kernel_npages; i++) {
-        s_kernel_initial_pml1[0][i] = (i * PAGE_SIZE) + boot_kernel_physical_address | 3;
-    }
-    
-    int_set_handler(14, s_pagefault_handler);
-    __asm__ volatile("mov %0, %%cr3":: "r"(s_kernel_initial_pd.phys));
-}
diff --git a/arch/x86_64/processor.c b/arch/x86_64/processor.c
new file mode 100644
index 0000000..44d437a
--- /dev/null
+++ b/arch/x86_64/processor.c
@@ -0,0 +1,40 @@
+#include "arch/processor.h"
+#include "arch/cpu.h"
+#include "arch/x86_64/msr.h"
+
+processor_t s_processors[PROCESSOR_MAX];
+processor_t *proc_bsp = &s_processors[0];
+
+extern void x86_64_lgdt(struct XDTR *gdtr);
+extern void x86_64_flush_tss(void);
+extern void x86_64_lidt(struct XDTR *idtr);
+
+extern void gdt_setup(processor_t*);
+extern void tss_setup(processor_t*);
+extern void idt_setup(processor_t*);
+
+void 
+processor_setup(processor_t *proc)
+{
+    gdt_setup(proc);
+    tss_setup(proc);
+    idt_setup(proc);
+
+    x86_64_lgdt(&proc->_gdtr);
+    x86_64_lidt(&proc->_idtr);
+    x86_64_flush_tss();
+
+    msr_gsbase_write((uintptr_t)proc);
+}
+
+processor_t*
+processor_list(void)
+{
+    return s_processors;
+}
+
+processor_t*
+processor_current(void)
+{
+    return (processor_t*)msr_gsbase_read();
+}
diff --git a/arch/x86_64/restore.S b/arch/x86_64/restore.S
new file mode 100644
index 0000000..f4aa939
--- /dev/null
+++ b/arch/x86_64/restore.S
@@ -0,0 +1,20 @@
+.global _arch_context_restore
+.type _arch_context_restore @function
+_arch_context_restore:
+    movq %rdi, %rsp
+    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
+    retq
diff --git a/arch/x86_64/savestate.S b/arch/x86_64/savestate.S
deleted file mode 100644
index c89933b..0000000
--- a/arch/x86_64/savestate.S
+++ /dev/null
@@ -1,39 +0,0 @@
-.global saveregs
-.type saveregs @function
-saveregs:
-    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
-    retq
-
-.global loadregs
-.type loadregs @function
-loadregs:
-    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
-
diff --git a/arch/x86_64/serial.c b/arch/x86_64/serial.c
deleted file mode 100644
index 1b49e3f..0000000
--- a/arch/x86_64/serial.c
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "serial.h"
-#include "uart.h"
-#include "io/log.h"
-
-static struct LogDevice s_serial_logdev =
-    { .out = serial_out, .chain = NULL };
-
-bool serial_supported = true;
-
-void
-serial_setup(void)
-{
-    /* Disable interrupts. */
-    poutb(SERIAL_UART_COM_IER(SERIAL_UART_COM1), 0x0);
-    /* Enable DLAB. */
-    poutb(SERIAL_UART_COM_LCR(SERIAL_UART_COM1), 0x80);
-    /* Set divisor to 3 (38400 baud)*/
-    poutb(SERIAL_UART_COM_DLAB_DLL(SERIAL_UART_COM1), 3);
-    poutb(SERIAL_UART_COM_DLAB_DLH(SERIAL_UART_COM1), 0);
-    /* Set flags for LCR (8 bits, no parity, one stop)*/
-    poutb(SERIAL_UART_COM_LCR(SERIAL_UART_COM1), 1 | 2);
-    /* Enable & clear FIFO, 14-byte threshold */
-    poutb(SERIAL_UART_COM_FCR(SERIAL_UART_COM1), 1 | 2 | 4 | 0xC0);
-    /* Enable interrupts, set RTS/DSR. */
-    poutb(SERIAL_UART_COM_MCR(SERIAL_UART_COM1), 1 | 2 | 8);
-    /* Set loopback mode for testing. */
-    poutb(SERIAL_UART_COM_MCR(SERIAL_UART_COM1), 2 | 4 | 8 | 0x10);
-    /* Test serial output. */
-    poutb(SERIAL_UART_COM1, 0xAE);
-    if(pinb(SERIAL_UART_COM1) != 0xAE) {
-        serial_supported = false;
-        return;
-    }
-
-    /* Serial is not faulty.
-     * No loopback, enable output 1 & 2.*/
-    poutb(SERIAL_UART_COM_MCR(SERIAL_UART_COM1), 1 | 2 | 4 | 8);
-
-    klog_newdev(&s_serial_logdev);
-}
-
-static ALWAYS_INLINE bool
-serial_transmit_empty(uint16_t com)
-{
-    return pinb(SERIAL_UART_COM_LSR(com) & 0x20);
-}
-
-static inline void
-serial_outb(uint16_t com, uint8_t b)
-{
-    if(b == '\n') serial_outb(com, '\r');
-    while(!serial_transmit_empty(SERIAL_UART_COM1));
-    poutb(com, b);
-}
-
-void
-serial_out(const char *s, size_t len)
-{
-    if(!serial_supported) return;
-    for(; len > 0; len--)
-        serial_outb(SERIAL_UART_COM1, *(s++));
-}
diff --git a/arch/x86_64/serial.h b/arch/x86_64/serial.h
deleted file mode 100644
index ecb896d..0000000
--- a/arch/x86_64/serial.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef JOVE_KERNEL_ARCH_x86_64_SERIAL_H
-#define JOVE_KERNEL_ARCH_x86_64_SERIAL_H 1
-
-#include <stdbool.h>
-#include <stddef.h>
-
-#define SERIAL_UART_COM1 0x3F8
-#define SERIAL_UART_COM2 0x2F8
-
-#define SERIAL_UART_COM_THR(COM)        COM
-#define SERIAL_UART_COM_RBR(COM)        COM
-#define SERIAL_UART_COM_DLAB_DLL(COM)   COM
-#define SERIAL_UART_COM_IER(COM)        (COM + 1)
-#define SERIAL_UART_COM_DLAB_DLH(COM)   (COM + 1)
-#define SERIAL_UART_COM_IIR(COM)        (COM + 2)
-#define SERIAL_UART_COM_FCR(COM)        (COM + 2)
-#define SERIAL_UART_COM_LCR(COM)        (COM + 3)
-#define SERIAL_UART_COM_MCR(COM)        (COM + 4)
-#define SERIAL_UART_COM_LSR(COM)        (COM + 5)
-#define SERIAL_UART_COM_MSR(COM)        (COM + 6)
-#define SERIAL_UART_COM_SR(COM)         (COM + 7)
-
-extern bool serial_supported;
-
-void serial_out(const char *s, size_t len);
-
-#endif
diff --git a/arch/x86_64/syscall.c b/arch/x86_64/syscall.c
deleted file mode 100644
index 0398f11..0000000
--- a/arch/x86_64/syscall.c
+++ /dev/null
@@ -1 +0,0 @@
-#include "usr/umode.h"
diff --git a/arch/x86_64/syscall_entry.c b/arch/x86_64/syscall_entry.c
new file mode 100644
index 0000000..56dedce
--- /dev/null
+++ b/arch/x86_64/syscall_entry.c
@@ -0,0 +1,25 @@
+#include "arch/processor.h"
+#include "syscall/handler.h"
+
+__attribute__((naked))
+void _syscall_entry()
+{
+    __asm__ volatile(" \
+    pushq %%r11; \
+    pushq %%rcx; \
+    swapgs; \
+    movq %%gs:%c[tcb], %%rax; \
+    movq %%rsp, %c[sp](%%rax); \
+    movq %c[ksp](%%rax), %%rsp; \
+    pushq %c[sp](%%rax); \
+    callq _syscall_handler; \
+    swapgs; \
+    popq %%rsp; \
+    popq %%rcx; \
+    popq %%r11; \
+    sysretq; \
+    "
+    :: [tcb] "i"(offsetof(processor_t, tcb)),
+       [sp] "i"(offsetof(tcb_t, sp)),
+       [ksp] "i"(offsetof(tcb_t, ksp)));
+}
diff --git a/arch/x86_64/syscall_setup.S b/arch/x86_64/syscall_setup.S
deleted file mode 100644
index 4f5c6f0..0000000
--- a/arch/x86_64/syscall_setup.S
+++ /dev/null
@@ -1,41 +0,0 @@
-.extern _kernel_task_sp
-.extern syscall_handler
-
-.global syscall_entry
-.type syscall_entry @function
-syscall_entry:
-    swapgs
-    movq %rsp, %rax
-    movq _kernel_task_bp, %rsp
-    pushq %rax
-    pushq %rbp
-    pushq %rcx
-    pushq %r11
-    call syscall_handler
-    popq %r11
-    popq %rcx
-    popq %rbp
-    popq %rsp
-    swapgs
-    sysretq
-
-.global syscall_setup_syscall
-.type syscall_setup_syscall @function
-syscall_setup_syscall:
-    movq $0xc0000080, %rcx
-    rdmsr
-    or $1, %eax
-    wrmsr
-    
-    movq $0xc0000081, %rcx
-    rdmsr
-    mov  $0x001b0008, %edx
-    wrmsr
-
-    movq $0xc0000082, %rcx
-    leaq syscall_entry, %rdx
-    mov %edx, %eax
-    shr $32, %rdx
-    wrmsr
-
-    retq
diff --git a/arch/x86_64/tables.c b/arch/x86_64/tables.c
deleted file mode 100644
index f530089..0000000
--- a/arch/x86_64/tables.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "tables.h"
-
-void
-arch_tables_setup(void)
-{
-    x86_64_load_gdt();
-    x86_64_load_idt();
-}
diff --git a/arch/x86_64/tables.h b/arch/x86_64/tables.h
deleted file mode 100644
index e160c66..0000000
--- a/arch/x86_64/tables.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef JOVE_ARCH_X86_64_TABLES_H
-#define JOVE_ARCH_X86_64_TABLES_H 1
-
-#include <stdint.h>
-
-#define CD_SEGMENT_TYPE_ACCESSED 1
-#define CD_SEGMENT_TYPE_WRITEABLE 2
-#define CD_SEGMENT_TYPE_DATA_EXPAND_DOWN 4
-#define CD_SEGMENT_TYPE_CODE_CONFORMING 4
-#define CD_SEGMENT_TYPE_CODE 8
-
-#define S_SEGMENT_TYPE_LDT 2
-#define S_SEGMENT_TYPE_TSS_AVAIL 9
-#define S_SEGMENT_TYPE_TSS_BUSY 11
-#define S_SEGMENT_TYPE_CALLGATE 12
-#define S_SEGMENT_TYPE_INT_GATE 14
-#define S_SEGMENT_TYPE_TRAP_GATE 15
-
-struct SegmentDescriptor
-{
-    uint16_t limit_0_15;    /* Segment limit. */
-    uint16_t base_0_15;     /* Segment base. */
-    uint8_t base_16_23; 
-    uint8_t type : 4;       /* Segment type. */
-    uint8_t s : 1;          /* Descriptor type (0 = system, 1 = code/data)*/
-    uint8_t dpl : 2;        /* Descriptor privilege level. */
-    uint8_t p : 1; ;        /* Present. */
-    uint8_t limit_16_19 : 4;
-    uint8_t avl : 1;        /* Available for use by system software. */
-    uint8_t l : 1;          /* 64-bit segment (Ext). */
-    uint8_t d_b : 1;        /* Default operation size (0 = 16-bit, 1 = 32-bit)*/
-    uint8_t g : 1;          /* Granularity. */
-    uint8_t base_24_31;
-}__attribute__((packed));
-
-struct InterruptTrapGate
-{
-    uint16_t base_0_15;
-    uint16_t segment_selector;
-    uint8_t ist : 3;
-    uint8_t zero_0 : 5;
-    uint8_t type : 4;
-    uint8_t zero_1 : 1;
-    uint8_t dpl : 2;
-    uint8_t p : 1;
-    uint16_t base_16_31;
-    uint32_t base_32_63;
-    uint32_t resv;
-}__attribute__((packed));
-
-struct XDTR /* Generic table descriptor struct */
-{
-    uint16_t length;
-    uint64_t address;
-}__attribute__((packed));
-
-void x86_64_load_gdt(void);
-void x86_64_load_idt(void);
-
-#endif
diff --git a/arch/x86_64/tasking.c b/arch/x86_64/tasking.c
deleted file mode 100644
index 9b29330..0000000
--- a/arch/x86_64/tasking.c
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "usr/tasking.h"
-#include "mem/memory.h"
-#include "io/log.h"
-#include "lib/hashtable.h"
-#include "lib/string.h"
-#include "paging.h"
-#include "cpu.h"
-#include "tss.h"
-
-struct TaskBody {
-    struct Task base;
-    struct Registers state;
-};
-
-struct Task *task_current;
-uintptr_t _kernel_task_bp = 0;
-
-//static struct SLinkedList s_tasks;
-static struct HashTable s_tasks;
-
-static struct SlabCache s_task_cache;
-static struct SlabCache s_kbp_cache;
-
-static tid_t s_task_id_next = 1;
-
-static size_t
-s_task_hash_func(const void* tid, size_t _)
-{
-    return (tid_t)tid;
-}
-
-void
-tasking_setup(void)
-{
-    hashtable_new(&s_tasks, struct TaskBody*, tid_t);
-    s_tasks.hash_function = s_task_hash_func;
- 
-    mem_slabcache_new(&s_task_cache, "tasks", sizeof(struct TaskBody));
-    mem_slabcache_new(&s_kbp_cache, "kernel stacks", 4096);
-
-    struct TaskBody *ktask = mem_slab_alloc(&s_task_cache);
-    *ktask = (struct TaskBody){
-        .base.id = s_task_id_next++,
-        .base.kbp = ((uintptr_t)mem_slab_alloc(&s_kbp_cache)) + 0xFF0,
-        .base.perm = (size_t)-1,
-        .base.pd = current_page_directory
-    };
-    hashtable_insert(&s_tasks, 0, ktask);
-
-    task_current = (struct Task*)ktask;
-    tss_set_rsp(0, task_current->kbp);
-    _kernel_task_bp = task_current->kbp;
-}
-
-struct Task*
-task_new(struct Task *parent)
-{
-    struct TaskBody *new = mem_slab_alloc(&s_task_cache);
-    memcpy(new, parent, sizeof(struct TaskBody));
-    new->base.id = s_task_id_next++;
-    
-    uintptr_t ksp_base = (uintptr_t)mem_slab_alloc(&s_kbp_cache);
-    new->base.kbp = ksp_base + 0xFFF;
-    new->base.perm = parent->perm;
-
-    hashtable_insert(&s_tasks, (void*)new->base.id, new);
-    return (struct Task*)new;
-}
-
-struct Task*
-task_get(tid_t id)
-{
-    struct Task **task = hashtable_get(&s_tasks, (void*)id, struct Task*);
-    if(task == NULL) return NULL;
-    return *task;
-}
-
-void
-task_free(struct Task *task)
-{
-    struct TaskBody *body = (struct TaskBody*)task;
-    task->pd->ref--;
-    task->kbp -= 0xFFF;
-    mem_slab_free(&s_kbp_cache, (void*)(task->kbp));
-    klogf("Need impl for task_free\n");
-}
diff --git a/arch/x86_64/tcb_prepare.c b/arch/x86_64/tcb_prepare.c
new file mode 100644
index 0000000..238d70d
--- /dev/null
+++ b/arch/x86_64/tcb_prepare.c
@@ -0,0 +1,9 @@
+#include "tasking.h"
+
+void 
+tcb_prepare(tcb_t *tcb, void *ip)
+{
+    uintptr_t state[15] = { 0 };
+    tcb_stack_push(tcb, &ip, sizeof(void*));
+    tcb_stack_push(tcb, state, sizeof(state));
+}
diff --git a/arch/x86_64/tcb_switch.c b/arch/x86_64/tcb_switch.c
new file mode 100644
index 0000000..bc8808d
--- /dev/null
+++ b/arch/x86_64/tcb_switch.c
@@ -0,0 +1,18 @@
+#include "tasking.h"
+#include "arch/processor.h"
+
+extern void _arch_context_restore(uintptr_t rsp);
+
+void
+tcb_switch(tcb_t *to)
+{
+    processor_t *proc = processor_current();
+    tcb_t *from = proc->tcb;
+
+    proc->tcb = to;
+    if(from != to) {
+        pd_switch(to->pd);
+    }
+    tss_set_rsp(&proc->_tss, 0, to->ksp);
+    _arch_context_restore(to->ksp);
+}
diff --git a/arch/x86_64/tss.h b/arch/x86_64/tss.h
deleted file mode 100644
index dcdd01c..0000000
--- a/arch/x86_64/tss.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef JOVE_ARCH_x86_64_TSS_H
-#define JOVE_ARCH_x86_64_TSS_H 1
-
-#include <stddef.h>
-#include <stdint.h>
-
-struct TSS
-{
-    uint32_t resv0;
-    uint32_t rsp[3][2];
-    uint64_t resv1;
-    uint32_t ist[8][2];
-    uint64_t resv2;
-    uint16_t resv3;
-    uint16_t iobp;
-};
-
-void tss_set_rsp(uint8_t dpl, uintptr_t rsp);
-
-#endif
diff --git a/arch/x86_64/uart.h b/arch/x86_64/uart.h
deleted file mode 100644
index 8386eb7..0000000
--- a/arch/x86_64/uart.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef JOVE_KERNEL_ARCH_x86_64_UART_H
-#define JOVE_KERNEL_ARCH_x86_64_UART_H 1
-
-#include "lib/jove.h"
-#include <stdint.h>
-
-ALWAYS_INLINE uint8_t pinb(uint16_t port)
-{
-    uint8_t v;
-    __asm__ volatile("inb %1, %0": "=a"(v): "Nd"(port));
-    return v;
-}
-
-ALWAYS_INLINE void poutb(uint16_t port, uint8_t b)
-{
-    __asm__ volatile("outb %0, %1":: "a"(b), "Nd"(port));
-}
-
-#endif
diff --git a/arch/x86_64/umode_enter.S b/arch/x86_64/umode_enter.S
deleted file mode 100644
index 29aa4e3..0000000
--- a/arch/x86_64/umode_enter.S
+++ /dev/null
@@ -1,8 +0,0 @@
-.global umode_enter
-.type umode_enter @function
-umode_enter:
-    movq %rdi, %rcx
-    movq %rsi, %rsp
-    movq $0x0202, %r11
-    cli
-    sysretq
diff --git a/arch/x86_64/umode_enter.c b/arch/x86_64/umode_enter.c
new file mode 100644
index 0000000..3c7fa18
--- /dev/null
+++ b/arch/x86_64/umode_enter.c
@@ -0,0 +1,17 @@
+#include "tasking.h"
+
+__attribute__((noreturn))
+void
+umode_enter(void *ip, void *sp)
+{
+    __asm__ volatile("mov %0, %%rsp; \
+                      push %%rcx; \
+                      mov %1, %%rcx; \
+                      mov $0x202, %%r11; \
+                      cli; \
+                      swapgs; \
+                      sysretq"::
+                      "r"(sp), "r"(ip):
+                      "memory");
+    for(;;);
+}
diff --git a/arch/x86_64/vm_tophys.c b/arch/x86_64/vm_tophys.c
new file mode 100644
index 0000000..2b16880
--- /dev/null
+++ b/arch/x86_64/vm_tophys.c
@@ -0,0 +1,23 @@
+#include "memory.h"
+#include "boot.h"
+
+uintptr_t
+pm_tovirt(physptr_t phys)
+{
+    if(phys < (1 * GiB))
+        return (uintptr_t)(phys + PHYSMAP_MEMORY_BASE);
+    kpanic("Missing impl for physical addresses > 1GiB (%#016X)\n",
+            phys);
+}
+
+physptr_t
+vm_tophys(uintptr_t virt)
+{
+    return vm_mapping_get(virt).phys;
+}
+
+physptr_t
+vm_tophys_koff(uintptr_t virt)
+{
+    return (virt - _kernel_virtual_base) + boot_kernel_physical_address;
+}