diff --git a/.vscode/settings.json b/.vscode/settings.json
index e99af7d..5b13e7a 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -10,6 +10,6 @@
         "**/*.d": true,
     },
 
-    "C_Cpp.default.includePath": ["src/kernel/include"],
-    "C_Cpp.default.cStandard": "c2x",
+    "C_Cpp.default.includePath": ["src/kernel/include", "sysroot/usr/include"],
+    "C_Cpp.default.cStandard": "c17",
 }
\ No newline at end of file
diff --git a/src/kernel/boot/TEMP-test_scheduler.c b/src/kernel/boot/TEMP-test_scheduler.c
index 135f861..480750a 100644
--- a/src/kernel/boot/TEMP-test_scheduler.c
+++ b/src/kernel/boot/TEMP-test_scheduler.c
@@ -9,42 +9,51 @@ extern gfx_context kernel_fb;
 int *position = (void *)0x20000;
 
 void thread1() {
-    int a = 1;
-    gfx_context *ctx = framebuffer_make_subcontext(&kernel_fb, 700, 300, 100, 100);
-    while(1) {
-        putCharacter(term_fb, *position, *position, RGB(255,255,0), RGB(0,0,0), '0'+(a++%10));
-        flip(term_fb);
-        draw_line(ctx, 0, 100, 50, ((a-1)%100), RGB(0,0,0));
-        draw_line(ctx, 0, 100, 50, (a%100), RGB(255,0,0));
-        flip(ctx);
-        sched_yield();
-    }
+  int a = 1;
+  gfx_context *ctx =
+      framebuffer_make_subcontext(&kernel_fb, 700, 300, 100, 100);
+  while(1) {
+    putCharacter(term_fb,
+        *position, *position,
+        RGB(255,255,0), RGB(0,0,0),
+        '0'+(a++%10)
+    );
+    flip(term_fb);
+    draw_line(ctx, 0, 100, 50, ((a-1)%100), RGB(0,0,0));
+    draw_line(ctx, 0, 100, 50, (a%100), RGB(255,0,0));
+    flip(ctx);
+    sched_yield();
+  }
 }
 
 void thread2() {
-    int a = 0;
-    while(1) {
-        putCharacter(term_fb, *position, *position, RGB(0,255,255), RGB(0,0,0), 'A'+(a++%10));
-        flip(term_fb);
-        sched_yield();
-    }
+  int a = 0;
+  while(1) {
+    putCharacter(term_fb,
+        *position, *position,
+        RGB(0,255,255), RGB(0,0,0),
+        'A'+(a++%10)
+    );
+    flip(term_fb);
+    sched_yield();
+  }
 }
 
 
 void TEMP_test_scheduler() {
-    struct process *th1 = new_process(thread1);
-    scheduler_insert(th1);
+  struct process *th1 = new_process(thread1);
+  scheduler_insert(th1);
 
-    struct process *th2 = new_process(thread2);
-    scheduler_insert(th2);
+  struct process *th2 = new_process(thread2);
+  scheduler_insert(th2);
 
-    uint64_t p1 = pmm_alloc();
-    uint64_t p2 = pmm_alloc();
-    vmm_set_page(th1->P4, 0x20000, p1, PAGE_PRESENT);
-    vmm_set_page(th2->P4, 0x20000, p2, PAGE_PRESENT);
-    // Write different values into the position variable for the two processes
-    int *a = P2V(p1);
-    *a = 20;
-    a = P2V(p2);
-    *a = 70;
+  uint64_t p1 = pmm_alloc();
+  uint64_t p2 = pmm_alloc();
+  vmm_set_page(th1->P4, 0x20000, p1, PAGE_PRESENT);
+  vmm_set_page(th2->P4, 0x20000, p2, PAGE_PRESENT);
+  // Write different values into the position variable for the two processes
+  int *a = P2V(p1);
+  *a = 20;
+  a = P2V(p2);
+  *a = 70;
 }
\ No newline at end of file
diff --git a/src/kernel/boot/kmain.c b/src/kernel/boot/kmain.c
index a2c7217..11cdd37 100644
--- a/src/kernel/boot/kmain.c
+++ b/src/kernel/boot/kmain.c
@@ -15,45 +15,46 @@ struct kernel_boot_data_st kernel_boot_data;
 
 registers *kbd_handler(registers *r)
 {
-    while(inb(0x64) & 0x2);
-    uint8_t scancode = inb(0x60);
-    debug("Keyboard: %x\n", scancode);
-    irq_ack();
-    return r;
+  while(inb(0x64) & 0x2);
+  uint8_t scancode = inb(0x60);
+  debug("Keyboard: %x\n", scancode);
+  irq_ack();
+  return r;
 }
 
 void kmain(uint64_t multiboot_magic, void *multiboot_data) {
-    musl_init();
-    debug_info("Started kernel\n");
-    multiboot_init(multiboot_magic, P2V(multiboot_data));
-    debug_info("Kernel loaded with command line: \"%s\" by <%s>\n",
-        kernel_boot_data.commandline,
-        kernel_boot_data.bootloader);
+  musl_init();
+  debug_info("Started kernel\n");
+  multiboot_init(multiboot_magic, P2V(multiboot_data));
+  debug_info("Kernel loaded with command line: \"%s\" by <%s>\n",
+      kernel_boot_data.commandline,
+      kernel_boot_data.bootloader
+  );
 
-    early_cpu_init();
-    debug_info("Set up boot CPU\n");
-    memory_init();
-    debug_info("Set up memory management\n");
+  early_cpu_init();
+  debug_info("Set up boot CPU\n");
+  memory_init();
+  debug_info("Set up memory management\n");
 
-    terminal_init();
-    debug_info("Set up debug terminal\n");
+  terminal_init();
+  debug_info("Set up debug terminal\n");
 
-    cpu_init();
+  cpu_init();
 
-    __asm__("sti");
+  __asm__("sti");
 
-    debug_info("Boot complete\n");
+  debug_info("Boot complete\n");
 
 
-    bind_interrupt(IRQ_INTERRUPT(IRQ_PS2_KBD), kbd_handler);
-    irq_unmask(IRQ_PS2_KBD);
-    TEMP_test_scheduler();
+  bind_interrupt(IRQ_INTERRUPT(IRQ_PS2_KBD), kbd_handler);
+  irq_unmask(IRQ_PS2_KBD);
+  TEMP_test_scheduler();
 
 
-    start_scheduler();
+  start_scheduler();
 
-    PANIC("End of kernel function!");
+  PANIC("End of kernel function!");
 
-    debug_info("Broke out of panic");
-    for(;;);
+  debug_info("Broke out of panic");
+  for(;;);
 }
\ No newline at end of file
diff --git a/src/kernel/boot/multiboot.c b/src/kernel/boot/multiboot.c
index bae5e9a..0e1ee11 100644
--- a/src/kernel/boot/multiboot.c
+++ b/src/kernel/boot/multiboot.c
@@ -8,106 +8,119 @@
 // https://www.gnu.org/software/grub/manual/multiboot2/multiboot.html
 
 struct taglist {
-    uint32_t total_size;
-    uint32_t reserved;
+  uint32_t total_size;
+  uint32_t reserved;
 }__attribute__((packed));
 
 struct tag {
-    uint32_t type;
-    uint32_t size;
-    uint8_t data[];
+  uint32_t type;
+  uint32_t size;
+  uint8_t data[];
 }__attribute__((packed));
 
 struct mmap_entry {
-    uint64_t base;
-    uint64_t len;
-    uint32_t type;
-    uint32_t reserved;
+  uint64_t base;
+  uint64_t len;
+  uint32_t type;
+  uint32_t reserved;
 }__attribute__((packed));
 
 struct mmap {
-    uint32_t entry_size;
-    uint32_t entry_version;
-    struct mmap_entry entries[];
+  uint32_t entry_size;
+  uint32_t entry_version;
+  struct mmap_entry entries[];
 }__attribute__((packed));
 
 static int parse_multiboot2(struct taglist *tags) {
-    struct mmap *mmap;
+  struct mmap *mmap;
 
-    struct tag *tag = incptr(tags, sizeof(struct taglist));
-    kernel_boot_data.mboot_tags = tag;
-    kernel_boot_data.tags_length = tags->total_size;
-    while(tag->type) {
-        switch(tag->type) {
-            case MBOOT2_TAG_BOOTLOADER:
-                kernel_boot_data.bootloader = (char *)tag->data;
-                break;
-            case MBOOT2_TAG_CMDLINE:
-                kernel_boot_data.commandline = (char *)tag->data;
-                break;
-            case MBOOT2_TAG_MMAP:
-                mmap = kernel_boot_data.mmap = (void *)tag->data;
-                kernel_boot_data.mmap_len = (tag->size - 8)/mmap->entry_size;
-                kernel_boot_data.mmap_size = (tag->size - 8);
-                break;
-            case MBOOT2_TAG_FBINFO:
-                kernel_boot_data.fbinfo = (void *)tag->data;
-                break;
-            case MBOOT2_TAG_OLD_RSDP:
-            case MBOOT2_TAG_NEW_RSDP:
-                kernel_boot_data.rsdp = (void *)tag->data;
-                break;
-        }
-
-        // Tags are 8 byte alligned, so make sure we look for the next one in the right place
-        int padded_size = tag->size + ((tag->size % 8)?(8-(tag->size%8)):0);
-        tag = incptr(tag, padded_size);
+  struct tag *tag = incptr(tags, sizeof(struct taglist));
+  kernel_boot_data.mboot_tags = tag;
+  kernel_boot_data.tags_length = tags->total_size;
+  while(tag->type) {
+    switch(tag->type) {
+      case MBOOT2_TAG_BOOTLOADER:
+        kernel_boot_data.bootloader = (char *)tag->data;
+        break;
+      case MBOOT2_TAG_CMDLINE:
+        kernel_boot_data.commandline = (char *)tag->data;
+        break;
+      case MBOOT2_TAG_MMAP:
+        mmap = kernel_boot_data.mmap = (void *)tag->data;
+        kernel_boot_data.mmap_len = (tag->size - 8)/mmap->entry_size;
+        kernel_boot_data.mmap_size = (tag->size - 8);
+        break;
+      case MBOOT2_TAG_FBINFO:
+        kernel_boot_data.fbinfo = (void *)tag->data;
+        break;
+      case MBOOT2_TAG_OLD_RSDP:
+      case MBOOT2_TAG_NEW_RSDP:
+        kernel_boot_data.rsdp = (void *)tag->data;
+        break;
     }
-    return 0;
+
+    // Tags are 8 byte alligned, so make sure we look for the next one
+    // in the right place
+    int padded_size = tag->size + ((tag->size % 8)?(8-(tag->size%8)):0);
+    tag = incptr(tag, padded_size);
+  }
+  return 0;
 }
 
 int multiboot_init(uint64_t magic, void *mboot_info) {
-    if(magic == MBOOT2_REPLY) {
-        kernel_boot_data.multiboot_version = 2;
-        parse_multiboot2(mboot_info);
-    } else {
-        return 1;
-    }
+  if(magic == MBOOT2_REPLY) {
+    kernel_boot_data.multiboot_version = 2;
+    parse_multiboot2(mboot_info);
+  } else {
+    return 1;
+  }
 
-    return 0;
+  return 0;
 }
 
-int multiboot_get_memory_area(size_t index, uintptr_t *start, uintptr_t *end, uint32_t *type) {
-    if(index >= kernel_boot_data.mmap_len) return 1;
+int multiboot_get_memory_area(
+    size_t index,
+    uintptr_t *start,
+    uintptr_t *end,
+    uint32_t *type
+) {
+  if(index >= kernel_boot_data.mmap_len) return 1;
 
-    struct mmap *mmap = kernel_boot_data.mmap;
-    struct mmap_entry *entry = mmap->entries;
-    entry = incptr(entry, index*mmap->entry_size);
+  struct mmap *mmap = kernel_boot_data.mmap;
+  struct mmap_entry *entry = mmap->entries;
+  entry = incptr(entry, index*mmap->entry_size);
 
-    *start = entry->base;
-    *end = entry->base + entry->len;
-    *type = entry->type;
-    return 0;
+  *start = entry->base;
+  *end = entry->base + entry->len;
+  *type = entry->type;
+  return 0;
 }
 
 int multiboot_page_used(uintptr_t page) {
-    #define within_page(st, l) (((uintptr_t)st + l) > page && (uintptr_t)st < (page + PAGE_SIZE))
+  #define within_page(st, l) (((uintptr_t)st + l) > page && \
+      (uintptr_t)st < (page + PAGE_SIZE))
 
-    size_t fb_size = 0;
-    uintptr_t fb_start = 0;
-    if(kernel_boot_data.fbinfo) {
-        fb_start = kernel_boot_data.fbinfo->framebuffer_addr;
-        fb_size = kernel_boot_data.fbinfo->framebuffer_pitch*(kernel_boot_data.fbinfo->framebuffer_height + 1);
-    }
-    if(
-        within_page(kernel_boot_data.mboot_tags, kernel_boot_data.tags_length) ||
-        within_page(kernel_boot_data.bootloader, strlen(kernel_boot_data.bootloader)) ||
-        within_page(kernel_boot_data.commandline, strlen(kernel_boot_data.commandline)) ||
-        within_page(kernel_boot_data.mmap, kernel_boot_data.mmap_size) ||
-        within_page(fb_start, fb_size) ||
-        0
-    ) {
-        return 1;
-    }
-    return 0;
+  size_t fb_size = 0;
+  uintptr_t fb_start = 0;
+  if(kernel_boot_data.fbinfo) {
+    fb_start = kernel_boot_data.fbinfo->framebuffer_addr;
+    fb_size = kernel_boot_data.fbinfo->framebuffer_pitch *
+        (kernel_boot_data.fbinfo->framebuffer_height + 1);
+  }
+  if(
+    within_page(kernel_boot_data.mboot_tags,
+        kernel_boot_data.tags_length
+    ) ||
+    within_page(kernel_boot_data.bootloader,
+        strlen(kernel_boot_data.bootloader)
+    ) ||
+    within_page(kernel_boot_data.commandline,
+        strlen(kernel_boot_data.commandline)
+    ) ||
+    within_page(kernel_boot_data.mmap, kernel_boot_data.mmap_size) ||
+    within_page(fb_start, fb_size) ||
+  0) {
+      return 1;
+  }
+  return 0;
 }
\ No newline at end of file
diff --git a/src/kernel/cpu/acpi.c b/src/kernel/cpu/acpi.c
index 46389a7..05027f6 100644
--- a/src/kernel/cpu/acpi.c
+++ b/src/kernel/cpu/acpi.c
@@ -4,22 +4,23 @@
 #include <string.h>
 #include <debug.h>
 
-// ACPI Specification https://uefi.org/sites/default/files/resources/ACPI_6_3_final_Jan30.pdf
+// ACPI Specification:
+// https://uefi.org/sites/default/files/resources/ACPI_6_3_final_Jan30.pdf
 
 struct rsdp { // 5.2.5.3
-    char signature[8];
-    uint8_t checksum;
-    char OEMID[6];
-    uint8_t revision;
-    uint32_t rsdt_p;
-    uint8_t _[14]; // Fields for revision >= 2
+  char signature[8];
+  uint8_t checksum;
+  char OEMID[6];
+  uint8_t revision;
+  uint32_t rsdt_p;
+  uint8_t _[14]; // Fields for revision >= 2
 }__attribute__((packed));
 
 struct sdt {
-    char signature[4];
-    uint32_t length;
-    uint8_t _[28];
-    uint32_t data[];
+  char signature[4];
+  uint32_t length;
+  uint8_t _[28];
+  uint32_t data[];
 }__attribute__((packed));
 
 
@@ -29,83 +30,79 @@ struct sdt {
 #define MADT_TYPE_ISO 2
 
 struct madt_field {
-    uint8_t type;
-    uint8_t length;
-    union {
-        // Processor Local APIC (5.2.12.2)
-        struct {
-            uint8_t id;
-            uint8_t apic;
-            uint32_t flags;
-        }__attribute__((packed)) lapic;
-        // I/O APIC (5.2.12.3)
-        struct {
-            uint8_t id;
-            uint8_t reserved;
-            uint32_t address;
-            uint32_t base;
-        }__attribute__((packed)) ioapic;
-        // Interrupt source override (5.2.12.5)
-        struct {
-            uint8_t bus;
-            uint8_t source;
-            uint32_t interrupt;
-            uint16_t flags;
-        }__attribute__((packed)) iso;
-    };
+  uint8_t type;
+  uint8_t length;
+  union {
+    struct { // Processor Local APIC (5.2.12.2)
+      uint8_t id;
+      uint8_t apic;
+      uint32_t flags;
+    }__attribute__((packed)) lapic;
+    struct { // I/O APIC (5.2.12.3)
+      uint8_t id;
+      uint8_t reserved;
+      uint32_t address;
+      uint32_t base;
+    }__attribute__((packed)) ioapic;
+    struct { // Interrupt source override (5.2.12.5)
+      uint8_t bus;
+      uint8_t source;
+      uint32_t interrupt;
+      uint16_t flags;
+    }__attribute__((packed)) iso;
+  };
 }__attribute__((packed));
 
 struct madt_header {
-    uint32_t controllerAddress;
-    uint32_t flags;
-    struct madt_field fields[];
+  uint32_t controllerAddress;
+  uint32_t flags;
+  struct madt_field fields[];
 }__attribute__((packed));
 
 
 static void madt_parse(struct madt_header *madt, size_t length)
 {
-    int cpu_i=0;
-    for(
-        struct madt_field *f = madt->fields;
-        (size_t)f <= (size_t)madt + length;
-        f = incptr(f, f->length)
-    ) {
-        switch(f->type) {
-            case MADT_TYPE_LAPIC: {
-                struct cpu *cpu = P2V(pmm_alloc());
-                cpus[cpu_i++] = cpu;
-                cpu->id = f->lapic.id;
-                cpu->apic_id = f->lapic.apic;
-                cpu->flags = f->lapic.flags;
-                break;
-            }
-            case MADT_TYPE_IOAPIC: {
-                ioapic.id = f->ioapic.id;
-                ioapic.addr = f->ioapic.address;
-                ioapic.base = f->ioapic.base;
-                break;
-            }
-            case MADT_TYPE_ISO: {
-                irq_redirects[f->iso.source] = f->iso.interrupt;
-                break;
-            }
-            default:
-        }
+  int cpu_i=0;
+  for(struct madt_field *f = madt->fields;
+      (size_t)f <= (size_t)madt + length;
+      f = incptr(f, f->length)
+  ) {
+    switch(f->type) {
+      case MADT_TYPE_LAPIC: {
+        struct cpu *cpu = P2V(pmm_alloc());
+        cpus[cpu_i++] = cpu;
+        cpu->id = f->lapic.id;
+        cpu->apic_id = f->lapic.apic;
+        cpu->flags = f->lapic.flags;
+        break;
+      }
+      case MADT_TYPE_IOAPIC: {
+        ioapic.id = f->ioapic.id;
+        ioapic.addr = f->ioapic.address;
+        ioapic.base = f->ioapic.base;
+        break;
+      }
+      case MADT_TYPE_ISO: {
+        irq_redirects[f->iso.source] = f->iso.interrupt;
+        break;
+      }
+      default:
     }
+  }
 }
 
 void acpi_parse(void *_rsdp) {
-    struct rsdp *rsdp = _rsdp;
+  struct rsdp *rsdp = _rsdp;
 
-    struct sdt *rsdt = P2V(rsdp->rsdt_p);
-    int rsdt_entries = (rsdt->length - sizeof(struct sdt))/sizeof(uint32_t);
+  struct sdt *rsdt = P2V(rsdp->rsdt_p);
+  int rsdt_entries = (rsdt->length - sizeof(struct sdt))/sizeof(uint32_t);
 
-    for(int i = 0; i < rsdt_entries; i++) {
-        struct sdt *h = P2V(rsdt->data[i]);
-        if(h->length == 0) continue;
+  for(int i = 0; i < rsdt_entries; i++) {
+    struct sdt *h = P2V(rsdt->data[i]);
+    if(h->length == 0) continue;
 
-        if(!strncmp(h->signature, "APIC", 4)) { // 5.2.12
-            madt_parse(P2V(h->data), h->length - sizeof(struct sdt));
-        }
+    if(!strncmp(h->signature, "APIC", 4)) { // 5.2.12
+      madt_parse(P2V(h->data), h->length - sizeof(struct sdt));
     }
+  }
 }
\ No newline at end of file
diff --git a/src/kernel/cpu/apic.c b/src/kernel/cpu/apic.c
index 231faac..2f57551 100644
--- a/src/kernel/cpu/apic.c
+++ b/src/kernel/cpu/apic.c
@@ -14,82 +14,90 @@
 #define IOREDTBL(irq) (0x10 + (irq)*2)
 
 union iored {
-    struct {
-        uint8_t vector;
-        uint8_t flags;
-        uint8_t mask;
-        uint32_t reserved;
-        uint8_t target;
-    }__attribute__((packed));
-    struct {
-        uint32_t l;
-        uint32_t h;
-    }__attribute__((packed));
-    uint64_t val;
+  struct {
+    uint8_t vector;
+    uint8_t flags;
+    uint8_t mask;
+    uint32_t reserved;
+    uint8_t target;
+  }__attribute__((packed));
+  struct {
+    uint32_t l;
+    uint32_t h;
+  }__attribute__((packed));
+  uint64_t val;
 };
 
 static uint32_t ioapic_read(int reg) {
-    uint32_t volatile *ioregsel = P2V(ioapic.addr);
-    uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
-    *ioregsel = reg;
-    return *iowin;
+  uint32_t volatile *ioregsel = P2V(ioapic.addr);
+  uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
+  *ioregsel = reg;
+  return *iowin;
 }
 static void ioapic_write(int reg, uint32_t value) {
-    uint32_t volatile *ioregsel = P2V(ioapic.addr);
-    uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
-    *ioregsel = reg;
-    *iowin = value;
+  uint32_t volatile *ioregsel = P2V(ioapic.addr);
+  uint32_t volatile *iowin = P2V(ioapic.addr + 0x10);
+  *ioregsel = reg;
+  *iowin = value;
 }
 
 static uint64_t ioapic_read_redirection(int irq) {
-    union iored retval;
-    retval.l = ioapic_read(IOREDTBL(irq));
-    retval.h = ioapic_read(IOREDTBL(irq)+1);
-    return retval.val;
+  union iored retval;
+  retval.l = ioapic_read(IOREDTBL(irq));
+  retval.h = ioapic_read(IOREDTBL(irq)+1);
+  return retval.val;
 }
 static void ioapic_write_redirection(int irq, uint64_t val) {
-    union iored value;
-    value.val = val;
-    ioapic_write(IOREDTBL(irq), value.l);
-    ioapic_write(IOREDTBL(irq) + 1, value.h);
+  union iored value;
+  value.val = val;
+  ioapic_write(IOREDTBL(irq), value.l);
+  ioapic_write(IOREDTBL(irq) + 1, value.h);
 }
 
 void irq_ack() {
-    APIC_REG(APIC_EOI) = 0;
+  APIC_REG(APIC_EOI) = 0;
 }
 
 void irq_mask(int irq) {
-    union iored iored;
-    iored.val = ioapic_read_redirection(irq_redirects[irq]);
-    iored.mask |= 0x1;
-    ioapic_write_redirection(irq_redirects[irq], iored.val);
+  union iored iored;
+  iored.val = ioapic_read_redirection(irq_redirects[irq]);
+  iored.mask |= 0x1;
+  ioapic_write_redirection(irq_redirects[irq], iored.val);
 }
 void irq_unmask(int irq) {
-    union iored iored;
-    iored.val = ioapic_read_redirection(irq_redirects[irq]);
-    iored.mask &= ~0x1;
-    ioapic_write_redirection(irq_redirects[irq], iored.val);
+  union iored iored;
+  iored.val = ioapic_read_redirection(irq_redirects[irq]);
+  iored.mask &= ~0x1;
+  ioapic_write_redirection(irq_redirects[irq], iored.val);
 }
 
 void ioapic_init() {
-    // Map ioapic offset into kernel memory
-    vmm_set_page(kernel_P4, (uintptr_t)P2V(ioapic.addr), ioapic.addr, PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL);
+  // Map ioapic offset into kernel memory
+  vmm_set_page(kernel_P4,
+      (uintptr_t)P2V(ioapic.addr),
+      ioapic.addr,
+      PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL
+  );
 
-    union iored iored;
-    for(int i = 0; i < 24; i++) {
-        iored.val = ioapic_read_redirection(i);
-        iored.vector = IRQ_BASE+i;
-        iored.flags = 0x0;
-        iored.mask |= 1;
-        iored.target = 0x0;
-        ioapic_write_redirection(i, iored.val);
-    }
+  union iored iored;
+  for(int i = 0; i < 24; i++) {
+    iored.val = ioapic_read_redirection(i);
+    iored.vector = IRQ_BASE+i;
+    iored.flags = 0x0;
+    iored.mask |= 1;
+    iored.target = 0x0;
+    ioapic_write_redirection(i, iored.val);
+  }
 }
 
 void apic_init() {
-    // Map apic offset into kernel memory
-    vmm_set_page(kernel_P4, (uintptr_t)P2V(APIC_BASE), APIC_BASE, PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL);
+  // Map apic offset into kernel memory
+  vmm_set_page(kernel_P4,
+      (uintptr_t)P2V(APIC_BASE),
+      APIC_BASE,
+      PAGE_PRESENT | PAGE_WRITE | PAGE_GLOBAL
+  );
 
-    // Allow LAPIC to receive interrupts
-    APIC_REG(APIC_SPURIOUS) = APIC_REG(APIC_SPURIOUS) | 0x100 | IRQ_SPURIOUS;
+  // Allow LAPIC to receive interrupts
+  APIC_REG(APIC_SPURIOUS) = APIC_REG(APIC_SPURIOUS) | 0x100 | IRQ_SPURIOUS;
 }
\ No newline at end of file
diff --git a/src/kernel/cpu/cpu.c b/src/kernel/cpu/cpu.c
index 2c32cbf..d69be75 100644
--- a/src/kernel/cpu/cpu.c
+++ b/src/kernel/cpu/cpu.c
@@ -4,24 +4,26 @@
 
 struct cpu *cpus[16];
 struct ioapic ioapic = {0,0,0};
-uint8_t irq_redirects[MAX_IRQS] = \
-    {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
+uint8_t irq_redirects[MAX_IRQS] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23
+};
 
 #define PIC1_ADDR 0x20
 #define PIC2_ADDR 0xA0
 static void pic_disable() {
-    // Mask all interrupts
-    outb(PIC1_ADDR | 1, 0xFF);
-    outb(PIC2_ADDR | 1, 0xFF);
+  // Mask all interrupts
+  outb(PIC1_ADDR | 1, 0xFF);
+  outb(PIC2_ADDR | 1, 0xFF);
 }
 
 void early_cpu_init() {
-    interrupt_init();
+  interrupt_init();
 }
 
 void cpu_init() {
-    acpi_parse(kernel_boot_data.rsdp);
-    pic_disable();
-    apic_init();
-    ioapic_init();
+  acpi_parse(kernel_boot_data.rsdp);
+  pic_disable();
+  apic_init();
+  ioapic_init();
 }
\ No newline at end of file
diff --git a/src/kernel/cpu/gdt.c b/src/kernel/cpu/gdt.c
index ed50bdd..5c09f51 100644
--- a/src/kernel/cpu/gdt.c
+++ b/src/kernel/cpu/gdt.c
@@ -6,18 +6,18 @@
 #define GDT_LONG (1<<21)
 
 struct gdt {
-    uint32_t _;
-    uint32_t flags;
+  uint32_t _;
+  uint32_t flags;
 }__attribute__((packed));
 
 struct gdtp {
-    uint16_t len;
-    struct gdt *gdt;
+  uint16_t len;
+  struct gdt *gdt;
 }__attribute__((packed));
 
 struct gdt BootGDT[] = {
-    {0, 0},
-    {0, GDT_PRESENT | GDT_DPL(0) | GDT_CODE | GDT_LONG}
+  {0, 0},
+  {0, GDT_PRESENT | GDT_DPL(0) | GDT_CODE | GDT_LONG}
 };
 
 struct gdtp GDTp = {2*8-1, BootGDT};
\ No newline at end of file
diff --git a/src/kernel/cpu/interrupts.c b/src/kernel/cpu/interrupts.c
index 1a83dc8..25ac6a8 100644
--- a/src/kernel/cpu/interrupts.c
+++ b/src/kernel/cpu/interrupts.c
@@ -11,67 +11,70 @@
 #define NUM_INTERRUPTS 256
 
 struct idt {
-    uint16_t base_l;
-    uint16_t cs;
-    uint8_t ist;
-    uint8_t flags;
-    uint16_t base_m;
-    uint32_t base_h;
-    uint32_t _;
+  uint16_t base_l;
+  uint16_t cs;
+  uint8_t ist;
+  uint8_t flags;
+  uint16_t base_m;
+  uint32_t base_h;
+  uint32_t _;
 }__attribute__((packed)) idt[NUM_INTERRUPTS];
 
 struct {
-    uint16_t len;
-    struct idt *addr;
+  uint16_t len;
+  struct idt *addr;
 }__attribute__((packed)) idtr;
 
 extern uintptr_t isr_table[];
 int_handler_t int_handlers[NUM_INTERRUPTS];
 
 void interrupt_init() {
-    memset(idt, 0, sizeof(idt));
-    for(int i=0; i < NUM_INTERRUPTS; i++) {
-        idt[i].base_l = isr_table[i] & 0xFFFF;
-        idt[i].base_m = (isr_table[i] >> 16) & 0xFFFF;
-        idt[i].base_h = (isr_table[i] >> 32) & 0xFFFFFFFF;
-        idt[i].cs = 0x8;
-        idt[i].ist = 0;
-        idt[i].flags = IDT_PRESENT | IDT_DPL0 | IDT_INTERRUPT;
-    }
+  memset(idt, 0, sizeof(idt));
+  for(int i=0; i < NUM_INTERRUPTS; i++) {
+    idt[i].base_l = isr_table[i] & 0xFFFF;
+    idt[i].base_m = (isr_table[i] >> 16) & 0xFFFF;
+    idt[i].base_h = (isr_table[i] >> 32) & 0xFFFFFFFF;
+    idt[i].cs = 0x8;
+    idt[i].ist = 0;
+    idt[i].flags = IDT_PRESENT | IDT_DPL0 | IDT_INTERRUPT;
+  }
 
-    idtr.addr = idt;
-    idtr.len = sizeof(idt)-1;
-    load_idt(&idtr); // cpu/registers.S
+  idtr.addr = idt;
+  idtr.len = sizeof(idt)-1;
+  load_idt(&idtr); // cpu/registers.S
 }
 
 int_handler_t bind_interrupt(uint32_t num, int_handler_t fn) {
-    int_handler_t old = int_handlers[num];
-    int_handlers[num] = fn;
-    return old;
+  int_handler_t old = int_handlers[num];
+  int_handlers[num] = fn;
+  return old;
 }
 
 registers *int_handler(registers *r) {
-    if(int_handlers[r->int_no])
-        return int_handlers[r->int_no](r);
-    if(r->int_no < IRQ_BASE) {
-        debug_error("UNHANDLED EXCEPTION\n");
-        switch(r->int_no) {
-            case 14:
-                debug_error("Page fault\n");
-                break;
-            case 6:
-                debug_error("Invalid opcode\n");
-        }
-        debug_error("Interrupt number: %d, Error code: %d\n", r->int_no, r->err_code);
-        PANIC("Unhandled interrupt\n");
-    } else if(r->int_no < IRQ_BASE + MAX_IRQS) {
-        debug_error("UNHANDLED IRQ\n");
-        debug_error("IRQ: %d", r->int_no - IRQ_BASE);
-        PANIC("Unhandled IRQ\n");
-    } else {
-        debug_error("UNKNOWN INTERRUPT\n");
-        debug_error("Interrupt number: %d\n", r->int_no);
-        PANIC("Unknown interrupt\n");
+  if(int_handlers[r->int_no])
+      return int_handlers[r->int_no](r);
+  if(r->int_no < IRQ_BASE) {
+    debug_error("UNHANDLED EXCEPTION\n");
+    switch(r->int_no) {
+      case 14:
+        debug_error("Page fault\n");
+        break;
+      case 6:
+        debug_error("Invalid opcode\n");
     }
-    return r;
+    debug_error("Interrupt number: %d, Error code: %d\n",
+        r->int_no,
+        r->err_code
+    );
+    PANIC("Unhandled interrupt\n");
+  } else if(r->int_no < IRQ_BASE + MAX_IRQS) {
+    debug_error("UNHANDLED IRQ\n");
+    debug_error("IRQ: %d", r->int_no - IRQ_BASE);
+    PANIC("Unhandled IRQ\n");
+  } else {
+    debug_error("UNKNOWN INTERRUPT\n");
+    debug_error("Interrupt number: %d\n", r->int_no);
+    PANIC("Unknown interrupt\n");
+  }
+  return r;
 }
\ No newline at end of file
diff --git a/src/kernel/drivers/terminal/fbterm.c b/src/kernel/drivers/terminal/fbterm.c
index 8f84fba..4c8cf15 100644
--- a/src/kernel/drivers/terminal/fbterm.c
+++ b/src/kernel/drivers/terminal/fbterm.c
@@ -8,47 +8,63 @@ gfx_context *term_fb;
 static int setup = 0;
 
 void fbterm_movecursor(unsigned int cursor) {
-    (void) cursor;
+  (void) cursor;
 }
 
 void fbterm_flush(struct vga_cell *buffer) {
-    if(!setup) return;
-    int i = 0;
-    for(int row = 0; row < VGA_ROWS; row++) {
-        for(int col=0; col < VGA_COLS; col++) {
-            putCharacter(term_fb, col*8, row*16, 0xebdbb2, 0x282828, (char)buffer[i++].c);
-        }
+  if(!setup) return;
+  int i = 0;
+  for(int row = 0; row < VGA_ROWS; row++) {
+    for(int col=0; col < VGA_COLS; col++) {
+      putCharacter(term_fb,
+          col*8, row*16,
+          0xebdbb2, 0x282828,
+          (char)buffer[i++].c
+      );
     }
-    flip(term_fb);
+  }
+  flip(term_fb);
 }
 
 void fbterm_init(struct fbinfo *fbinfo) {
-    kernel_fb.width = fbinfo->framebuffer_width;
-    kernel_fb.height = fbinfo->framebuffer_height;
-    kernel_fb.bpp = fbinfo->framebuffer_bpp/8;
-    kernel_fb.pitch = fbinfo->framebuffer_pitch/kernel_fb.bpp;
-    kernel_fb.addr = P2V(fbinfo->framebuffer_addr);
-    kernel_fb.size = fbinfo->framebuffer_pitch * (kernel_fb.height);
-    kernel_fb.buffer = calloc(1, kernel_fb.size);
+  kernel_fb = (gfx_context){
+    .width = fbinfo->framebuffer_width,
+    .height = fbinfo->framebuffer_height,
+    .bpp = fbinfo->framebuffer_bpp/8,
+    .pitch = fbinfo->framebuffer_pitch/(fbinfo->framebuffer_bpp/8),
+    .addr = P2V(fbinfo->framebuffer_addr),
+    .size = fbinfo->framebuffer_pitch * (fbinfo->framebuffer_height),
+  };
+  kernel_fb.buffer = calloc(1, kernel_fb.size);
 
-    for(
-        uintptr_t p = (uintptr_t)kernel_fb.addr;
-        p < ((uintptr_t)kernel_fb.addr + kernel_fb.size);
-        p += PAGE_SIZE
-    ) {
-        vmm_set_page(kernel_P4, p, V2P(p), PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT);
-    }
+  for(uintptr_t p = (uintptr_t)kernel_fb.addr;
+      p < ((uintptr_t)kernel_fb.addr + kernel_fb.size);
+      p += PAGE_SIZE
+  ) {
+    vmm_set_page(kernel_P4,
+        p,
+        V2P(p),
+        PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT
+    );
+  }
 
-    draw_rect(&kernel_fb, 20, 20, 8*VGA_COLS+8, 16*VGA_ROWS+8, RGB(255, 0, 0));
-    flip(&kernel_fb);
-    term_fb = framebuffer_make_subcontext(&kernel_fb, 24, 24, 8*VGA_COLS, 16*VGA_ROWS);
-    flip(term_fb);
-    setup = 1;
+  draw_rect(&kernel_fb,
+      20, 20,
+      8*VGA_COLS+8, 16*VGA_ROWS+8,
+      RGB(255, 0, 0)
+  );
+  flip(&kernel_fb);
+  term_fb = framebuffer_make_subcontext(&kernel_fb,
+      24, 24,
+      8*VGA_COLS, 16*VGA_ROWS
+  );
+  flip(term_fb);
+  setup = 1;
 
-    draw_line(&kernel_fb, 750, 850, 120, 120, RGB(255,0,0));
-    draw_line(&kernel_fb, 750, 750, 120, 220, RGB(0,255,0));
-    draw_line(&kernel_fb, 750, 850, 120, 220, RGB(0,0,255));
-    draw_line(&kernel_fb, 750, 800, 120, 220, RGB(255,0,255));
-    draw_line(&kernel_fb, 750, 850, 120, 170, RGB(255,255,0));
-    flip(&kernel_fb);
+  draw_line(&kernel_fb, 750, 850, 120, 120, RGB(255,0,0));
+  draw_line(&kernel_fb, 750, 750, 120, 220, RGB(0,255,0));
+  draw_line(&kernel_fb, 750, 850, 120, 220, RGB(0,0,255));
+  draw_line(&kernel_fb, 750, 800, 120, 220, RGB(255,0,255));
+  draw_line(&kernel_fb, 750, 850, 120, 170, RGB(255,255,0));
+  flip(&kernel_fb);
 }
\ No newline at end of file
diff --git a/src/kernel/drivers/terminal/terminal.c b/src/kernel/drivers/terminal/terminal.c
index a953561..c47b414 100644
--- a/src/kernel/drivers/terminal/terminal.c
+++ b/src/kernel/drivers/terminal/terminal.c
@@ -20,86 +20,91 @@ uint8_t format = 0x7;
 static int terminal_type;
 
 static void scroll() {
-    while(cursor >= VGA_SIZE) {
-        memmove(buffer, &buffer[VGA_POS(1,0)], VGA_COLS*(VGA_ROWS-1)*sizeof(struct vga_cell));
-        memset(&buffer[VGA_POS(VGA_ROWS-1, 0)], 0, VGA_COLS*sizeof(struct vga_cell));
-        cursor -= VGA_COLS;
-    }
+  while(cursor >= VGA_SIZE) {
+    memmove(buffer,
+        &buffer[VGA_POS(1,0)],
+        VGA_COLS*(VGA_ROWS-1)*sizeof(struct vga_cell)
+    );
+    memset(&buffer[VGA_POS(VGA_ROWS-1, 0)],
+        0,
+        VGA_COLS*sizeof(struct vga_cell)
+    );
+    cursor -= VGA_COLS;
+  }
 }
 
 static void terminal_write(char c) {
-    int doflush = 0;
-    switch(c) {
-        case '\n':
-            cursor += VGA_COLS - VGA_COL(cursor);
-            doflush = 1;
-            break;
-        default:
-            buffer[cursor++] = (struct vga_cell){.c = c, .f = format};
-    }
-    scroll();
-    switch(terminal_type) {
-        case FRAMEBUFFER:
-            if(doflush)
-                fbterm_flush(buffer);
-            fbterm_movecursor(cursor);
-            break;
-        case EGA_TEXT:
-            if(doflush)
-                vga_flush(buffer);
-            vga_movecursor(cursor);
-            break;
-    }
+  int doflush = 0;
+  switch(c) {
+    case '\n':
+      cursor += VGA_COLS - VGA_COL(cursor);
+      doflush = 1;
+      break;
+    default:
+      buffer[cursor++] = (struct vga_cell){.c = c, .f = format};
+  }
+  scroll();
+  switch(terminal_type) {
+    case FRAMEBUFFER:
+      if(doflush)
+        fbterm_flush(buffer);
+      fbterm_movecursor(cursor);
+      break;
+    case EGA_TEXT:
+      if(doflush)
+        vga_flush(buffer);
+      vga_movecursor(cursor);
+      break;
+  }
 }
 
 static void terminal_putsn(char *s, size_t n) {
-    while(n--)
-        terminal_write(*s++);
+  while(n--)
+    terminal_write(*s++);
 }
 
 long k_ioctl(long fd, long cmd, long arg3, long, long, long) {
-    if(fd == 1 && cmd == 0x5413) {
-        struct {
-            unsigned short ws_row;
-            unsigned short ws_col;
-            unsigned short ws_xp;
-            unsigned short ws_yp;
-        } *wsz = (void *)arg3;
-        wsz->ws_row = 24;
-        wsz->ws_col = 80;
-        return 0;
-    }
-    long retval = -1;
-    PANIC("Unknown IOCTL request: fd: %d, command: %x\n", fd, cmd);
-    return retval;
+  if(fd == 1 && cmd == 0x5413) {
+    struct {
+      unsigned short ws_row;
+      unsigned short ws_col;
+      unsigned short ws_xp;
+      unsigned short ws_yp;
+    } *wsz = (void *)arg3;
+    wsz->ws_row = 24;
+    wsz->ws_col = 80;
+    return 0;
+  }
+  long retval = -1;
+  PANIC("Unknown IOCTL request: fd: %d, command: %x\n", fd, cmd);
+  return retval;
 }
 
 long k_writev(long fd, long iov, long iovcnt, long, long, long) {
-    if(fd == 1)
-    {
-        size_t len = 0;
-        struct iovec *v = (void *) iov;
-        for(int i = 0; i < iovcnt; i++) {
-            terminal_putsn(v[i].iov_base, v[i].iov_len);
-            len += v[i].iov_len;
-        }
-        return len;
+  if(fd == 1) {
+    size_t len = 0;
+    struct iovec *v = (void *) iov;
+    for(int i = 0; i < iovcnt; i++) {
+      terminal_putsn(v[i].iov_base, v[i].iov_len);
+      len += v[i].iov_len;
     }
-    long retval = 0;
-    PANIC("Unknown writev request: fd: %d\n", fd);
-    return retval;
+    return len;
+  }
+  long retval = 0;
+  PANIC("Unknown writev request: fd: %d\n", fd);
+  return retval;
 }
 
 void terminal_init() {
-    struct fbinfo *fbinfo = kernel_boot_data.fbinfo;
-    terminal_type = fbinfo->framebuffer_type;
+  struct fbinfo *fbinfo = kernel_boot_data.fbinfo;
+  terminal_type = fbinfo->framebuffer_type;
 
-    switch(terminal_type) {
-        case FRAMEBUFFER:
-            fbterm_init(fbinfo);
-            break;
-        case EGA_TEXT:
-            vga_init(fbinfo);
-            break;
-    }
+  switch(terminal_type) {
+    case FRAMEBUFFER:
+      fbterm_init(fbinfo);
+      break;
+    case EGA_TEXT:
+      vga_init(fbinfo);
+      break;
+  }
 }
\ No newline at end of file
diff --git a/src/kernel/drivers/terminal/vga.c b/src/kernel/drivers/terminal/vga.c
index 6d724a5..fa5c018 100644
--- a/src/kernel/drivers/terminal/vga.c
+++ b/src/kernel/drivers/terminal/vga.c
@@ -16,21 +16,21 @@ static void *vidmem;
 static int setup = 0;
 
 void vga_init(struct fbinfo *fbinfo) {
-    (void) fbinfo;
-    vidmem = VGA_MEMORY;
-    memset(vidmem, 0, VGA_SIZE*sizeof(struct vga_cell));
-    setup = 1;
+  (void) fbinfo;
+  vidmem = VGA_MEMORY;
+  memset(vidmem, 0, VGA_SIZE*sizeof(struct vga_cell));
+  setup = 1;
 }
 
 void vga_movecursor(unsigned int cursor) {
-    if(!setup) return;
-    outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_LOW);
-    outb(VGA_DATA_PORT, (uint8_t)(cursor & 0xFF));
-    outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_HIGH);
-    outb(VGA_DATA_PORT, (uint8_t)((cursor >> 8) & 0xFF));
+  if(!setup) return;
+  outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_LOW);
+  outb(VGA_DATA_PORT, (uint8_t)(cursor & 0xFF));
+  outb(VGA_ADDRESS_PORT, VGA_REGISTER_CURSOR_POS_HIGH);
+  outb(VGA_DATA_PORT, (uint8_t)((cursor >> 8) & 0xFF));
 }
 
 void vga_flush(struct vga_cell *buffer) {
-    if(!setup) return;
-    memcpy(vidmem, buffer, VGA_SIZE*2);
+  if(!setup) return;
+  memcpy(vidmem, buffer, VGA_SIZE*2);
 }
diff --git a/src/kernel/include/cpu.h b/src/kernel/include/cpu.h
index 3cf17ac..6cd80c3 100644
--- a/src/kernel/include/cpu.h
+++ b/src/kernel/include/cpu.h
@@ -13,43 +13,43 @@
 #define IRQ_SPURIOUS 0xFF
 
 typedef struct {
-    uint64_t rax;
-    uint64_t rbx;
-    uint64_t rcx;
-    uint64_t rdx;
-    uint64_t rsi;
-    uint64_t rdi;
-    uint64_t rbp;
-    uint64_t r8;
-    uint64_t r9;
-    uint64_t r10;
-    uint64_t r11;
-    uint64_t r12;
-    uint64_t r13;
-    uint64_t r14;
-    uint64_t r15;
+  uint64_t rax;
+  uint64_t rbx;
+  uint64_t rcx;
+  uint64_t rdx;
+  uint64_t rsi;
+  uint64_t rdi;
+  uint64_t rbp;
+  uint64_t r8;
+  uint64_t r9;
+  uint64_t r10;
+  uint64_t r11;
+  uint64_t r12;
+  uint64_t r13;
+  uint64_t r14;
+  uint64_t r15;
 
-    uint64_t int_no;
-    uint64_t err_code;
+  uint64_t int_no;
+  uint64_t err_code;
 
-    uint64_t rip;
-    uint64_t cs;
-    uint64_t rflags;
-    uint64_t rsp;
-    uint64_t ss;
+  uint64_t rip;
+  uint64_t cs;
+  uint64_t rflags;
+  uint64_t rsp;
+  uint64_t ss;
 } registers;
 
 typedef registers *(*int_handler_t)(registers *);
 
 struct cpu {
-    uint8_t id;
-    uint8_t apic_id;
-    uint32_t flags;
+  uint8_t id;
+  uint8_t apic_id;
+  uint32_t flags;
 };
 struct ioapic {
-    uint8_t id;
-    uint32_t addr;
-    uint32_t base;
+  uint8_t id;
+  uint32_t addr;
+  uint32_t base;
 };
 
 extern struct cpu *cpus[MAX_CPUS];
diff --git a/src/kernel/include/debug.h b/src/kernel/include/debug.h
index 5a6e1b9..8fbbd28 100644
--- a/src/kernel/include/debug.h
+++ b/src/kernel/include/debug.h
@@ -26,12 +26,12 @@
 
 #define PANIC(...) \
     do { \
-        debug("\n\nKERNEL PANIC!\n%s:%d\n", __FILE__, __LINE__); \
-        debug(__VA_ARGS__); \
-        debug("\n"); \
-        volatile int _override = 0; \
-        while(1) { \
-            __asm__("panic_breakpoint_" S__LINE__ ":"); \
-            if(_override) break; \
-        } \
+      debug("\n\nKERNEL PANIC!\n%s:%d\n", __FILE__, __LINE__); \
+      debug(__VA_ARGS__); \
+      debug("\n"); \
+      volatile int _override = 0; \
+      while(1) { \
+        __asm__("panic_breakpoint_" S__LINE__ ":"); \
+        if(_override) break; \
+      } \
     }while(0)
diff --git a/src/kernel/include/memory.h b/src/kernel/include/memory.h
index d0a14f3..e4a5a47 100644
--- a/src/kernel/include/memory.h
+++ b/src/kernel/include/memory.h
@@ -12,40 +12,40 @@
 #define ENTRIES_PER_PT 512
 
 #ifdef __ASSEMBLER__
-    #define V2P(a) ((a) - KERNEL_OFFSET)
-    #define P2V(a) ((a) + KERNEL_OFFSET)
+  #define V2P(a) ((a) - KERNEL_OFFSET)
+  #define P2V(a) ((a) + KERNEL_OFFSET)
 #else
-    #include <stdint.h>
-    #include <stddef.h>
-    #define V2P(a) ((uintptr_t)(a) &~KERNEL_OFFSET)
-    #define P2V(a) ((void *)((uintptr_t)(a) | KERNEL_OFFSET))
+  #include <stdint.h>
+  #include <stddef.h>
+  #define V2P(a) ((uintptr_t)(a) &~KERNEL_OFFSET)
+  #define P2V(a) ((void *)((uintptr_t)(a) | KERNEL_OFFSET))
 
-    #define incptr(p, n) ((void *)(((uintptr_t)(p)) + (n)))
+  #define incptr(p, n) ((void *)(((uintptr_t)(p)) + (n)))
 
-    #define P1_OFFSET(a) (((a)>>12) & 0x1FF)
-    #define P2_OFFSET(a) (((a)>>21) & 0x1FF)
-    #define P3_OFFSET(a) (((a)>>30) & 0x1FF)
-    #define P4_OFFSET(a) (((a)>>39) & 0x1FF)
+  #define P1_OFFSET(a) (((a)>>12) & 0x1FF)
+  #define P2_OFFSET(a) (((a)>>21) & 0x1FF)
+  #define P3_OFFSET(a) (((a)>>30) & 0x1FF)
+  #define P4_OFFSET(a) (((a)>>39) & 0x1FF)
 
-    // memory/memory.c
-    void memory_init();
-    extern uint64_t kernel_P4;
+  // memory/memory.c
+  void memory_init();
+  extern uint64_t kernel_P4;
 
-    // memory/vmm.c
-    uint64_t new_P4();
-    uint64_t vmm_get_page(uint64_t P4, uint64_t addr);
-    int vmm_set_page(uint64_t P4, uint64_t addr, uint64_t page, uint16_t flags);
-    void vmm_clear_page(uint64_t P4, uint64_t addr, int free);
+  // memory/vmm.c
+  uint64_t new_P4();
+  uint64_t vmm_get_page(uint64_t P4, uint64_t addr);
+  int vmm_set_page(uint64_t P4, uint64_t addr, uint64_t page, uint16_t flags);
+  void vmm_clear_page(uint64_t P4, uint64_t addr, int free);
 
-    // memory/pmm.c
-    void pmm_free(uint64_t page);
-    uint64_t pmm_alloc();
-    uint64_t pmm_calloc();
+  // memory/pmm.c
+  void pmm_free(uint64_t page);
+  uint64_t pmm_alloc();
+  uint64_t pmm_calloc();
 
-    // Link.ld
-    extern int kernel_start, kernel_end;
+  // Link.ld
+  extern int kernel_start, kernel_end;
 
-    // boot/boot_PT.s
-    extern uint64_t BootP4;
+  // boot/boot_PT.s
+  extern uint64_t BootP4;
 
 #endif
\ No newline at end of file
diff --git a/src/kernel/include/multiboot.h b/src/kernel/include/multiboot.h
index e584957..1f5768f 100644
--- a/src/kernel/include/multiboot.h
+++ b/src/kernel/include/multiboot.h
@@ -18,27 +18,27 @@
 #include <stdint.h>
 
 struct fbinfo {
-    uint64_t framebuffer_addr;
-    uint32_t framebuffer_pitch;
-    uint32_t framebuffer_width;
-    uint32_t framebuffer_height;
-    uint8_t framebuffer_bpp;
-    uint8_t framebuffer_type;
-    uint8_t reserved;
-    uint8_t color_info[];
+  uint64_t framebuffer_addr;
+  uint32_t framebuffer_pitch;
+  uint32_t framebuffer_width;
+  uint32_t framebuffer_height;
+  uint8_t framebuffer_bpp;
+  uint8_t framebuffer_type;
+  uint8_t reserved;
+  uint8_t color_info[];
 }__attribute__((packed));
 
 struct kernel_boot_data_st {
-    int multiboot_version;
-    void *mboot_tags;
-    size_t tags_length;
-    char *bootloader;
-    char *commandline;
-    size_t mmap_size;
-    unsigned int mmap_len;
-    void *mmap;
-    struct fbinfo *fbinfo;
-    void *rsdp;
+  int multiboot_version;
+  void *mboot_tags;
+  size_t tags_length;
+  char *bootloader;
+  char *commandline;
+  size_t mmap_size;
+  unsigned int mmap_len;
+  void *mmap;
+  struct fbinfo *fbinfo;
+  void *rsdp;
 };
 
 #define MMAP_FREE 1
diff --git a/src/kernel/include/musl-glue.h b/src/kernel/include/musl-glue.h
index 05da0e0..7128206 100644
--- a/src/kernel/include/musl-glue.h
+++ b/src/kernel/include/musl-glue.h
@@ -26,23 +26,23 @@ long k_sched_yield(long, long, long, long, long, long);
 
 
 struct __locale_struct {
-	const struct __locale_map *cat[6];
+  const struct __locale_map *cat[6];
 };
 struct tls_module {
-	struct tls_module *next;
-	void *image;
-	size_t len, size, align, offset;
+  struct tls_module *next;
+  void *image;
+  size_t len, size, align, offset;
 };
 struct __libc {
-	char can_do_threads;
-	char threaded;
-	char secure;
-	volatile signed char need_locks;
-	int threads_minus_1;
-	size_t *auxv;
-	struct tls_module *tls_head;
-	size_t tls_size, tls_align, tls_cnt;
-	size_t page_size;
-	struct __locale_struct global_locale;
+  char can_do_threads;
+  char threaded;
+  char secure;
+  volatile signed char need_locks;
+  int threads_minus_1;
+  size_t *auxv;
+  struct tls_module *tls_head;
+  size_t tls_size, tls_align, tls_cnt;
+  size_t page_size;
+  struct __locale_struct global_locale;
 };
 extern struct __libc __libc;
\ No newline at end of file
diff --git a/src/kernel/include/ports.h b/src/kernel/include/ports.h
index 44306b3..0f3897f 100644
--- a/src/kernel/include/ports.h
+++ b/src/kernel/include/ports.h
@@ -2,13 +2,13 @@
 #include <stdint.h>
 
 static __inline void _outb(uint16_t port, uint8_t value) {
-    __asm__ volatile("outb %1, %0" : : "dN" (port), "a" (value));
+  __asm__ volatile("outb %1, %0" : : "dN" (port), "a" (value));
 }
 
 static __inline uint8_t _inb(uint16_t port) {
-    uint8_t ret;
-    __asm__ volatile("inb %1, %0" : "=a" (ret) : "dN" (port));
-    return ret;
+  uint8_t ret;
+  __asm__ volatile("inb %1, %0" : "=a" (ret) : "dN" (port));
+  return ret;
 }
 
 #define outb _outb
diff --git a/src/kernel/include/proc.h b/src/kernel/include/proc.h
index 0a8feb3..63c1892 100644
--- a/src/kernel/include/proc.h
+++ b/src/kernel/include/proc.h
@@ -2,12 +2,12 @@
 #include <stdint.h>
 
 struct process {
-    uint64_t pid;
-    void *stack_ptr;
-    uint64_t state;
-    uint64_t P4;
-    struct process *q_next;
-    uint8_t stack[];
+  uint64_t pid;
+  void *stack_ptr;
+  uint64_t state;
+  uint64_t P4;
+  struct process *q_next;
+  uint8_t stack[];
 };
 
 // proc/process.c
diff --git a/src/kernel/include/terminal.h b/src/kernel/include/terminal.h
index f3672b3..67becbc 100644
--- a/src/kernel/include/terminal.h
+++ b/src/kernel/include/terminal.h
@@ -8,8 +8,8 @@
 #define VGA_MEMORY P2V(0xB8000)
 
 struct vga_cell {
-    uint8_t c;
-    uint8_t f;
+  uint8_t c;
+  uint8_t f;
 }__attribute__((packed));
 
 
diff --git a/src/kernel/lib/musl-glue.c b/src/kernel/lib/musl-glue.c
index c1c823f..f5abf80 100644
--- a/src/kernel/lib/musl-glue.c
+++ b/src/kernel/lib/musl-glue.c
@@ -2,85 +2,89 @@
 #include <debug.h>
 
 syscall_handler syscall_handlers[440] = {
-    [SYSCALL_BRK] = k_brk,
-    [SYSCALL_IOCTL] = k_ioctl,
-    [SYSCALL_WRITEV] = k_writev,
-    [SYSCALL_SCHED_YIELD] = k_sched_yield,
-    [SYSCALL_MMAP] = k_mmap,
+  [SYSCALL_BRK] = k_brk,
+  [SYSCALL_IOCTL] = k_ioctl,
+  [SYSCALL_WRITEV] = k_writev,
+  [SYSCALL_SCHED_YIELD] = k_sched_yield,
+  [SYSCALL_MMAP] = k_mmap,
 };
 
 syscall_handler set_syscall_handler(long num, syscall_handler handler) {
-    syscall_handler old = syscall_handlers[num];
-    syscall_handlers[num] = handler;
-    return old;
+  syscall_handler old = syscall_handlers[num];
+  syscall_handlers[num] = handler;
+  return old;
 }
 
 long syscall0(long num) {
-    long retval = 0;
-    if(syscall_handlers[num])
-        retval = syscall_handlers[num](0, 0, 0, 0, 0, 0);
-    else
-        PANIC("Unknown syscall: %d()\n", num);
-    return retval;
+  long retval = 0;
+  if(syscall_handlers[num])
+      retval = syscall_handlers[num](0, 0, 0, 0, 0, 0);
+  else
+      PANIC("Unknown syscall: %d()\n", num);
+  return retval;
 }
 
 long syscall1(long num, long a1) {
-    long retval = 0;
-    if(syscall_handlers[num])
-        retval = syscall_handlers[num](a1, 0, 0, 0, 0, 0);
-    else
-        PANIC("Unknown syscall: %d(%x)\n", num, a1);
-    return retval;
+  long retval = 0;
+  if(syscall_handlers[num])
+      retval = syscall_handlers[num](a1, 0, 0, 0, 0, 0);
+  else
+      PANIC("Unknown syscall: %d(%x)\n", num, a1);
+  return retval;
 }
 
 long syscall2(long num, long a1, long a2) {
-    long retval = 0;
-    if(syscall_handlers[num])
-        retval = syscall_handlers[num](a1, a2, 0, 0, 0, 0);
-    else
-    PANIC("Unknown syscall: %d(%x, %x)\n", num, a1, a2);
-    return retval;
+  long retval = 0;
+  if(syscall_handlers[num])
+      retval = syscall_handlers[num](a1, a2, 0, 0, 0, 0);
+  else
+  PANIC("Unknown syscall: %d(%x, %x)\n", num, a1, a2);
+  return retval;
 }
 
 long syscall3(long num, long a1, long a2, long a3) {
-    long retval = 0;
-    if(syscall_handlers[num])
-        retval = syscall_handlers[num](a1, a2, a3, 0, 0, 0);
-    else
-    PANIC("Unknown syscall: %d(%x, %x, %x)\n", num, a1, a2, a3);
-    return retval;
+  long retval = 0;
+  if(syscall_handlers[num])
+      retval = syscall_handlers[num](a1, a2, a3, 0, 0, 0);
+  else
+  PANIC("Unknown syscall: %d(%x, %x, %x)\n", num, a1, a2, a3);
+  return retval;
 }
 
 long syscall4(long num, long a1, long a2, long a3, long a4) {
-    long retval = 0;
-    if(syscall_handlers[num])
-        retval = syscall_handlers[num](a1, a2, a3, a4, 0, 0);
-    else
-    PANIC("Unknown syscall: %d(%x, %x, %x, %x)\n", num, a1, a2, a3, a4);
-    return retval;
+  long retval = 0;
+  if(syscall_handlers[num])
+      retval = syscall_handlers[num](a1, a2, a3, a4, 0, 0);
+  else
+  PANIC("Unknown syscall: %d(%x, %x, %x, %x)\n", num, a1, a2, a3, a4);
+  return retval;
 }
 
 long syscall5(long num, long a1, long a2, long a3, long a4, long a5) {
-    long retval = 0;
-    if(syscall_handlers[num])
-        retval = syscall_handlers[num](a1, a2, a3, a4, a5, 0);
-    else
-    PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x)\n", num, a1, a2, a3, a4, a5);
-    return retval;
+  long retval = 0;
+  if(syscall_handlers[num])
+      retval = syscall_handlers[num](a1, a2, a3, a4, a5, 0);
+  else
+  PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x)\n",
+      num, a1, a2, a3, a4, a5
+  );
+  return retval;
 }
 
 long syscall6(long num, long a1, long a2, long a3, long a4, long a5, long a6) {
-    long retval = 0;
-    if(syscall_handlers[num])
-        retval = syscall_handlers[num](a1, a2, a3, a4, a5, a6);
-    else
-        PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x, %x)\n", num, a1, a2, a3, a4, a5, a6);
-    return retval;
+  long retval = 0;
+  if(syscall_handlers[num])
+      retval = syscall_handlers[num](a1, a2, a3, a4, a5, a6);
+  else
+      PANIC("Unknown syscall: %d(%x, %x, %x, %x, %x, %x)\n",
+          num, a1, a2, a3, a4, a5, a6
+      );
+  return retval;
 }
 
 
 size_t auxv[] = {0};
 
 void musl_init() {
-    __libc.auxv = auxv;
+  __libc.auxv = auxv;
 }
\ No newline at end of file
diff --git a/src/kernel/memory/kbrk.c b/src/kernel/memory/kbrk.c
index 653afb3..d56ee55 100644
--- a/src/kernel/memory/kbrk.c
+++ b/src/kernel/memory/kbrk.c
@@ -5,27 +5,42 @@ static long _brk = KERNEL_BRK0;
 static long _mmap = KERNEL_MMAP;
 
 long k_brk(long brk, long, long, long, long, long) {
-    if(brk) {
-        while(_brk < brk) {
-            vmm_set_page(kernel_P4, _brk, pmm_alloc(), PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT);
-            _brk += PAGE_SIZE;
-        }
+  if(brk) {
+    while(_brk < brk) {
+      vmm_set_page(kernel_P4,
+          _brk,
+          pmm_alloc(),
+          PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT
+      );
+      _brk += PAGE_SIZE;
     }
-    return _brk;
+  }
+  return _brk;
 }
 
-long k_mmap(long addr, long length, long prot, long flags, long fd, long offset) {
-    (void)addr;
-    (void)prot;
-    (void)flags;
-    (void)offset;
-    if(fd != -1)
-        PANIC("Unknown mmap request\n");
-    long retval = _mmap;
-    while(length > 0) {
-        vmm_set_page(kernel_P4, _mmap, pmm_alloc(), PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT);
-        _mmap += PAGE_SIZE;
-        length -= PAGE_SIZE;
-    }
-    return retval;
+long k_mmap(
+      long addr,
+      long length,
+      long prot,
+      long flags,
+      long fd,
+      long offset
+  ) {
+  (void)addr;
+  (void)prot;
+  (void)flags;
+  (void)offset;
+
+  if(fd != -1)
+    PANIC("Unknown mmap request\n");
+  long retval = _mmap;
+  while(length > 0) {
+    vmm_set_page(kernel_P4,
+        _mmap, pmm_alloc(),
+        PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT
+    );
+    _mmap += PAGE_SIZE;
+    length -= PAGE_SIZE;
+  }
+  return retval;
 }
\ No newline at end of file
diff --git a/src/kernel/memory/memory.c b/src/kernel/memory/memory.c
index 56a8faf..92bc6ac 100644
--- a/src/kernel/memory/memory.c
+++ b/src/kernel/memory/memory.c
@@ -7,27 +7,27 @@
 uint64_t kernel_P4;
 
 void memory_init() {
-    kernel_P4 = (uint64_t)&BootP4;
+  kernel_P4 = (uint64_t)&BootP4;
 
-    uint64_t start, end;
-    uint32_t type, i = 0;
-    while(!multiboot_get_memory_area(i++, &start, &end, &type)) {
-        for(uint64_t p = start; p < end; p += PAGE_SIZE) {
-            uint64_t vaddr = (uint64_t)P2V(p);
-            uint64_t page = vmm_get_page(kernel_P4, vaddr);
-            if(page == (uint64_t)-1 || !(page & PAGE_PRESENT)) {
-                uint16_t flags = PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT;
-                vmm_set_page(kernel_P4, vaddr, p, flags);
-            }
+  uint64_t start, end;
+  uint32_t type, i = 0;
+  while(!multiboot_get_memory_area(i++, &start, &end, &type)) {
+    for(uint64_t p = start; p < end; p += PAGE_SIZE) {
+      uint64_t vaddr = (uint64_t)P2V(p);
+      uint64_t page = vmm_get_page(kernel_P4, vaddr);
+      if(page == (uint64_t)-1 || !(page & PAGE_PRESENT)) {
+        uint16_t flags = PAGE_GLOBAL | PAGE_WRITE | PAGE_PRESENT;
+        vmm_set_page(kernel_P4, vaddr, p, flags);
+      }
 
-            if(type != MMAP_FREE)
-                continue;
-            if(p >= V2P(&kernel_start) && p < V2P(&kernel_end))
-                continue;
-            if(multiboot_page_used((uintptr_t)P2V(p)))
-                continue;
+      if(type != MMAP_FREE)
+        continue;
+      if(p >= V2P(&kernel_start) && p < V2P(&kernel_end))
+        continue;
+      if(multiboot_page_used((uintptr_t)P2V(p)))
+        continue;
 
-            pmm_free(p);
-        }
+      pmm_free(p);
     }
+  }
 }
\ No newline at end of file
diff --git a/src/kernel/memory/pmm.c b/src/kernel/memory/pmm.c
index 8336549..40cd762 100644
--- a/src/kernel/memory/pmm.c
+++ b/src/kernel/memory/pmm.c
@@ -6,19 +6,19 @@
 uint64_t next = 0;
 
 void pmm_free(uint64_t page) {
-    *(uint64_t *)P2V(page) = next;
-    next = page;
+  *(uint64_t *)P2V(page) = next;
+  next = page;
 }
 
 uint64_t pmm_alloc() {
-    if(!next) return 0;
-    uint64_t page = next;
-    next = *(uint64_t *)P2V(page);
-    return page;
+  if(!next) return 0;
+  uint64_t page = next;
+  next = *(uint64_t *)P2V(page);
+  return page;
 }
 
 uint64_t pmm_calloc() {
-    uint64_t page = pmm_alloc();
-    memset(P2V(page), 0, PAGE_SIZE);
-    return page;
+  uint64_t page = pmm_alloc();
+  memset(P2V(page), 0, PAGE_SIZE);
+  return page;
 }
\ No newline at end of file
diff --git a/src/kernel/memory/vmm.c b/src/kernel/memory/vmm.c
index e5e887a..18e7184 100644
--- a/src/kernel/memory/vmm.c
+++ b/src/kernel/memory/vmm.c
@@ -17,80 +17,79 @@
 
 
 static int P1_exists(uint64_t P4, uint64_t addr) {
-
-    if (P4 && PRESENT(P4E(P4, addr)) && PRESENT(P3E(P4, addr)) && PRESENT(P2E(P4, addr)))
-        return 1;
-    return 0;
+  if (P4 && PRESENT(P4E(P4, addr)) && PRESENT(P3E(P4, addr)) && PRESENT(P2E(P4, addr)))
+    return 1;
+  return 0;
 }
 
 static int touch_P1(uint64_t P4, uint64_t addr, uint16_t flags) {
-    if (!P4) return -1;
+  if (!P4) return -1;
 
-    if(!PRESENT(P4E(P4, addr)) && (!(P4E(P4,addr) = pmm_calloc())))
-        return -1;
-    P4E(P4, addr) |= flags | PAGE_PRESENT;
+  if(!PRESENT(P4E(P4, addr)) && (!(P4E(P4,addr) = pmm_calloc())))
+    return -1;
+  P4E(P4, addr) |= flags | PAGE_PRESENT;
 
-    if(!PRESENT(P3E(P4, addr)) && (!(P3E(P4, addr) = pmm_calloc())))
-        return -1;
-    P3E(P4, addr) |= flags | PAGE_PRESENT;
+  if(!PRESENT(P3E(P4, addr)) && (!(P3E(P4, addr) = pmm_calloc())))
+    return -1;
+  P3E(P4, addr) |= flags | PAGE_PRESENT;
 
-    if(!PRESENT(P2E(P4, addr)) && (!(P2E(P4, addr) = pmm_calloc())))
-        return -1;
-    P2E(P4, addr) |= flags | PAGE_PRESENT;
+  if(!PRESENT(P2E(P4, addr)) && (!(P2E(P4, addr) = pmm_calloc())))
+    return -1;
+  P2E(P4, addr) |= flags | PAGE_PRESENT;
 
-    return 0;
+  return 0;
 }
 
 uint64_t new_P4() {
-    uint64_t p4 = pmm_alloc();
-    memcpy(P2V(p4), (void *)kernel_P4, PAGE_SIZE);
-    return p4;
+  uint64_t p4 = pmm_alloc();
+  memcpy(P2V(p4), (void *)kernel_P4, PAGE_SIZE);
+  return p4;
 }
 
 uint64_t vmm_get_page(uint64_t P4, uint64_t addr) {
-    if(P1_exists(P4, addr))
-        return P1E(P4, addr);
-    return -1;
+  if(P1_exists(P4, addr))
+    return P1E(P4, addr);
+  return -1;
 }
 
 int vmm_set_page(uint64_t P4, uint64_t addr, uint64_t page, uint16_t flags) {
-    if(!P1_exists(P4, addr))
-        if(touch_P1(P4, addr, flags))
-            return -1;
+  if(!P1_exists(P4, addr))
+    if(touch_P1(P4, addr, flags))
+      return -1;
 
-    P1E(P4, addr) = page | flags;
-    return 0;
+  P1E(P4, addr) = page | flags;
+  return 0;
 }
 
 void vmm_clear_page(uint64_t P4, uint64_t addr, int free) {
-    if(!P1_exists(P4, addr))
-        return;
+  if(!P1_exists(P4, addr))
+    return;
 
-    uint64_t *pt;
+  uint64_t *pt;
 
-    P1E(P4, addr) = 0;
+  P1E(P4, addr) = 0;
 
-    if(!free)
-        return;
+  if(!free)
+    return;
 
-    pt = PT(P2E(P4, addr));
-    for(int i = 0; i < ENTRIES_PER_PT; i++)
-        if(pt[i])
-            return;
-    pmm_free(MASK_FLAGS(P2E(P4, addr)));
-    P2E(P4, addr) = 0;
+  pt = PT(P2E(P4, addr));
+  for(int i = 0; i < ENTRIES_PER_PT; i++)
+    if(pt[i])
+      return;
+  pmm_free(MASK_FLAGS(P2E(P4, addr)));
+  P2E(P4, addr) = 0;
 
-    pt = PT(P3E(P4, addr));
-    for(int i = 0; i < ENTRIES_PER_PT; i++)
-        if(pt[i])
-            return;
-    pmm_free(MASK_FLAGS(P3E(P4, addr)));
-    P3E(P4, addr) = 0;
+  pt = PT(P3E(P4, addr));
+  for(int i = 0; i < ENTRIES_PER_PT; i++)
+    if(pt[i])
+      return;
+  pmm_free(MASK_FLAGS(P3E(P4, addr)));
+  P3E(P4, addr) = 0;
 
-    pt = PT(P4E(P4, addr));
-    for(int i = 0; i < ENTRIES_PER_PT; i++)
-        if(pt[i])
-            return;
-    pmm_free(MASK_FLAGS(P4E(P4, addr)));
-    P4E(P4, addr) = 0;
+  pt = PT(P4E(P4, addr));
+  for(int i = 0; i < ENTRIES_PER_PT; i++)
+    if(pt[i])
+      return;
+  pmm_free(MASK_FLAGS(P4E(P4, addr)));
+  P4E(P4, addr) = 0;
 }
\ No newline at end of file
diff --git a/src/kernel/proc/process.c b/src/kernel/proc/process.c
index 7e6d79a..b064b82 100644
--- a/src/kernel/proc/process.c
+++ b/src/kernel/proc/process.c
@@ -3,14 +3,14 @@
 #include <memory.h>
 
 struct swtch_stack {
-    uint64_t RBP;
-    uint64_t RBX;
-    uint64_t R12;
-    uint64_t R13;
-    uint64_t R14;
-    uint64_t R15;
-    uint64_t RBP2;
-    uint64_t ret;
+  uint64_t RBP;
+  uint64_t RBX;
+  uint64_t R12;
+  uint64_t R13;
+  uint64_t R14;
+  uint64_t R15;
+  uint64_t RBP2;
+  uint64_t ret;
 };
 
 static uint64_t next_pid = 1;
@@ -18,19 +18,19 @@ static uint64_t next_pid = 1;
 struct process *current_proc;
 
 struct process *new_process(void (*function)(void)) {
-    struct process *p = P2V(pmm_calloc());
-    p->pid = next_pid++;
-    p->stack_ptr = incptr(p, PAGE_SIZE - sizeof(struct swtch_stack));
-    p->q_next = 0;
-    p->P4 = new_P4();
+  struct process *p = P2V(pmm_calloc());
+  p->pid = next_pid++;
+  p->stack_ptr = incptr(p, PAGE_SIZE - sizeof(struct swtch_stack));
+  p->q_next = 0;
+  p->P4 = new_P4();
 
-    struct swtch_stack *stck = p->stack_ptr;
-    stck->RBP = (uint64_t)&stck->RBP2;
-    stck->ret = (uint64_t)function;
+  struct swtch_stack *stck = p->stack_ptr;
+  stck->RBP = (uint64_t)&stck->RBP2;
+  stck->ret = (uint64_t)function;
 
-    return p;
+  return p;
 }
 
 struct process *proc() {
-    return current_proc;
+  return current_proc;
 }
\ No newline at end of file
diff --git a/src/kernel/proc/scheduler.c b/src/kernel/proc/scheduler.c
index 69aaa2b..785fc87 100644
--- a/src/kernel/proc/scheduler.c
+++ b/src/kernel/proc/scheduler.c
@@ -2,52 +2,52 @@
 #include <cpu.h>
 
 static struct {
-    struct process *first;
-    struct process *last;
+  struct process *first;
+  struct process *last;
 } run_q = {0,0};
 
 static struct process *scheduler_proc;
 
 static struct process *scheduler_next() {
-    struct process *ret = run_q.first;
-    if(run_q.first && !(run_q.first = run_q.first->q_next))
-        run_q.last = 0;
-    return ret;
+  struct process *ret = run_q.first;
+  if(run_q.first && !(run_q.first = run_q.first->q_next))
+    run_q.last = 0;
+  return ret;
 }
 
 void scheduler_insert(struct process *new) {
-    if(run_q.last) {
-        run_q.last->q_next = new;
-        run_q.last = new;
-    } else {
-        run_q.first = run_q.last = new;
-    }
-    new->q_next = 0;
+  if(run_q.last) {
+    run_q.last->q_next = new;
+    run_q.last = new;
+  } else {
+    run_q.first = run_q.last = new;
+  }
+  new->q_next = 0;
 }
 
 void scheduler() {
-    while(1) {
-        struct process *new = 0;
-        while(!(new = scheduler_next()));
+  while(1) {
+    struct process *new = 0;
+    while(!(new = scheduler_next()));
 
-        current_proc = new;
-        write_cr3(new->P4);
-        switch_stack(&scheduler_proc->stack_ptr, &new->stack_ptr);
+    current_proc = new;
+    write_cr3(new->P4);
+    switch_stack(&scheduler_proc->stack_ptr, &new->stack_ptr);
 
-        scheduler_insert(current_proc);
-        current_proc = 0;
-    }
+    scheduler_insert(current_proc);
+    current_proc = 0;
+  }
 }
 
 long k_sched_yield(long, long, long, long, long, long) {
-    switch_stack(&current_proc->stack_ptr, &scheduler_proc->stack_ptr);
-    return 0;
+  switch_stack(&current_proc->stack_ptr, &scheduler_proc->stack_ptr);
+  return 0;
 }
 
 void start_scheduler() {
-    scheduler_proc = new_process(scheduler);
-    scheduler_proc->pid = (uint64_t)-1;
+  scheduler_proc = new_process(scheduler);
+  scheduler_proc->pid = (uint64_t)-1;
 
-    uint64_t stack;
-    switch_stack(&stack, &scheduler_proc->stack_ptr);
+  uint64_t stack;
+  switch_stack(&stack, &scheduler_proc->stack_ptr);
 }
\ No newline at end of file
diff --git a/src/libmittos/graphics/graphics.c b/src/libmittos/graphics/graphics.c
index 711331f..128589e 100644
--- a/src/libmittos/graphics/graphics.c
+++ b/src/libmittos/graphics/graphics.c
@@ -11,96 +11,125 @@
 #define STEP_X(ctx) 1
 #define STEP_Y(ctx) (ctx)->pitch
 
-void putpixel(gfx_context *ctx, uint64_t x, uint64_t y, uint32_t clr) {
-    if(x >= ctx->width || y >= ctx->height) return;
-    uint32_t *fb = (uint32_t *)ctx->buffer;
+void putpixel(
+    gfx_context *ctx,
+    uint64_t x, uint64_t y,
+    uint32_t clr
+) {
+  if(x >= ctx->width || y >= ctx->height) return;
+  uint32_t *fb = (uint32_t *)ctx->buffer;
+  fb[PXL(ctx, x, y)] = clr;
+}
+
+void draw_line(
+    gfx_context *ctx,
+    uint64_t x0, uint64_t x1,
+    uint64_t y0, uint64_t y1,
+    uint32_t clr
+) {
+  int64_t dx = x1 > x0 ? x1 - x0 : x0 - x1;
+  int64_t dy = y1 > y0 ? y1 - y0 : y0 - y1;
+  int sx = x1 > x0 ? 1 : -1;
+  int sy = y1 > y0 ? 1 : -1;
+  uint64_t x = x0, y = y0;
+  int64_t diff = dx - dy;
+  uint32_t *fb = (uint32_t *)ctx->buffer;
+  while(1) {
     fb[PXL(ctx, x, y)] = clr;
+    if(x == x1 && y == y1) break;
+
+    if((2*diff) > -dy) {
+      diff -= dy;
+      x += sx;
+    } else {
+      diff += dx;
+      y += sy;
+    }
+  }
 }
 
-void draw_line(gfx_context *ctx, uint64_t x0, uint64_t x1, uint64_t y0, uint64_t y1, uint32_t clr) {
-    int64_t dx = x1 > x0 ? x1 - x0 : x0 - x1;
-    int64_t dy = y1 > y0 ? y1 - y0 : y0 - y1;
-    int sx = x1 > x0 ? 1 : -1;
-    int sy = y1 > y0 ? 1 : -1;
-    uint64_t x = x0, y = y0;
-    int64_t diff = dx - dy;
-    uint32_t *fb = (uint32_t *)ctx->buffer;
-    while(1) {
-        fb[PXL(ctx, x, y)] = clr;
-        if(x == x1 && y == y1) break;
-
-        if((2*diff) > -dy) {
-            diff -= dy;
-            x += sx;
-        } else {
-            diff += dx;
-            y += sy;
-        }
-    }
+void draw_rect(
+    gfx_context *ctx,
+    uint64_t x, uint64_t y,
+    uint64_t width, uint64_t height,
+    uint32_t clr
+) {
+  uint32_t *fb = (uint32_t *)ctx->buffer;
+  uint64_t l1 = PXL(ctx, x, y);
+  uint64_t l2 = PXL(ctx, x, y + height);
+  for(uint64_t _x = 0; _x <= width; _x++) {
+    fb[l1] = fb[l2] = clr;
+    l1 += STEP_X(ctx);
+    l2 += STEP_X(ctx);
+  }
+  l1 = PXL(ctx, x, y);
+  l2 = PXL(ctx, x + width, y);
+  for(uint64_t _y = 0; _y <= height; _y++) {
+    fb[l1] = fb[l2] = clr;
+    l1 += STEP_Y(ctx);
+    l2 += STEP_Y(ctx);
+  }
 }
 
-void draw_rect(gfx_context *ctx, uint64_t x, uint64_t y, uint64_t width, uint64_t height, uint32_t clr) {
-    uint32_t *fb = (uint32_t *)ctx->buffer;
-    uint64_t l1 = PXL(ctx, x, y);
-    uint64_t l2 = PXL(ctx, x, y + height);
-    for(uint64_t _x = 0; _x <= width; _x++) {
-        fb[l1] = fb[l2] = clr;
-        l1 += STEP_X(ctx);
-        l2 += STEP_X(ctx);
-    }
-    l1 = PXL(ctx, x, y);
-    l2 = PXL(ctx, x + width, y);
-    for(uint64_t _y = 0; _y <= height; _y++) {
-        fb[l1] = fb[l2] = clr;
-        l1 += STEP_Y(ctx);
-        l2 += STEP_Y(ctx);
+void fill_rect(
+    gfx_context *ctx,
+    uint64_t x, uint64_t y,
+    uint64_t width, uint64_t height,
+    uint32_t clr
+) {
+  uint32_t *fb = (uint32_t *)ctx->buffer;
+  uint64_t loc = PXL(ctx, x, y);
+  for(uint64_t _y = 0; _y <= height; _y++) {
+    for(uint64_t _x = 0; _x <= width; _x += STEP_X(ctx)) {
+      fb[loc + _x] = clr;
     }
+    loc += STEP_Y(ctx);
+}
 }
 
-void fill_rect(gfx_context *ctx, uint64_t x, uint64_t y, uint64_t width, uint64_t height, uint32_t clr) {
-    uint32_t *fb = (uint32_t *)ctx->buffer;
-    uint64_t loc = PXL(ctx, x, y);
-    for(uint64_t _y = 0; _y <= height; _y++) {
-        for(uint64_t _x = 0; _x <= width; _x += STEP_X(ctx)) {
-            fb[loc + _x] = clr;
-        }
-        loc += STEP_Y(ctx);
-    }
-}
-
-void putCharacter(gfx_context *ctx, uint64_t x, uint64_t y, uint32_t clr_fg, uint32_t clr_bg, char c) {
-    unsigned char *chr = c ? font[(int)c-0x20]: font[0];
-    if(x >= ctx->width || y >= ctx->height) return;
-    uint32_t *fb = (uint32_t *)ctx->buffer;
-    uint64_t loc = y * ctx->pitch + x;
-    for(int row = 0; row < 16; row++) {
-        for(int col = 0; col < 8; col++) {
-            fb[loc+col] = ((chr[row]>>(7-col))&0x1) ? clr_fg : clr_bg;
-        }
-        loc += ctx->pitch;
+void putCharacter(
+    gfx_context *ctx,
+    uint64_t x, uint64_t y,
+    uint32_t clr_fg, uint32_t clr_bg,
+    char c
+) {
+  unsigned char *chr = c ? font[(int)c-0x20]: font[0];
+  if(x >= ctx->width || y >= ctx->height) return;
+  uint32_t *fb = (uint32_t *)ctx->buffer;
+  uint64_t loc = y * ctx->pitch + x;
+  for(int row = 0; row < 16; row++) {
+    for(int col = 0; col < 8; col++) {
+      fb[loc+col] = ((chr[row]>>(7-col))&0x1) ? clr_fg : clr_bg;
     }
+    loc += ctx->pitch;
+  }
 }
 
 void flip(gfx_context *ctx) {
-    for(uint64_t y = 0; y < ctx->height; y++) {
-        memcpy(
-            incptr(ctx->addr, y*ctx->pitch*ctx->bpp),
-            incptr(ctx->buffer, y*ctx->pitch*ctx->bpp),
-            ctx->width*ctx->bpp);
-    }
+  for(uint64_t y = 0; y < ctx->height; y++) {
+    memcpy(
+        incptr(ctx->addr, y*ctx->pitch*ctx->bpp),
+        incptr(ctx->buffer, y*ctx->pitch*ctx->bpp),
+        ctx->width*ctx->bpp
+    );
+  }
 }
 
-gfx_context *framebuffer_make_subcontext(gfx_context *ctx, uint64_t x, uint64_t y, uint64_t width, uint64_t height) {
-    gfx_context *out = malloc(sizeof(gfx_context));
-    uint64_t loc = y * ctx->pitch + x;
+gfx_context *framebuffer_make_subcontext(
+    gfx_context *ctx,
+    uint64_t x, uint64_t y,
+    uint64_t width, uint64_t height
+) {
+  gfx_context *out = malloc(sizeof(gfx_context));
+  uint64_t loc = y * ctx->pitch + x;
 
-    out->width = width;
-    out->height = height;
-    out->bpp = ctx->bpp;
-    out->pitch = ctx->pitch;
-    out->addr = incptr(ctx->addr, loc*ctx->bpp);
-    out->size = ctx->pitch * height * ctx->bpp;
-    out->buffer = calloc(1, out->size);
+  out->width = width;
+  out->height = height;
+  out->bpp = ctx->bpp;
+  out->pitch = ctx->pitch;
+  out->addr = incptr(ctx->addr, loc*ctx->bpp);
+  out->size = ctx->pitch * height * ctx->bpp;
+  out->buffer = calloc(1, out->size);
 
-    return out;
+  return out;
 }
\ No newline at end of file
diff --git a/src/libmittos/include/graphics.h b/src/libmittos/include/graphics.h
index ca7a987..a89258e 100644
--- a/src/libmittos/include/graphics.h
+++ b/src/libmittos/include/graphics.h
@@ -2,13 +2,13 @@
 #include <stdlib.h>
 
 typedef struct {
-    uint32_t width;
-    uint32_t height;
-    uint32_t bpp;
-    uint32_t pitch;
-    void *addr;
-    void *buffer;
-    size_t size;
+  uint32_t width;
+  uint32_t height;
+  uint32_t bpp;
+  uint32_t pitch;
+  void *addr;
+  void *buffer;
+  size_t size;
 } gfx_context;
 
 #define RGB(r, g, b) (((uint32_t) (r<<16) + (g<<8) + (b)))
diff --git a/src/patch-musl/arch/x86_64/syscall_arch.h b/src/patch-musl/arch/x86_64/syscall_arch.h
index e8a0cf1..6206856 100644
--- a/src/patch-musl/arch/x86_64/syscall_arch.h
+++ b/src/patch-musl/arch/x86_64/syscall_arch.h
@@ -10,25 +10,29 @@ extern long syscall5(long, long, long, long, long, long);
 extern long syscall6(long, long, long, long, long, long, long);
 
 static __inline long __syscall0(long n) {
-    return syscall0(n);
+  return syscall0(n);
 }
 static __inline long __syscall1(long n, long a1) {
-    return syscall1(n, a1);
+  return syscall1(n, a1);
 }
 static __inline long __syscall2(long n, long a1, long a2) {
-    return syscall2(n, a1, a2);
+  return syscall2(n, a1, a2);
 }
 static __inline long __syscall3(long n, long a1, long a2, long a3) {
-    return syscall3(n, a1, a2, a3);
+  return syscall3(n, a1, a2, a3);
 }
 static __inline long __syscall4(long n, long a1, long a2, long a3, long a4) {
-    return syscall4(n, a1, a2, a3, a4);
+  return syscall4(n, a1, a2, a3, a4);
 }
-static __inline long __syscall5(long n, long a1, long a2, long a3, long a4, long a5) {
-    return syscall5(n, a1, a2, a3, a4, a5);
+static __inline long __syscall5(long n, long a1, long a2, long a3, long a4,
+    long a5
+) {
+  return syscall5(n, a1, a2, a3, a4, a5);
 }
-static __inline long __syscall6(long n, long a1, long a2, long a3, long a4, long a5, long a6) {
-    return syscall6(n, a1, a2, a3, a4, a5, a6);
+static __inline long __syscall6(long n, long a1, long a2, long a3, long a4,
+    long a5, long a6
+) {
+  return syscall6(n, a1, a2, a3, a4, a5, a6);
 }
 
 #define VDSO_USEFUL