Kernel Style: Change uint*_t -> u*

84 files changed, 1043 insertions, 1044 deletions

diff --git a/kernel/arch/i386/mmu.c b/kernel/arch/i386/mmu.c
index 53aa5dd..5d4252f 100644
--- a/kernel/arch/i386/mmu.c
+++ b/kernel/arch/i386/mmu.c
@@ -17,15 +17,15 @@ PageDirectory real_kernel_directory;
 PageDirectory *active_directory = 0;
 
 #define END_OF_MEMORY 0x8000000 * 15
-uint64_t num_of_frames;
-uint32_t *frames;
-uint64_t available_memory_kb;
-uint32_t num_allocated_frames = 0;
+u64 num_of_frames;
+u32 *frames;
+u64 available_memory_kb;
+u32 num_allocated_frames = 0;
 
 #define KERNEL_START 0xc0000000
 extern uintptr_t data_end;
 
-void write_to_frame(uint32_t frame_address, uint8_t on);
+void write_to_frame(u32 frame_address, u8 on);
 
 void *ksbrk(size_t s) {
   uintptr_t rc = (uintptr_t)align_page((void *)data_end);
@@ -42,12 +42,12 @@ void *ksbrk(size_t s) {
   // Determine whether we are approaching a unallocated table
   int table_index = 1 + (rc / (1024 * 0x1000));
   if (!active_directory->tables[table_index]) {
-    uint32_t physical;
+    u32 physical;
     active_directory->tables[table_index] = (PageTable *)0xDEADBEEF;
     active_directory->tables[table_index] =
         (PageTable *)ksbrk_physical(sizeof(PageTable), (void **)&physical);
     memset(active_directory->tables[table_index], 0, sizeof(PageTable));
-    active_directory->physical_tables[table_index] = (uint32_t)physical | 0x3;
+    active_directory->physical_tables[table_index] = (u32)physical | 0x3;
 
     kernel_directory->tables[table_index] =
         active_directory->tables[table_index];
@@ -71,7 +71,7 @@ void *ksbrk_physical(size_t s, void **physical) {
   return r;
 }
 
-uint32_t mmu_get_number_of_allocated_frames(void) {
+u32 mmu_get_number_of_allocated_frames(void) {
   return num_allocated_frames;
 }
 
@@ -82,17 +82,17 @@ Page *get_page(void *ptr, PageDirectory *directory, int create_new_page,
     directory = get_active_pagedirectory();
   address /= 0x1000;
 
-  uint32_t table_index = address / 1024;
+  u32 table_index = address / 1024;
   if (!directory->tables[table_index]) {
     if (!create_new_page)
       return 0;
 
-    uint32_t physical;
+    u32 physical;
     directory->tables[table_index] =
         (PageTable *)ksbrk_physical(sizeof(PageTable), (void **)&physical);
     memset(directory->tables[table_index], 0, sizeof(PageTable));
     directory->physical_tables[table_index] =
-        (uint32_t)physical | ((set_user) ? 0x7 : 0x3);
+        (u32)physical | ((set_user) ? 0x7 : 0x3);
 
     if (!set_user) {
       kernel_directory->tables[table_index] = directory->tables[table_index];
@@ -107,7 +107,7 @@ Page *get_page(void *ptr, PageDirectory *directory, int create_new_page,
   return &directory->tables[table_index]->pages[address % 1024];
 }
 
-void mmu_free_pages(void *a, uint32_t n) {
+void mmu_free_pages(void *a, u32 n) {
   for (; n > 0; n--) {
     Page *p = get_page(a, NULL, PAGE_NO_ALLOCATE, 0);
     p->present = 0;
@@ -118,7 +118,7 @@ void mmu_free_pages(void *a, uint32_t n) {
 
 void *next_page(void *ptr) {
   uintptr_t a = (uintptr_t)ptr;
-  return (void *)(a + (PAGE_SIZE - ((uint32_t)a & (PAGE_SIZE - 1))));
+  return (void *)(a + (PAGE_SIZE - ((u32)a & (PAGE_SIZE - 1))));
 }
 
 void *align_page(void *a) {
@@ -134,13 +134,13 @@ void flush_tlb(void) {
 	mov %eax, %cr3");
 }
 
-uint32_t first_free_frame(void) {
-  for (uint32_t i = 1; i < INDEX_FROM_BIT(num_of_frames); i++) {
+u32 first_free_frame(void) {
+  for (u32 i = 1; i < INDEX_FROM_BIT(num_of_frames); i++) {
     if (frames[i] == 0xFFFFFFFF)
       continue;
 
-    for (uint32_t c = 0; c < 32; c++)
-      if (!(frames[i] & ((uint32_t)1 << c)))
+    for (u32 c = 0; c < 32; c++)
+      if (!(frames[i] & ((u32)1 << c)))
         return i * 32 + c;
   }
 
@@ -150,32 +150,32 @@ uint32_t first_free_frame(void) {
   return 0;
 }
 
-void write_to_frame(uint32_t frame_address, uint8_t on) {
-  uint32_t frame = frame_address / 0x1000;
+void write_to_frame(u32 frame_address, u8 on) {
+  u32 frame = frame_address / 0x1000;
   if (on) {
     num_allocated_frames++;
-    frames[INDEX_FROM_BIT(frame)] |= ((uint32_t)0x1 << OFFSET_FROM_BIT(frame));
+    frames[INDEX_FROM_BIT(frame)] |= ((u32)0x1 << OFFSET_FROM_BIT(frame));
     return;
   }
   num_allocated_frames--;
-  frames[INDEX_FROM_BIT(frame)] &= ~((uint32_t)0x1 << OFFSET_FROM_BIT(frame));
+  frames[INDEX_FROM_BIT(frame)] &= ~((u32)0x1 << OFFSET_FROM_BIT(frame));
 }
 
 PageDirectory *get_active_pagedirectory(void) { return active_directory; }
 
-PageTable *clone_table(uint32_t src_index, PageDirectory *src_directory,
-                       uint32_t *physical_address) {
+PageTable *clone_table(u32 src_index, PageDirectory *src_directory,
+                       u32 *physical_address) {
   PageTable *new_table =
       ksbrk_physical(sizeof(PageTable), (void **)physical_address);
   PageTable *src = src_directory->tables[src_index];
 
   // Copy all the pages
-  for (uint16_t i = 0; i < 1024; i++) {
+  for (u16 i = 0; i < 1024; i++) {
     if (!src->pages[i].present) {
       new_table->pages[i].present = 0;
       continue;
     }
-    uint32_t frame_address = first_free_frame();
+    u32 frame_address = first_free_frame();
     write_to_frame(frame_address * 0x1000, 1);
     new_table->pages[i].frame = frame_address;
 
@@ -189,7 +189,7 @@ PageTable *clone_table(uint32_t src_index, PageDirectory *src_directory,
   // Now copy all of the data to the new table. This is done by creating a
   // virutal pointer to this newly created tables physical frame so we can
   // copy data to it.
-  for (uint32_t i = 0; i < 1024; i++) {
+  for (u32 i = 0; i < 1024; i++) {
     // Find a unused table
     if (src_directory->tables[i])
       continue;
@@ -201,13 +201,13 @@ PageTable *clone_table(uint32_t src_index, PageDirectory *src_directory,
     switch_page_directory(src_directory);
 
     // For each page in the table copy all the data over.
-    for (uint32_t c = 0; c < 1024; c++) {
+    for (u32 c = 0; c < 1024; c++) {
       // Only copy pages that are used.
       if (!src->pages[c].frame || !src->pages[c].present)
         continue;
 
-      uint32_t table_data_pointer = i << 22 | c << 12;
-      uint32_t src_data_pointer = src_index << 22 | c << 12;
+      u32 table_data_pointer = i << 22 | c << 12;
+      u32 src_data_pointer = src_index << 22 | c << 12;
       memcpy((void *)table_data_pointer, (void *)src_data_pointer, 0x1000);
     }
     src_directory->tables[i] = 0;
@@ -219,12 +219,12 @@ PageTable *clone_table(uint32_t src_index, PageDirectory *src_directory,
   return 0;
 }
 
-PageTable *copy_table(PageTable *src, uint32_t *physical_address) {
+PageTable *copy_table(PageTable *src, u32 *physical_address) {
   PageTable *new_table =
       ksbrk_physical(sizeof(PageTable), (void **)physical_address);
 
   // copy all the pages
-  for (uint16_t i = 0; i < 1024; i++) {
+  for (u16 i = 0; i < 1024; i++) {
     if (!src->pages[i].present) {
       new_table->pages[i].present = 0;
       continue;
@@ -243,23 +243,23 @@ PageDirectory *clone_directory(PageDirectory *original) {
   if (!original)
     original = get_active_pagedirectory();
 
-  uint32_t physical_address;
+  u32 physical_address;
   PageDirectory *new_directory =
       ksbrk_physical(sizeof(PageDirectory), (void **)&physical_address);
-  uint32_t offset =
-      (uint32_t)new_directory->physical_tables - (uint32_t)new_directory;
+  u32 offset =
+      (u32)new_directory->physical_tables - (u32)new_directory;
   new_directory->physical_address = physical_address + offset;
 
   for (int i = 0; i < 1024; i++) {
     if (!original->tables[i]) {
       new_directory->tables[i] = NULL;
-      new_directory->physical_tables[i] = (uint32_t)NULL;
+      new_directory->physical_tables[i] = (u32)NULL;
       continue;
     }
 
     // Make sure to copy instead of cloning the stack.
     if (i >= 635 && i <= 641) {
-      uint32_t physical;
+      u32 physical;
       new_directory->tables[i] = clone_table(i, original, &physical);
       new_directory->physical_tables[i] =
           physical | (original->physical_tables[i] & 0xFFF);
@@ -273,7 +273,7 @@ PageDirectory *clone_directory(PageDirectory *original) {
       continue;
     }
 
-    uint32_t physical;
+    u32 physical;
     new_directory->tables[i] = clone_table(i, original, &physical);
     new_directory->physical_tables[i] =
         physical | (original->physical_tables[i] & 0xFFF);
@@ -362,7 +362,7 @@ void *allocate_frame(Page *page, int rw, int is_kernel) {
       ;
     return 0;
   }
-  uint32_t frame_address = first_free_frame();
+  u32 frame_address = first_free_frame();
   write_to_frame(frame_address * 0x1000, 1);
 
   page->present = 1;
@@ -382,7 +382,7 @@ void mmu_free_address_range(void *ptr, size_t length) {
       continue;
     if (!page->frame)
       continue;
-    write_to_frame(((uint32_t)page->frame) * 0x1000, 0);
+    write_to_frame(((u32)page->frame) * 0x1000, 0);
     page->present = 0;
     page->rw = 0;
     page->user = 0;
@@ -394,14 +394,14 @@ void mmu_map_directories(void *dst, PageDirectory *d, void *src,
                          PageDirectory *s, size_t length) {
   d = (!d) ? get_active_pagedirectory() : d;
   s = (!s) ? get_active_pagedirectory() : s;
-  size_t num_pages = (uint32_t)align_page((void *)length) / 0x1000;
+  size_t num_pages = (u32)align_page((void *)length) / 0x1000;
   for (size_t i = 0; i < num_pages; i++, dst += 0x1000, src += 0x1000) {
     Page *p = get_page(dst, d, PAGE_ALLOCATE, 1);
     p->present = 1;
     p->rw = 1;
     p->user = 1;
     void *physical = virtual_to_physical(src, s);
-    p->frame = (uint32_t)physical / PAGE_SIZE;
+    p->frame = (u32)physical / PAGE_SIZE;
   }
   flush_tlb();
 }
@@ -409,7 +409,7 @@ void mmu_map_directories(void *dst, PageDirectory *d, void *src,
 void mmu_map_physical(void *dst, PageDirectory *d, void *physical,
                       size_t length) {
   d = (!d) ? get_active_pagedirectory() : d;
-  size_t num_pages = (uint32_t)align_page((void *)length) / 0x1000;
+  size_t num_pages = (u32)align_page((void *)length) / 0x1000;
   for (size_t i = 0; i < num_pages; i++, dst += 0x1000, physical += 0x1000) {
     Page *p = get_page(dst, d, PAGE_ALLOCATE, 1);
     p->present = 1;
@@ -430,30 +430,30 @@ void *virtual_to_physical(void *address, PageDirectory *directory) {
                   (((uintptr_t)address) & 0xFFF));
 }
 
-extern uint32_t inital_esp;
-void move_stack(uint32_t new_stack_address, uint32_t size) {
+extern u32 inital_esp;
+void move_stack(u32 new_stack_address, u32 size) {
   mmu_allocate_region((void *)(new_stack_address - size), size, MMU_FLAG_KERNEL,
                       NULL);
 
-  uint32_t old_stack_pointer, old_base_pointer;
+  u32 old_stack_pointer, old_base_pointer;
 
   asm volatile("mov %%esp, %0" : "=r"(old_stack_pointer));
   asm volatile("mov %%ebp, %0" : "=r"(old_base_pointer));
 
-  uint32_t new_stack_pointer =
-      old_stack_pointer + ((uint32_t)new_stack_address - inital_esp);
-  uint32_t new_base_pointer =
-      old_base_pointer + ((uint32_t)new_stack_address - inital_esp);
+  u32 new_stack_pointer =
+      old_stack_pointer + ((u32)new_stack_address - inital_esp);
+  u32 new_base_pointer =
+      old_base_pointer + ((u32)new_stack_address - inital_esp);
 
   // Copy the stack
   memcpy((void *)new_stack_pointer, (void *)old_stack_pointer,
          inital_esp - old_stack_pointer);
-  for (uint32_t i = (uint32_t)new_stack_address; i > new_stack_address - size;
+  for (u32 i = (u32)new_stack_address; i > new_stack_address - size;
        i -= 4) {
-    uint32_t tmp = *(uint32_t *)i;
+    u32 tmp = *(u32 *)i;
     if (old_stack_pointer < tmp && tmp < inital_esp) {
       tmp = tmp + (new_stack_address - inital_esp);
-      uint32_t *tmp2 = (uint32_t *)i;
+      u32 *tmp2 = (u32 *)i;
       *tmp2 = tmp;
     }
   }
@@ -470,7 +470,7 @@ void move_stack(uint32_t new_stack_address, uint32_t size) {
 void *is_valid_user_c_string(const char *ptr, size_t *size) {
   void *r = (void *)ptr;
   size_t s = 0;
-  for (; ((uint32_t)ptr - (uint32_t)r) < 0x1000;) {
+  for (; ((u32)ptr - (u32)r) < 0x1000;) {
     void *page = (void *)((uintptr_t)ptr & (uintptr_t)(~(PAGE_SIZE - 1)));
     if (!is_valid_userpointer(page, PAGE_SIZE))
       return NULL;
@@ -519,25 +519,25 @@ void enable_paging(void) {
 void create_table(int table_index) {
   if (kernel_directory->tables[table_index])
     return;
-  uint32_t physical;
+  u32 physical;
   kernel_directory->tables[table_index] = (PageTable *)0xDEADBEEF;
   kernel_directory->tables[table_index] =
       (PageTable *)ksbrk_physical(sizeof(PageTable), (void **)&physical);
   memset(kernel_directory->tables[table_index], 0, sizeof(PageTable));
-  kernel_directory->physical_tables[table_index] = (uint32_t)physical | 0x3;
+  kernel_directory->physical_tables[table_index] = (u32)physical | 0x3;
 }
 
-void paging_init(uint64_t memsize) {
-  uint32_t *cr3;
+void paging_init(u64 memsize) {
+  u32 *cr3;
   asm volatile("mov %%cr3, %0" : "=r"(cr3));
-  uint32_t *virtual = (uint32_t *)((uint32_t)cr3 + 0xC0000000);
-  frames = ksbrk(1024 * sizeof(uint32_t));
-  memset(frames, 0, 1024 * sizeof(uint32_t));
+  u32 *virtual = (u32 *)((u32)cr3 + 0xC0000000);
+  frames = ksbrk(1024 * sizeof(u32));
+  memset(frames, 0, 1024 * sizeof(u32));
   num_of_frames = 1024 * 32;
 
   kernel_directory = &real_kernel_directory;
-  kernel_directory->physical_address = (uint32_t)cr3;
-  for (uint32_t i = 0; i < 1024; i++) {
+  kernel_directory->physical_address = (u32)cr3;
+  for (u32 i = 0; i < 1024; i++) {
     kernel_directory->physical_tables[i] = virtual[i];
 
     if (!kernel_directory->physical_tables[i]) {
@@ -571,24 +571,24 @@ void paging_init(uint64_t memsize) {
   switch_page_directory(clone_directory(kernel_directory));
   move_stack(0xA0000000, 0x80000);
 
-  uint64_t buffer_size = (memsize / 32) * sizeof(uint32_t);
+  u64 buffer_size = (memsize / 32) * sizeof(u32);
   // TODO: Very hacky solution since we have to memcpy the old allocation. This
   // places a strict requierment on how much RAM the system can have(altough it
   // is very small). Ideally the number of frames required would be dynamically
   // calculated.
-  assert(buffer_size >= 1024 * sizeof(uint32_t));
+  assert(buffer_size >= 1024 * sizeof(u32));
 
   // TODO Do this better
   // NOTE:
   // There are some addresses that point to devices rather than RAM.
   // Therefore we need frames for these to exist
-  uint64_t min_buffer_required = 0xFD000 + 0x100000;
+  u64 min_buffer_required = 0xFD000 + 0x100000;
   buffer_size = max(min_buffer_required, buffer_size);
 
   available_memory_kb = memsize;
   num_of_frames = available_memory_kb / 4;
-  uint32_t *new_frames = ksbrk(buffer_size);
+  u32 *new_frames = ksbrk(buffer_size);
   memset(new_frames, 0, buffer_size);
-  memcpy(new_frames, frames, 1024 * sizeof(uint32_t));
+  memcpy(new_frames, frames, 1024 * sizeof(u32));
   frames = new_frames;
 }
diff --git a/kernel/cpu/gdt.c b/kernel/cpu/gdt.c
index 28853cf..553512f 100644
--- a/kernel/cpu/gdt.c
+++ b/kernel/cpu/gdt.c
@@ -9,16 +9,16 @@ tss_entry_t tss_entry;
 
 typedef union {
   struct GDT_Entry s;
-  uint64_t raw;
+  u64 raw;
 } GDT_Entry;
 
 GDT_Entry gdt_entries[6] = {0};
 GDT_Pointer gdtr;
 
-extern uint32_t inital_esp;
+extern u32 inital_esp;
 void write_tss(struct GDT_Entry *gdt_entry) {
-  uint32_t base = (uint32_t)&tss_entry;
-  uint32_t limit = sizeof(tss_entry);
+  u32 base = (u32)&tss_entry;
+  u32 limit = sizeof(tss_entry);
 
   gdt_entry->limit_low = limit;
   gdt_entry->base_low = base;
@@ -34,11 +34,11 @@ void write_tss(struct GDT_Entry *gdt_entry) {
   gdt_entry->long_mode = 0;
   gdt_entry->big = 0;
   gdt_entry->gran = 0;
-  gdt_entry->base_high = (base & ((uint32_t)0xff << 24)) >> 24;
+  gdt_entry->base_high = (base & ((u32)0xff << 24)) >> 24;
 
   memset(&tss_entry, 0, sizeof tss_entry);
   tss_entry.ss0 = GDT_KERNEL_DATA_SEGMENT * GDT_ENTRY_SIZE;
-  register uint32_t esp asm("esp");
+  register u32 esp asm("esp");
   tss_entry.esp0 = esp;
 }
 
@@ -63,7 +63,7 @@ void gdt_init() {
 
   write_tss((struct GDT_Entry *)&gdt_entries[GDT_TSS_SEGMENT]);
 
-  gdtr.offset = (uint32_t)&gdt_entries;
+  gdtr.offset = (u32)&gdt_entries;
   gdtr.size = sizeof(gdt_entries) - 1;
 
   asm("cli");
diff --git a/kernel/cpu/gdt.h b/kernel/cpu/gdt.h
index a490dea..7cb2dc9 100644
--- a/kernel/cpu/gdt.h
+++ b/kernel/cpu/gdt.h
@@ -1,6 +1,6 @@
 #ifndef GDT_H
 #define GDT_H
-#include <stdint.h>
+#include <typedefs.h>
 #include <string.h>
 
 #define GDT_ENTRY_SIZE 0x8
@@ -13,64 +13,64 @@
 
 struct GDT_Entry
 {
-	uint16_t limit_low;
-	uint32_t base_low               : 24;
-	uint32_t accessed               :  1;
-	uint32_t read_write             :  1; // readable for code, writable for data
-	uint32_t conforming_expand_down :  1; // conforming for code, expand down for data
-	uint32_t code                   :  1; // 1 for code, 0 for data
-	uint32_t code_data_segment      :  1; // should be 1 for everything but TSS and LDT
-	uint32_t DPL                    :  2; // privilege level
-	uint32_t present                :  1;
-	uint32_t limit_high             :  4;
-	uint32_t available              :  1; // only used in software; has no effect on hardware
-	uint32_t long_mode              :  1;
-	uint32_t big                    :  1; // 32-bit opcodes for code, uint32_t stack for data
-	uint32_t gran                   :  1; // 1 to use 4k page addressing, 0 for byte addressing
-	uint8_t base_high;
+	u16 limit_low;
+	u32 base_low               : 24;
+	u32 accessed               :  1;
+	u32 read_write             :  1; // readable for code, writable for data
+	u32 conforming_expand_down :  1; // conforming for code, expand down for data
+	u32 code                   :  1; // 1 for code, 0 for data
+	u32 code_data_segment      :  1; // should be 1 for everything but TSS and LDT
+	u32 DPL                    :  2; // privilege level
+	u32 present                :  1;
+	u32 limit_high             :  4;
+	u32 available              :  1; // only used in software; has no effect on hardware
+	u32 long_mode              :  1;
+	u32 big                    :  1; // 32-bit opcodes for code, u32 stack for data
+	u32 gran                   :  1; // 1 to use 4k page addressing, 0 for byte addressing
+	u8 base_high;
 }__attribute__((packed));
 
 typedef struct GDT_Pointer
 {
-	uint16_t size;
-	uint32_t offset;
+	u16 size;
+	u32 offset;
 }__attribute__((packed)) GDT_Pointer;
 
 struct tss_entry_struct
 {
-	uint32_t prev_tss; // The previous TSS - with hardware task switching these form a kind of backward linked list.
-	uint32_t esp0;     // The stack pointer to load when changing to kernel mode.
-	uint32_t ss0;      // The stack segment to load when changing to kernel mode.
+	u32 prev_tss; // The previous TSS - with hardware task switching these form a kind of backward linked list.
+	u32 esp0;     // The stack pointer to load when changing to kernel mode.
+	u32 ss0;      // The stack segment to load when changing to kernel mode.
 	// Everything below here is unused.
-	uint32_t esp1; // esp and ss 1 and 2 would be used when switching to rings 1 or 2.
-	uint32_t ss1;
-	uint32_t esp2;
-	uint32_t ss2;
-	uint32_t cr3;
-	uint32_t eip;
-	uint32_t eflags;
-	uint32_t eax;
-	uint32_t ecx;
-	uint32_t edx;
-	uint32_t ebx;
-	uint32_t esp;
-	uint32_t ebp;
-	uint32_t esi;
-	uint32_t edi;
-	uint32_t es;
-	uint32_t cs;
-	uint32_t ss;
-	uint32_t ds;
-	uint32_t fs;
-	uint32_t gs;
-	uint32_t ldt;
-	uint16_t trap;
-	uint16_t iomap_base;
+	u32 esp1; // esp and ss 1 and 2 would be used when switching to rings 1 or 2.
+	u32 ss1;
+	u32 esp2;
+	u32 ss2;
+	u32 cr3;
+	u32 eip;
+	u32 eflags;
+	u32 eax;
+	u32 ecx;
+	u32 edx;
+	u32 ebx;
+	u32 esp;
+	u32 ebp;
+	u32 esi;
+	u32 edi;
+	u32 es;
+	u32 cs;
+	u32 ss;
+	u32 ds;
+	u32 fs;
+	u32 gs;
+	u32 ldt;
+	u16 trap;
+	u16 iomap_base;
 } __attribute__((packed));
 
 void gdt_init();
 
-uint8_t gen_access_byte(uint8_t priv, uint8_t s, uint8_t ex, uint8_t dc, uint8_t rw);
-uint64_t gen_gdt_entry(uint32_t base, uint32_t limit, uint8_t access_byte, uint8_t flag);
-uint8_t gen_flag(uint8_t gr, uint8_t sz);
+u8 gen_access_byte(u8 priv, u8 s, u8 ex, u8 dc, u8 rw);
+u64 gen_gdt_entry(u32 base, u32 limit, u8 access_byte, u8 flag);
+u8 gen_flag(u8 gr, u8 sz);
 #endif
diff --git a/kernel/cpu/idt.c b/kernel/cpu/idt.c
index abcafad..bf0061f 100644
--- a/kernel/cpu/idt.c
+++ b/kernel/cpu/idt.c
@@ -13,15 +13,15 @@
 #define IDT_MAX_ENTRY 256
 
 struct IDT_Descriptor {
-  uint16_t low_offset;
-  uint16_t code_segment_selector;
-  uint8_t zero; // Always should be zero
-  uint8_t type_attribute;
-  uint16_t high_offset;
+  u16 low_offset;
+  u16 code_segment_selector;
+  u8 zero; // Always should be zero
+  u8 type_attribute;
+  u16 high_offset;
 } __attribute__((packed)) __attribute__((aligned(4)));
 
 struct IDT_Pointer {
-  uint16_t size;
+  u16 size;
   struct IDT_Descriptor **interrupt_table;
 } __attribute__((packed));
 
@@ -30,9 +30,8 @@ struct IDT_Pointer idtr;
 
 extern void load_idtr(void *idtr);
 
-void format_descriptor(uint32_t offset, uint16_t code_segment,
-                       uint8_t type_attribute,
-                       struct IDT_Descriptor *descriptor) {
+void format_descriptor(u32 offset, u16 code_segment,
+                       u8 type_attribute, struct IDT_Descriptor *descriptor) {
   descriptor->low_offset = offset & 0xFFFF;
   descriptor->high_offset = offset >> 16;
   descriptor->type_attribute = type_attribute;
@@ -40,13 +39,13 @@ void format_descriptor(uint32_t offset, uint16_t code_segment,
   descriptor->zero = 0;
 }
 
-void install_handler(void (*handler_function)(), uint16_t type_attribute,
-                     uint8_t entry) {
-  format_descriptor((uint32_t)handler_function, KERNEL_CODE_SEGMENT_OFFSET,
+void install_handler(void (*handler_function)(), u16 type_attribute,
+                     u8 entry) {
+  format_descriptor((u32)handler_function, KERNEL_CODE_SEGMENT_OFFSET,
                     type_attribute, &IDT_Entry[entry]);
 }
 
-__attribute__((no_caller_saved_registers)) void EOI(uint8_t irq) {
+__attribute__((no_caller_saved_registers)) void EOI(u8 irq) {
   if (irq > 7)
     outb(SLAVE_PIC_COMMAND_PORT, 0x20);
 
@@ -158,8 +157,8 @@ void PIC_remap(int offset) {
 }
 
 void IRQ_set_mask(unsigned char IRQline) {
-  uint16_t port;
-  uint8_t value;
+  u16 port;
+  u8 value;
   port = (IRQline < 8) ? MASTER_PIC_DATA_PORT : SLAVE_PIC_DATA_PORT;
   if (IRQline >= 8)
     IRQline -= 8;
@@ -168,8 +167,8 @@ void IRQ_set_mask(unsigned char IRQline) {
 }
 
 void IRQ_clear_mask(unsigned char IRQline) {
-  uint16_t port;
-  uint8_t value;
+  u16 port;
+  u8 value;
   port = (IRQline < 8) ? MASTER_PIC_DATA_PORT : SLAVE_PIC_DATA_PORT;
   if (IRQline >= 8) {
     IRQline -= 8;
diff --git a/kernel/cpu/idt.h b/kernel/cpu/idt.h
index 025ba75..c68ce81 100644
--- a/kernel/cpu/idt.h
+++ b/kernel/cpu/idt.h
@@ -5,7 +5,7 @@ typedef struct registers registers_t;
 #include <cpu/gdt.h>
 #include <cpu/io.h>
 #include <log.h>
-#include <stdint.h>
+#include <typedefs.h>
 #include <stdio.h>
 
 /*
@@ -55,16 +55,16 @@ typedef struct registers registers_t;
 struct interrupt_frame;
 
 struct registers {
-  uint32_t error_code;
-  uint32_t eip;
-  uint32_t cs;
-  uint32_t eflags;
-  uint32_t esp;
-  uint32_t ss;
+  u32 error_code;
+  u32 eip;
+  u32 cs;
+  u32 eflags;
+  u32 esp;
+  u32 ss;
 };
 
 void idt_init(void);
 __attribute__((no_caller_saved_registers)) void EOI(unsigned char irq);
-void install_handler(void (*handler_function)(), uint16_t type_attribute,
-                     uint8_t entry);
+void install_handler(void (*handler_function)(), u16 type_attribute,
+                     u8 entry);
 #endif
diff --git a/kernel/cpu/io.h b/kernel/cpu/io.h
index 38858a4..af2981e 100644
--- a/kernel/cpu/io.h
+++ b/kernel/cpu/io.h
@@ -1,15 +1,15 @@
-#include <stdint.h>
+#include <typedefs.h>
 
-extern void outsw(uint16_t, uint32_t);
-extern void outb(uint16_t, uint8_t);
-extern void outw(uint16_t, uint16_t);
-extern void outl(uint16_t, uint32_t);
+extern void outsw(u16, u32);
+extern void outb(u16, u8);
+extern void outw(u16, u16);
+extern void outl(u16, u32);
 
-extern uint32_t inl(uint16_t);
-extern uint16_t inw(uint16_t);
-extern uint16_t inb(uint16_t);
+extern u32 inl(u16);
+extern u16 inw(u16);
+extern u16 inb(u16);
 
-extern void rep_outsw(uint16_t count, uint16_t port, volatile void *addy);
+extern void rep_outsw(u16 count, u16 port, volatile void *addy);
 __attribute__((no_caller_saved_registers)) extern void
-rep_insw(uint16_t count, uint16_t port, volatile void *addy);
-extern void jump_usermode(void (*address)(), uint32_t stack_pointer);
+rep_insw(u16 count, u16 port, volatile void *addy);
+extern void jump_usermode(void (*address)(), u32 stack_pointer);
diff --git a/kernel/cpu/spinlock.c b/kernel/cpu/spinlock.c
index 3f87423..11bcf68 100644
--- a/kernel/cpu/spinlock.c
+++ b/kernel/cpu/spinlock.c
@@ -1,2 +1,2 @@
-#include <stdint.h>
-uint8_t locked;
+#include <typedefs.h>
+u8 locked;
diff --git a/kernel/cpu/syscall.c b/kernel/cpu/syscall.c
index 8e17ae1..024d06f 100644
--- a/kernel/cpu/syscall.c
+++ b/kernel/cpu/syscall.c
@@ -22,7 +22,7 @@
 #include <scalls/socket.h>
 #include <scalls/stat.h>
 #include <scalls/uptime.h>
-#include <stdint.h>
+#include <typedefs.h>
 #include <string.h>
 
 #pragma GCC diagnostic ignored "-Wpedantic"
@@ -170,8 +170,8 @@ void (*syscall_functions[])() = {
     (void(*))syscall_sigaction,
 };
 
-void syscall_function_handler(uint32_t eax, uint32_t arg1, uint32_t arg2,
-                              uint32_t arg3, uint32_t arg4, uint32_t arg5) {
+void syscall_function_handler(u32 eax, u32 arg1, u32 arg2,
+                              u32 arg3, u32 arg4, u32 arg5) {
   assert(eax < sizeof(syscall_functions) / sizeof(syscall_functions[0]));
   syscall_functions[eax](arg1, arg2, arg3, arg4, arg5);
 }
diff --git a/kernel/cpu/syscall.h b/kernel/cpu/syscall.h
index 51d50f2..3568e51 100644
--- a/kernel/cpu/syscall.h
+++ b/kernel/cpu/syscall.h
@@ -1,6 +1,6 @@
 #include "idt.h"
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 void syscalls_init(void);
 
diff --git a/kernel/crypto/ChaCha20/chacha20.c b/kernel/crypto/ChaCha20/chacha20.c
index 5bf7aa2..0f74844 100644
--- a/kernel/crypto/ChaCha20/chacha20.c
+++ b/kernel/crypto/ChaCha20/chacha20.c
@@ -6,10 +6,10 @@
 	 a += b, d ^= a, d = ROTL(d, 8), c += d, b ^= c, b = ROTL(b, 7))
 #define ROUNDS 20
 
-void chacha_block(uint32_t out[16], uint32_t const in[16])
+void chacha_block(u32 out[16], u32 const in[16])
 {
 	int i;
-	uint32_t x[16];
+	u32 x[16];
 
 	for (i = 0; i < 16; ++i)
 		x[i] = in[i];
diff --git a/kernel/crypto/ChaCha20/chacha20.h b/kernel/crypto/ChaCha20/chacha20.h
index 17532f3..3278783 100644
--- a/kernel/crypto/ChaCha20/chacha20.h
+++ b/kernel/crypto/ChaCha20/chacha20.h
@@ -1,15 +1,15 @@
 #ifndef CHACHA20_H
 #define CHACHA20_H
-#include <stdint.h>
+#include <typedefs.h>
 
 #define KEY 4
-#define KEY_SIZE 8*sizeof(uint32_t)
+#define KEY_SIZE 8*sizeof(u32)
 #define COUNT 12
-#define COUNT_SIZE sizeof(uint32_t)
+#define COUNT_SIZE sizeof(u32)
 #define COUNT_MAX (0x100000000-1) // 2^32 - 1
 #define NONCE 13
-#define NONCE_SIZE 2*sizeof(uint32_t)
-#define BLOCK_SIZE 16*sizeof(uint32_t)
+#define NONCE_SIZE 2*sizeof(u32)
+#define BLOCK_SIZE 16*sizeof(u32)
 
-void chacha_block(uint32_t out[16], uint32_t const in[16]);
+void chacha_block(u32 out[16], u32 const in[16]);
 #endif
diff --git a/kernel/drivers/ata.c b/kernel/drivers/ata.c
index 82e745b..190cf5a 100644
--- a/kernel/drivers/ata.c
+++ b/kernel/drivers/ata.c
@@ -28,11 +28,11 @@
 #define STATUS_DRQ ((1 << 3))
 #define STATUS_ERR ((1 << 0))
 
-uint32_t io_base;
+u32 io_base;
 
 unsigned char read_buffer[SECTOR_SIZE];
 
-void select_drive(uint8_t master_slave) {
+void select_drive(u8 master_slave) {
   outb(io_base + DRIVE_SELECT, (master_slave) ? 0xA0 : 0xB0);
 }
 
@@ -59,7 +59,7 @@ int identify(int master_slave) {
     return -1;
   }
 
-  for (uint16_t status;;) {
+  for (u16 status;;) {
     status = inb(io_base + STATUS_PORT);
 
     if (1 == (status & STATUS_ERR)) {
@@ -76,13 +76,13 @@ int identify(int master_slave) {
   // and store them.
   // TODO: This returns some intreasting information.
   // https://wiki.osdev.org/ATA_PIO_Mode#Interesting_information_returned_by_IDENTIFY
-  uint16_t array[256];
+  u16 array[256];
   rep_insw(1 * SECTOR_SIZE / 16, io_base + DATA_PORT, array);
   return 1;
 }
 
 int poll_status(void) {
-  for (uint16_t status;;) {
+  for (u16 status;;) {
     // Read the Regular Status port until...
     // We read this 15 times to give some
     // time for the drive to catch up.
@@ -106,7 +106,7 @@ int poll_status(void) {
 
 // Instructions from: https://wiki.osdev.org/ATA_PIO_Mode#28_bit_PIO
 void
-setup_drive_for_command(uint32_t lba, uint32_t sector_count) {
+setup_drive_for_command(u32 lba, u32 sector_count) {
   // 1. Send 0xE0 for the "master" or 0xF0 for
   //    the "slave", ORed with the highest 4 bits
   //    of the LBA to port 0x1F6
@@ -131,21 +131,21 @@ setup_drive_for_command(uint32_t lba, uint32_t sector_count) {
   outb(io_base + LBAhi, (lba >> 16) & 0xFF);
 }
 
-void delayed_rep_outsw(size_t n, uint16_t port, volatile uint8_t *buffer) {
+void delayed_rep_outsw(size_t n, u16 port, volatile u8 *buffer) {
   for (volatile size_t i = 0; i < n; i++) {
-    outsw(port, (uint32_t)buffer);
+    outsw(port, (u32)buffer);
     buffer += 2;
     //    outsw(port, buffer);
   }
 }
 
-void ata_write_lba28(uint32_t lba, uint32_t sector_count,
-                     volatile const uint8_t *buffer) {
+void ata_write_lba28(u32 lba, u32 sector_count,
+                     volatile const u8 *buffer) {
   setup_drive_for_command(lba, sector_count);
 
   outb(io_base + COMMAND_PORT, WRITE_SECTORS);
 
-  for (volatile uint32_t i = 0; i < sector_count; i++) {
+  for (volatile u32 i = 0; i < sector_count; i++) {
     if (!poll_status()) {
       // FIXME: Fail properly
       for (;;)
@@ -153,7 +153,7 @@ void ata_write_lba28(uint32_t lba, uint32_t sector_count,
     }
 
     delayed_rep_outsw(256, io_base + DATA_PORT,
-                      (void *)((uint32_t)buffer + i * 256));
+                      (void *)((u32)buffer + i * 256));
   }
 
   // Cache flush
@@ -161,14 +161,14 @@ void ata_write_lba28(uint32_t lba, uint32_t sector_count,
 
   // Wait for BSY to clear
   for (;;) {
-    uint16_t status = inb(io_base + STATUS_PORT);
+    u16 status = inb(io_base + STATUS_PORT);
     if (!(status & STATUS_BSY))
       break;
   }
 }
 
 // Instructions from: https://wiki.osdev.org/ATA_PIO_Mode#28_bit_PIO
-void ata_read_lba28(uint32_t lba, uint32_t sector_count,
+void ata_read_lba28(u32 lba, u32 sector_count,
                     volatile void *address) {
   // Step 1-6 is done in this function.
   setup_drive_for_command(lba, sector_count);
@@ -180,9 +180,9 @@ void ata_read_lba28(uint32_t lba, uint32_t sector_count,
 
   // This step can be found in the for loop
 
-  // 9. Transfer 256 16-bit values, a uint16_t at a time,
+  // 9. Transfer 256 16-bit values, a u16 at a time,
   //    into your buffer from I/O port 0x1F0
-  for (volatile uint32_t i = 0; i < sector_count; i++) {
+  for (volatile u32 i = 0; i < sector_count; i++) {
     // 10. Then loop back to waiting for the next IRQ
     // or poll again for each successive sector.
     // 8. Wait for an IRQ or poll.
@@ -191,7 +191,7 @@ void ata_read_lba28(uint32_t lba, uint32_t sector_count,
       for (;;)
         ;
     }
-    rep_insw(256, io_base + DATA_PORT, (void *)((uint32_t)address + i * 256));
+    rep_insw(256, io_base + DATA_PORT, (void *)((u32)address + i * 256));
   }
 }
 
@@ -210,13 +210,13 @@ void ata_init(void) {
   select_drive(1);
 }
 
-void read_lba(uint32_t lba, void *address, size_t size, size_t offset) {
+void read_lba(u32 lba, void *address, size_t size, size_t offset) {
   uintptr_t ptr = (uintptr_t)address;
   lba += offset / SECTOR_SIZE;
   offset = offset % SECTOR_SIZE;
   size_t total_read = 0;
   for (int i = 0; size > 0; i++) {
-    uint32_t read_len =
+    u32 read_len =
         (SECTOR_SIZE < (size + offset)) ? (SECTOR_SIZE - offset) : size;
     ata_read_lba28(lba + i, 1, read_buffer);
     memcpy((void *)ptr, read_buffer + offset, read_len);
@@ -227,16 +227,16 @@ void read_lba(uint32_t lba, void *address, size_t size, size_t offset) {
   }
 }
 
-void write_lba(uint32_t lba, volatile void *address, size_t size,
+void write_lba(u32 lba, volatile void *address, size_t size,
                size_t offset) {
   uintptr_t ptr = (uintptr_t)address;
   lba += offset / SECTOR_SIZE;
   offset = offset % SECTOR_SIZE;
   size_t total_write = 0;
-  uint8_t sector_buffer[512];
+  u8 sector_buffer[512];
   for (int i = 0; size > 0; i++) {
     ata_read_lba28(lba + i, 1, sector_buffer);
-    uint32_t write_len =
+    u32 write_len =
         (SECTOR_SIZE < (size + offset)) ? (SECTOR_SIZE - offset) : size;
 
     memcpy(sector_buffer + offset, (void *)ptr, write_len);
diff --git a/kernel/drivers/ata.h b/kernel/drivers/ata.h
index 3e88d7f..6aa4906 100644
--- a/kernel/drivers/ata.h
+++ b/kernel/drivers/ata.h
@@ -5,12 +5,12 @@
 
 void ata_init(void);
 
-void read_drive_chs(uint8_t head_index, uint8_t sector_count,
-                    uint8_t sector_index, uint8_t cylinder_low_value,
-                    uint8_t cylinder_high_value, void *address);
-void read_drive_lba(uint32_t lba, uint8_t sector_count, void *address);
-void read_lba(uint32_t lba, void *address, size_t size, size_t offset);
-void write_lba(uint32_t lba, volatile void *address, size_t size,
+void read_drive_chs(u8 head_index, u8 sector_count,
+                    u8 sector_index, u8 cylinder_low_value,
+                    u8 cylinder_high_value, void *address);
+void read_drive_lba(u32 lba, u8 sector_count, void *address);
+void read_lba(u32 lba, void *address, size_t size, size_t offset);
+void write_lba(u32 lba, volatile void *address, size_t size,
                size_t offset);
-void ata_write_lba28(uint32_t lba, uint32_t sector_count,
-                     volatile const uint8_t *buffer);
+void ata_write_lba28(u32 lba, u32 sector_count,
+                     volatile const u8 *buffer);
diff --git a/kernel/drivers/keyboard.c b/kernel/drivers/keyboard.c
index 8c96606..0e3edf8 100644
--- a/kernel/drivers/keyboard.c
+++ b/kernel/drivers/keyboard.c
@@ -5,7 +5,7 @@
 #include <fs/fifo.h>
 #include <fs/vfs.h>
 #include <sched/scheduler.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 #define PS2_REG_DATA 0x60
 #define PS2_REG_STATUS 0x64
@@ -24,11 +24,11 @@
 
 #define PS2_CMD_SET_MAKE_RELEASE 0xF8 // has rsp
 
-uint8_t kb_scancodes[3] = {0x43, 0x41, 0x3f};
+u8 kb_scancodes[3] = {0x43, 0x41, 0x3f};
 
 FIFO_FILE *keyboard_fifo;
 
-uint8_t ascii_table[] = {
+u8 ascii_table[] = {
     'e', '\x1B', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '-', '=', 8,
     '\t',
 
@@ -57,7 +57,7 @@ uint8_t ascii_table[] = {
     ' ', // ;
 };
 
-uint8_t capital_ascii_table[] = {
+u8 capital_ascii_table[] = {
     'e', '\x1B', '!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '_', '+', 8,
     '\t',
 
@@ -88,7 +88,7 @@ uint8_t capital_ascii_table[] = {
 
 vfs_inode_t *kb_inode;
 
-uint8_t keyboard_to_ascii(uint16_t key, uint8_t capital) {
+u8 keyboard_to_ascii(u16 key, u8 capital) {
   if ((key & 0xFF) > sizeof(ascii_table))
     return 'U';
   if (capital)
@@ -97,20 +97,20 @@ uint8_t keyboard_to_ascii(uint16_t key, uint8_t capital) {
     return ascii_table[key & 0xFF];
 }
 
-uint8_t is_shift_down = 0;
-uint8_t is_alt_down = 0;
+u8 is_shift_down = 0;
+u8 is_alt_down = 0;
 
 struct KEY_EVENT {
   char c;
-  uint8_t mode;    // (shift (0 bit)) (alt (1 bit))
-  uint8_t release; // 0 pressed, 1 released
+  u8 mode;    // (shift (0 bit)) (alt (1 bit))
+  u8 release; // 0 pressed, 1 released
 };
 
 extern process_t *ready_queue;
 __attribute__((interrupt)) void
 int_keyboard(__attribute__((unused)) struct interrupt_frame *frame) {
   outb(0x20, 0x20);
-  uint16_t c;
+  u16 c;
   c = inb(PS2_REG_DATA);
   int released = 0;
   if (c & 0x80) {
@@ -143,14 +143,14 @@ int_keyboard(__attribute__((unused)) struct interrupt_frame *frame) {
   ev.mode = 0;
   ev.mode |= is_shift_down << 0;
   ev.mode |= is_alt_down << 1;
-  fifo_object_write((uint8_t *)&ev, 0, sizeof(ev), keyboard_fifo);
+  fifo_object_write((u8 *)&ev, 0, sizeof(ev), keyboard_fifo);
   kb_inode->has_data = keyboard_fifo->has_data;
 }
 
 #define PS2_WAIT_RECV                                                          \
   {                                                                            \
     for (;;) {                                                                 \
-      uint8_t status = inb(PS2_REG_STATUS);                                    \
+      u8 status = inb(PS2_REG_STATUS);                                         \
       if (status & 0x1)                                                        \
         break;                                                                 \
     }                                                                          \
@@ -159,7 +159,7 @@ int_keyboard(__attribute__((unused)) struct interrupt_frame *frame) {
 #define PS2_WAIT_SEND                                                          \
   {                                                                            \
     for (;;) {                                                                 \
-      uint8_t status = inb(PS2_REG_STATUS);                                    \
+      u8 status = inb(PS2_REG_STATUS);                                         \
       if (!(status & (0x1 << 1)))                                              \
         break;                                                                 \
     }                                                                          \
@@ -170,8 +170,7 @@ void install_keyboard(void) {
   install_handler(int_keyboard, INT_32_INTERRUPT_GATE(0x3), 0x21);
 }
 
-int keyboard_read(uint8_t *buffer, uint64_t offset, uint64_t len,
-                  vfs_fd_t *fd) {
+int keyboard_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)offset;
 
   if (0 == fd->inode->has_data) {
diff --git a/kernel/drivers/keyboard.h b/kernel/drivers/keyboard.h
index 4b76f22..002b9c2 100644
--- a/kernel/drivers/keyboard.h
+++ b/kernel/drivers/keyboard.h
@@ -1,7 +1,7 @@
 #ifndef KEYBOARD_H
 #define KEYBOARD_H
 
-#include <stdint.h>
+#include <typedefs.h>
 #include <cpu/io.h>
 #include <cpu/idt.h>
 
diff --git a/kernel/drivers/mouse.c b/kernel/drivers/mouse.c
index 23619a0..21cb470 100644
--- a/kernel/drivers/mouse.c
+++ b/kernel/drivers/mouse.c
@@ -3,22 +3,22 @@
 #include <fs/devfs.h>
 #include <fs/fifo.h>
 #include <fs/vfs.h>
-#include <stdint.h>
+#include <typedefs.h>
 
-uint8_t mouse_cycle = 0;  // unsigned char
-uint8_t mouse_uint8_t[3]; // signed char
-uint8_t mouse_x = 0;      // signed char
-uint8_t mouse_y = 0;      // signed char
+u8 mouse_cycle = 0;  // unsigned char
+u8 mouse_u8[3]; // signed char
+u8 mouse_x = 0;      // signed char
+u8 mouse_y = 0;      // signed char
 vfs_inode_t *mouse_inode;
 vfs_fd_t *mouse_fd;
 
 struct mouse_event {
-  uint8_t buttons;
-  uint8_t x;
-  uint8_t y;
+  u8 buttons;
+  u8 x;
+  u8 y;
 };
 
-int fs_mouse_write(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fs_mouse_write(u8 *buffer, u64 offset, u64 len,
                    vfs_fd_t *fd) {
   int rc = fifo_object_write(buffer, offset, len, fd->inode->internal_object);
   FIFO_FILE *f = fd->inode->internal_object;
@@ -26,7 +26,7 @@ int fs_mouse_write(uint8_t *buffer, uint64_t offset, uint64_t len,
   return rc;
 }
 
-int fs_mouse_read(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fs_mouse_read(u8 *buffer, u64 offset, u64 len,
                   vfs_fd_t *fd) {
   FIFO_FILE *f = fd->inode->internal_object;
   if (!mouse_inode->has_data)
@@ -53,24 +53,24 @@ __attribute__((interrupt)) void int_mouse(registers_t *r) {
   EOI(12);
   switch (mouse_cycle) {
   case 0:
-    mouse_uint8_t[0] = inb(0x60);
-    if(!(mouse_uint8_t[0] & (1 << 3))) {
+    mouse_u8[0] = inb(0x60);
+    if(!(mouse_u8[0] & (1 << 3))) {
 	mouse_cycle = 0;
     return;
     }
     mouse_cycle++;
     break;
   case 1:
-    mouse_uint8_t[1] = inb(0x60);
+    mouse_u8[1] = inb(0x60);
     mouse_cycle++;
     break;
   case 2:
-    mouse_uint8_t[2] = inb(0x60);
-    mouse_x = mouse_uint8_t[1];
-    mouse_y = mouse_uint8_t[2];
+    mouse_u8[2] = inb(0x60);
+    mouse_x = mouse_u8[1];
+    mouse_y = mouse_u8[2];
     mouse_cycle = 0;
     struct mouse_event e;
-    e.buttons = mouse_uint8_t[0];
+    e.buttons = mouse_u8[0];
     e.x = mouse_x;
     e.y = mouse_y;
     raw_vfs_pwrite(mouse_fd, &e, sizeof(e), 0);
@@ -78,8 +78,8 @@ __attribute__((interrupt)) void int_mouse(registers_t *r) {
   }
 }
 
-void mouse_wait(uint8_t a_type) {
-  uint32_t _time_out = 100000;
+void mouse_wait(u8 a_type) {
+  u32 _time_out = 100000;
   if (a_type == 0) {
     while (_time_out--) {
       if ((inb(0x64) & 1) == 1) {
@@ -97,7 +97,7 @@ void mouse_wait(uint8_t a_type) {
   }
 }
 
-void mouse_write(uint8_t a_write) {
+void mouse_write(u8 a_write) {
   // Wait to be able to send a command
   mouse_wait(1);
   // Tell the mouse we are sending a command
@@ -108,14 +108,14 @@ void mouse_write(uint8_t a_write) {
   outb(0x60, a_write);
 }
 
-uint8_t mouse_read() {
+u8 mouse_read() {
   // Get's response from mouse
   mouse_wait(0);
   return inb(0x60);
 }
 
 void install_mouse(void) {
-  uint8_t _status; // unsigned char
+  u8 _status; // unsigned char
   asm("cli");
   // Enable the auxiliary mouse device
   mouse_wait(1);
diff --git a/kernel/drivers/pci.c b/kernel/drivers/pci.c
index 5fe14bd..f73b341 100644
--- a/kernel/drivers/pci.c
+++ b/kernel/drivers/pci.c
@@ -6,39 +6,39 @@
 #define CONFIG_ADDRESS 0xCF8
 #define CONFIG_DATA 0xCFC
 
-void pci_config_write32(const struct PCI_DEVICE *device, uint8_t func,
-                        uint8_t offset, uint32_t data) {
-  uint32_t address;
-  uint32_t lbus = (uint32_t)device->bus;
-  uint32_t lslot = (uint32_t)device->slot;
-  uint32_t lfunc = (uint32_t)func;
+void pci_config_write32(const struct PCI_DEVICE *device, u8 func,
+                        u8 offset, u32 data) {
+  u32 address;
+  u32 lbus = (u32)device->bus;
+  u32 lslot = (u32)device->slot;
+  u32 lfunc = (u32)func;
 
   // Create configuration address as per Figure 1
-  address = (uint32_t)((lbus << 16) | (lslot << 11) | (lfunc << 8) |
-                       (offset & 0xFC) | ((uint32_t)0x80000000));
+  address = (u32)((lbus << 16) | (lslot << 11) | (lfunc << 8) |
+                       (offset & 0xFC) | ((u32)0x80000000));
 
   // Write out the address
   outl(CONFIG_ADDRESS, address);
   outl(CONFIG_DATA, data);
 }
 
-uint32_t pci_config_read32(const struct PCI_DEVICE *device, uint8_t func,
-                           uint8_t offset) {
-  uint32_t address;
-  uint32_t lbus = (uint32_t)device->bus;
-  uint32_t lslot = (uint32_t)device->slot;
-  uint32_t lfunc = (uint32_t)func;
+u32 pci_config_read32(const struct PCI_DEVICE *device, u8 func,
+                           u8 offset) {
+  u32 address;
+  u32 lbus = (u32)device->bus;
+  u32 lslot = (u32)device->slot;
+  u32 lfunc = (u32)func;
 
   // Create configuration address as per Figure 1
-  address = (uint32_t)((lbus << 16) | (lslot << 11) | (lfunc << 8) |
-                       (offset & 0xFC) | ((uint32_t)0x80000000));
+  address = (u32)((lbus << 16) | (lslot << 11) | (lfunc << 8) |
+                       (offset & 0xFC) | ((u32)0x80000000));
 
   // Write out the address
   outl(CONFIG_ADDRESS, address);
   return inl(CONFIG_DATA);
 }
 
-int pci_populate_device_struct(uint16_t vendor, uint16_t device,
+int pci_populate_device_struct(u16 vendor, u16 device,
                                struct PCI_DEVICE *pci_device) {
   pci_device->vendor = vendor;
   pci_device->device = device;
@@ -48,14 +48,14 @@ int pci_populate_device_struct(uint16_t vendor, uint16_t device,
       struct PCI_DEVICE tmp;
       tmp.bus = bus;
       tmp.slot = slot;
-      uint32_t device_vendor = pci_config_read32(&tmp, 0, 0);
+      u32 device_vendor = pci_config_read32(&tmp, 0, 0);
       if (vendor != (device_vendor & 0xFFFF))
         continue;
       if (device != (device_vendor >> 16))
         continue;
       pci_device->bus = bus;
       pci_device->slot = slot;
-      uint32_t bar0 = pci_config_read32(pci_device, 0, 0x10);
+      u32 bar0 = pci_config_read32(pci_device, 0, 0x10);
       assert(bar0 & 0x1 && "Only support memory IO");
       pci_device->gen.base_mem_io = bar0 & (~0x3);
       return 1;
@@ -64,6 +64,6 @@ int pci_populate_device_struct(uint16_t vendor, uint16_t device,
   return 0;
 }
 
-uint8_t pci_get_interrupt_line(const struct PCI_DEVICE *device) {
+u8 pci_get_interrupt_line(const struct PCI_DEVICE *device) {
   return pci_config_read32(device, 0, 0x3C) & 0xFF;
 }
diff --git a/kernel/drivers/pci.h b/kernel/drivers/pci.h
index 7511cee..66d7207 100644
--- a/kernel/drivers/pci.h
+++ b/kernel/drivers/pci.h
@@ -1,26 +1,26 @@
-#include <stdint.h>
+#include <typedefs.h>
 
 struct GENERAL_DEVICE {
-  uint32_t base_mem_io;
-  uint8_t interrupt_line;
+  u32 base_mem_io;
+  u8 interrupt_line;
 };
 
 struct PCI_DEVICE {
-  uint16_t vendor;
-  uint16_t device;
-  uint8_t bus;
-  uint8_t slot;
+  u16 vendor;
+  u16 device;
+  u8 bus;
+  u8 slot;
   union {
     struct GENERAL_DEVICE gen;
   };
 };
 
-uint32_t pci_config_read32(const struct PCI_DEVICE *device, uint8_t func,
-                           uint8_t offset);
-void pci_config_write32(const struct PCI_DEVICE *device, uint8_t func,
-                        uint8_t offset, uint32_t data);
+u32 pci_config_read32(const struct PCI_DEVICE *device, u8 func,
+                           u8 offset);
+void pci_config_write32(const struct PCI_DEVICE *device, u8 func,
+                        u8 offset, u32 data);
 
-int pci_populate_device_struct(uint16_t vendor, uint16_t device,
+int pci_populate_device_struct(u16 vendor, u16 device,
                                struct PCI_DEVICE *pci_device);
 
-uint8_t pci_get_interrupt_line(const struct PCI_DEVICE *device);
+u8 pci_get_interrupt_line(const struct PCI_DEVICE *device);
diff --git a/kernel/drivers/pit.c b/kernel/drivers/pit.c
index 711883c..f29b3f8 100644
--- a/kernel/drivers/pit.c
+++ b/kernel/drivers/pit.c
@@ -3,14 +3,14 @@
 #define PIT_IO_CHANNEL_0 0x40
 #define PIT_IO_MODE_COMMAND 0x43
 
-uint64_t clock_num_ms_ticks = 0;
-uint64_t pit_counter = 0;
-uint16_t hertz;
+u64 clock_num_ms_ticks = 0;
+u64 pit_counter = 0;
+u16 hertz;
 
-uint64_t pit_num_ms(void) { return clock_num_ms_ticks; }
+u64 pit_num_ms(void) { return clock_num_ms_ticks; }
 
-uint16_t read_pit_count(void) {
-  uint16_t count = 0;
+u16 read_pit_count(void) {
+  u16 count = 0;
 
   outb(PIT_IO_MODE_COMMAND, 0x0 /*0b00000000*/);
 
@@ -20,8 +20,8 @@ uint16_t read_pit_count(void) {
   return count;
 }
 
-void set_pit_count(uint16_t hertz) {
-  uint16_t divisor = 1193180 / hertz;
+void set_pit_count(u16 hertz) {
+  u16 divisor = 1193180 / hertz;
 
   /*
    * 0b00110110
diff --git a/kernel/drivers/pit.h b/kernel/drivers/pit.h
index 8d9ce98..4d221c1 100644
--- a/kernel/drivers/pit.h
+++ b/kernel/drivers/pit.h
@@ -3,10 +3,10 @@
 #include <cpu/idt.h>
 #include <cpu/io.h>
 #include <sched/scheduler.h>
-#include <stdint.h>
+#include <typedefs.h>
 #include <stdio.h>
 
 void pit_install(void);
-void set_pit_count(uint16_t hertz);
-uint64_t pit_num_ms(void);
+void set_pit_count(u16 hertz);
+u64 pit_num_ms(void);
 #endif
diff --git a/kernel/drivers/rtl8139.c b/kernel/drivers/rtl8139.c
index 3853eab..cfe5cf2 100644
--- a/kernel/drivers/rtl8139.c
+++ b/kernel/drivers/rtl8139.c
@@ -15,53 +15,53 @@
 #define TSAD0 0x20 // transmit start address
 
 struct PCI_DEVICE rtl8139;
-uint8_t *device_buffer;
+u8 *device_buffer;
 
-uint8_t *send_buffers[4];
+u8 *send_buffers[4];
 
 struct _INT_PACKET_HEADER {
-  uint8_t ROK : 1;
-  uint8_t FAE : 1;
-  uint8_t CRC : 1;
-  uint8_t LONG : 1;
-  uint8_t RUNT : 1;
-  uint8_t ISE : 1;
-  uint8_t reserved : 5;
-  uint8_t BAR : 1;
-  uint8_t PAM : 1;
-  uint8_t MAR : 1;
+  u8 ROK : 1;
+  u8 FAE : 1;
+  u8 CRC : 1;
+  u8 LONG : 1;
+  u8 RUNT : 1;
+  u8 ISE : 1;
+  u8 reserved : 5;
+  u8 BAR : 1;
+  u8 PAM : 1;
+  u8 MAR : 1;
 };
 
 struct PACKET_HEADER {
   union {
-    uint16_t raw;
+    u16 raw;
     struct _INT_PACKET_HEADER data;
   };
 };
 
-uint16_t current_packet_read = 0;
+u16 current_packet_read = 0;
 
 void handle_packet(void) {
-  assert(sizeof(struct _INT_PACKET_HEADER) == sizeof(uint16_t));
+  assert(sizeof(struct _INT_PACKET_HEADER) == sizeof(u16));
 
-  uint16_t *buf = (uint16_t *)(device_buffer + current_packet_read);
+  u16 *buf = (u16 *)(device_buffer + current_packet_read);
   struct PACKET_HEADER packet_header;
   packet_header.raw = *buf;
   assert(packet_header.data.ROK);
   kprintf("packet_header.raw: %x\n", packet_header.raw);
-  uint16_t packet_length = *(buf + 1);
+  u16 packet_length = *(buf + 1);
   kprintf("packet_length: %x\n", packet_length);
 
-  uint8_t packet_buffer[8192 + 16];
+  u8 packet_buffer[8192 + 16];
   if (current_packet_read + packet_length >= 8192 + 16) {
-    uint32_t first_run = ((uint8_t *)buf + (8192 + 16)) - device_buffer;
+    u32 first_run = ((u8 *)buf + (8192 + 16)) - device_buffer;
     memcpy(packet_buffer, buf, first_run);
     memcpy(packet_buffer, device_buffer, packet_length - first_run);
   } else {
     memcpy(packet_buffer, buf, packet_length);
   }
 
-  handle_ethernet((uint8_t *)packet_buffer + 4, packet_length);
+  handle_ethernet((u8 *)packet_buffer + 4, packet_length);
 
   // Thanks to exscape
   // https://github.com/exscape/exscapeOS/blob/master/src/kernel/net/rtl8139.c
@@ -76,7 +76,7 @@ void handle_packet(void) {
 
 __attribute__((interrupt)) void rtl8139_handler(void *regs) {
   (void)regs;
-  uint16_t status = inw(rtl8139.gen.base_mem_io + 0x3e);
+  u16 status = inw(rtl8139.gen.base_mem_io + 0x3e);
   kprintf("status: %x\n", status);
 
   outw(rtl8139.gen.base_mem_io + 0x3E, 0x5);
@@ -91,7 +91,7 @@ __attribute__((interrupt)) void rtl8139_handler(void *regs) {
   EOI(0xB);
 }
 
-int rtl8139_send_data(uint8_t *data, uint16_t data_size) {
+int rtl8139_send_data(u8 *data, u16 data_size) {
   const struct PCI_DEVICE *device = &rtl8139;
   // FIXME: It should block or fail if there is too little space for the
   // buffer
@@ -103,30 +103,30 @@ int rtl8139_send_data(uint8_t *data, uint16_t data_size) {
   }
   memcpy(send_buffers[loop], data, data_size);
   outl(device->gen.base_mem_io + 0x20 + loop * 4,
-       (uint32_t)virtual_to_physical(send_buffers[loop], NULL));
+       (u32)virtual_to_physical(send_buffers[loop], NULL));
   outl(device->gen.base_mem_io + 0x10 + loop * 4, data_size);
   loop += 1;
   return 1;
 }
 
-void get_mac_address(uint8_t mac[6]) {
-  uint32_t base_address = rtl8139.gen.base_mem_io;
+void get_mac_address(u8 mac[6]) {
+  u32 base_address = rtl8139.gen.base_mem_io;
   // Read the MAC address
-  uint64_t mac_address;
+  u64 mac_address;
   {
-    uint32_t low_mac = inl(base_address);
-    uint16_t high_mac = inw(base_address + 0x4);
-    mac_address = ((uint64_t)high_mac << 32) | low_mac;
+    u32 low_mac = inl(base_address);
+    u16 high_mac = inw(base_address + 0x4);
+    mac_address = ((u64)high_mac << 32) | low_mac;
   }
   kprintf("mac_address: %x\n", mac_address);
-  memcpy(mac, &mac_address, sizeof(uint8_t[6]));
+  memcpy(mac, &mac_address, sizeof(u8[6]));
 }
 
-uint8_t rtl8139_get_transmit_status(uint32_t base_address) {
-  uint32_t status_register = inl(base_address + 0x3E);
+u8 rtl8139_get_transmit_status(u32 base_address) {
+  u32 status_register = inl(base_address + 0x3E);
   if ((status_register >> 3) & 0x1)
     kprintf("transmit error :(\n");
-  uint8_t status = (status_register >> 2) & 0x1;
+  u8 status = (status_register >> 2) & 0x1;
   outl(base_address + 0x3E, 0x5);
   return status;
 }
@@ -138,14 +138,14 @@ void rtl8139_init(void) {
   }
   kprintf("RTL8139 found at bus: %x slot: %x\n", rtl8139.bus, rtl8139.slot);
 
-  uint8_t header_type = (pci_config_read32(&rtl8139, 0, 0xC) >> 16) & 0xFF;
+  u8 header_type = (pci_config_read32(&rtl8139, 0, 0xC) >> 16) & 0xFF;
   assert(0 == header_type);
 
-  uint32_t base_address = rtl8139.gen.base_mem_io;
-  uint8_t interrupt_line = pci_get_interrupt_line(&rtl8139);
+  u32 base_address = rtl8139.gen.base_mem_io;
+  u8 interrupt_line = pci_get_interrupt_line(&rtl8139);
 
   // Enable bus mastering
-  uint32_t register1 = pci_config_read32(&rtl8139, 0, 0x4);
+  u32 register1 = pci_config_read32(&rtl8139, 0, 0x4);
   register1 |= (1 << 2);
   pci_config_write32(&rtl8139, 0, 0x4, register1);
 
@@ -159,7 +159,7 @@ void rtl8139_init(void) {
   device_buffer = ksbrk(8192 + 16);
   memset(device_buffer, 0, 8192 + 16);
   // Setupt the recieve buffer
-  uint32_t rx_buffer = (uint32_t)virtual_to_physical(device_buffer, NULL);
+  u32 rx_buffer = (u32)virtual_to_physical(device_buffer, NULL);
   outl(base_address + RBSTART, rx_buffer);
 
   // Set IMR + ISR
diff --git a/kernel/drivers/rtl8139.h b/kernel/drivers/rtl8139.h
index 6e13fdd..7cbca4b 100644
--- a/kernel/drivers/rtl8139.h
+++ b/kernel/drivers/rtl8139.h
@@ -1,4 +1,4 @@
-#include <stdint.h>
-void get_mac_address(uint8_t mac[6]);
+#include <typedefs.h>
+void get_mac_address(u8 mac[6]);
 void rtl8139_init(void);
-int rtl8139_send_data(uint8_t *data, uint16_t data_size);
+int rtl8139_send_data(u8 *data, u16 data_size);
diff --git a/kernel/drivers/vbe.c b/kernel/drivers/vbe.c
index c67b7b4..0fb0600 100644
--- a/kernel/drivers/vbe.c
+++ b/kernel/drivers/vbe.c
@@ -5,11 +5,11 @@
 #include <mmu.h>
 #include <stdio.h>
 
-uint8_t *framebuffer;
-uint32_t framebuffer_physical;
-uint32_t framebuffer_width;
-uint32_t framebuffer_height;
-uint64_t framebuffer_size;
+u8 *framebuffer;
+u32 framebuffer_physical;
+u32 framebuffer_width;
+u32 framebuffer_height;
+u64 framebuffer_size;
 
 vfs_vm_object_t vbe_vm_object;
 
@@ -17,9 +17,9 @@ vfs_vm_object_t vbe_vm_object;
 #define min(_a, _b) (((_a) > (_b)) ? (_b) : (_a))
 
 struct DISPLAY_INFO {
-  uint32_t width;
-  uint32_t height;
-  uint8_t bpp;
+  u32 width;
+  u32 height;
+  u8 bpp;
 };
 
 struct DISPLAY_INFO vbe_info;
@@ -29,27 +29,27 @@ void display_driver_init(multiboot_info_t *mbi) {
   framebuffer_width = mbi->framebuffer_width;
   framebuffer_height = mbi->framebuffer_height;
 
-  uint32_t bits_pp = mbi->framebuffer_bpp;
-  uint32_t bytes_pp = (bits_pp / 8) + (8 - (bits_pp % 8));
+  u32 bits_pp = mbi->framebuffer_bpp;
+  u32 bytes_pp = (bits_pp / 8) + (8 - (bits_pp % 8));
 
   framebuffer_size = bytes_pp * framebuffer_width * framebuffer_height;
 
   framebuffer_physical = mbi->framebuffer_addr;
   framebuffer =
-      mmu_map_frames((void *)(uint32_t)mbi->framebuffer_addr, framebuffer_size);
+      mmu_map_frames((void *)(u32)mbi->framebuffer_addr, framebuffer_size);
 
   vbe_info.width = framebuffer_width;
   vbe_info.height = framebuffer_height;
   vbe_info.bpp = mbi->framebuffer_bpp;
 }
 
-vfs_vm_object_t *vbe_get_vm_object(uint64_t length, uint64_t offset,
+vfs_vm_object_t *vbe_get_vm_object(u64 length, u64 offset,
                                    vfs_fd_t *fd) {
   (void)fd;
   (void)length;
   (void)offset;
   vbe_vm_object.size = framebuffer_size;
-  int n = (uintptr_t)align_page((void *)(uint32_t)framebuffer_size) / 0x1000;
+  int n = (uintptr_t)align_page((void *)(u32)framebuffer_size) / 0x1000;
   vbe_vm_object.object = kmalloc(sizeof(void *) * n);
   for (int i = 0; i < n; i++) {
     vbe_vm_object.object[i] = (void *)framebuffer_physical + (i * 0x1000);
@@ -57,7 +57,7 @@ vfs_vm_object_t *vbe_get_vm_object(uint64_t length, uint64_t offset,
   return &vbe_vm_object;
 }
 
-int display_info_read(uint8_t *buffer, uint64_t offset, uint64_t len,
+int display_info_read(u8 *buffer, u64 offset, u64 len,
                       vfs_fd_t *fd) {
   (void)offset;
   int read_len = min(sizeof(struct DISPLAY_INFO), len);
diff --git a/kernel/elf.c b/kernel/elf.c
index e46d24d..d6d349c 100644
--- a/kernel/elf.c
+++ b/kernel/elf.c
@@ -3,9 +3,9 @@
 #include <elf.h>
 #include <sched/scheduler.h>
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
-void *load_elf_file(const char *f, uint32_t *ds) {
+void *load_elf_file(const char *f, u32 *ds) {
   //  ELFHeader *header = kmalloc(sizeof(ELFHeader));
   ELFHeader header;
   int fd = vfs_open(f, O_RDONLY, 0);
@@ -24,7 +24,7 @@ void *load_elf_file(const char *f, uint32_t *ds) {
 
   Elf32_Phdr program_header;
   assert(sizeof(program_header) == header.e_phentsize);
-  uint32_t header_offset = header.e_phoff;
+  u32 header_offset = header.e_phoff;
   uintptr_t end_of_code = 0;
   for (int i = 0; i < header.e_phnum;
        i++, header_offset += header.e_phentsize) {
@@ -39,11 +39,11 @@ void *load_elf_file(const char *f, uint32_t *ds) {
 
     // 1. Clear p_memsz bytes at p_vaddr to 0.(We also allocate frames for
     // that range)
-    uint32_t p_memsz = program_header.p_memsz;
-    uint32_t p_vaddr = program_header.p_vaddr;
+    u32 p_memsz = program_header.p_memsz;
+    u32 p_vaddr = program_header.p_vaddr;
 
-    uint32_t pages_to_allocate =
-        (uint32_t)align_page((void *)(p_vaddr + p_memsz));
+    u32 pages_to_allocate =
+        (u32)align_page((void *)(p_vaddr + p_memsz));
     pages_to_allocate -= p_vaddr - (p_vaddr % 0x1000);
     pages_to_allocate /= 0x1000;
 
diff --git a/kernel/elf.h b/kernel/elf.h
index 452ddbd..4677d3c 100644
--- a/kernel/elf.h
+++ b/kernel/elf.h
@@ -1,6 +1,6 @@
 #ifndef ELF_H
 #define ELF_H
-#include <stdint.h>
+#include <typedefs.h>
 #include <mmu.h>
 #include <fs/vfs.h>
 #include <assert.h>
@@ -29,11 +29,11 @@
 #define ELF_WRITABLE (1 << 1)
 #define ELF_READABLE (1 << 2)
 
-#define Elf32_Addr uint32_t  // Unsigned program address
-#define Elf32_Half uint16_t  // Unsigned medium integer
-#define Elf32_Off uint32_t   // Unsigned file offset
-#define Elf32_Sword uint32_t // Signed large integer
-#define Elf32_Word uint32_t  // Unsigned large integer
+#define Elf32_Addr u32  // Unsigned program address
+#define Elf32_Half u16  // Unsigned medium integer
+#define Elf32_Off u32   // Unsigned file offset
+#define Elf32_Sword u32 // Signed large integer
+#define Elf32_Word u32  // Unsigned large integer
 
 #define ELF_EXEC (1 << 0)
 #define ELF_WRITE (1 << 1)
@@ -95,5 +95,5 @@ typedef struct {
 } __attribute__((packed)) Elf32_Phdr;
 
 
-void *load_elf_file(const char *f, uint32_t *ds);
+void *load_elf_file(const char *f, u32 *ds);
 #endif
diff --git a/kernel/fs/devfs.c b/kernel/fs/devfs.c
index 14748a7..0fd082d 100644
--- a/kernel/fs/devfs.c
+++ b/kernel/fs/devfs.c
@@ -9,11 +9,11 @@ int num_files = 0;
 
 vfs_inode_t *devfs_add_file(
     char *path,
-    int (*read)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
-    int (*write)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
-    vfs_vm_object_t *(get_vm_object)(uint64_t length, uint64_t offset,
+    int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    vfs_vm_object_t *(get_vm_object)(u64 length, u64 offset,
                                      vfs_fd_t *fd),
-    uint8_t has_data, uint8_t can_write, int type) {
+    u8 has_data, u8 can_write, int type) {
   files[num_files].name = copy_and_allocate_string(path);
 
   vfs_inode_t *i = kmalloc(sizeof(vfs_inode_t));
@@ -38,20 +38,20 @@ vfs_inode_t *devfs_open(const char *file) {
   return 0;
 }
 
-int devfs_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int devfs_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   return fd->inode->read(buffer, offset, len, fd);
 }
 
-int devfs_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int devfs_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   return fd->inode->write(buffer, offset, len, fd);
 }
 
-vfs_vm_object_t *devfs_get_vm_object(uint64_t length, uint64_t offset,
+vfs_vm_object_t *devfs_get_vm_object(u64 length, u64 offset,
                                      vfs_fd_t *fd) {
   return fd->inode->get_vm_object(length, offset, fd);
 }
 
-int stdout_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int stdout_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)offset;
   (void)fd;
 
@@ -61,7 +61,7 @@ int stdout_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
   return rc;
 }
 
-int serial_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int serial_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)offset;
   (void)fd;
 
diff --git a/kernel/fs/devfs.h b/kernel/fs/devfs.h
index 23a499e..9de7034 100644
--- a/kernel/fs/devfs.h
+++ b/kernel/fs/devfs.h
@@ -2,7 +2,7 @@
 #define DEVFS_H
 #include <defs.h>
 #include <fs/vfs.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 typedef struct devfs_file {
   char *name;
@@ -11,16 +11,16 @@ typedef struct devfs_file {
 
 vfs_inode_t *devfs_mount(void);
 vfs_inode_t *devfs_open(const char *file);
-int devfs_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd);
-int devfs_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd);
+int devfs_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd);
+int devfs_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd);
 void add_stdout(void);
 void add_serial(void);
 vfs_inode_t *devfs_add_file(
     char *path,
-    int (*read)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
-    int (*write)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
-    vfs_vm_object_t *(*get_vm_object)(uint64_t length, uint64_t offset,
+    int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    vfs_vm_object_t *(*get_vm_object)(u64 length, u64 offset,
                                       vfs_fd_t *fd),
-    uint8_t has_data, uint8_t can_write, int type);
+    u8 has_data, u8 can_write, int type);
 
 #endif
diff --git a/kernel/fs/ext2.c b/kernel/fs/ext2.c
index 6bde98b..734ca15 100644
--- a/kernel/fs/ext2.c
+++ b/kernel/fs/ext2.c
@@ -1,7 +1,7 @@
 #include <assert.h>
 #include <fs/ext2.h>
 #include <fs/vfs.h>
-#include <stdint.h>
+#include <typedefs.h>
 #include <string.h>
 
 #define EXT2_SUPERBLOCK_SECTOR 2
@@ -10,9 +10,9 @@
 #define BLOCKS_REQUIRED(_a, _b) ((_a) / (_b) + (((_a) % (_b)) != 0))
 
 superblock_t *superblock;
-uint32_t block_byte_size;
-uint32_t inode_size;
-uint32_t inodes_per_block;
+u32 block_byte_size;
+u32 inode_size;
+u32 inodes_per_block;
 
 #define BLOCK_SIZE (block_byte_size)
 
@@ -20,23 +20,23 @@ void ext2_close(vfs_fd_t *fd) {
   return; // There is nothing to clear
 }
 
-int read_inode(int inode_num, char *data, uint64_t size, uint64_t offset,
-               uint64_t *file_size);
+int read_inode(int inode_num, char *data, u64 size, u64 offset,
+               u64 *file_size);
 
-inline void get_inode_data_size(int inode_num, uint64_t *file_size) {
+inline void get_inode_data_size(int inode_num, u64 *file_size) {
   read_inode(inode_num, NULL, 0, 0, file_size);
 }
 
 struct BLOCK_CACHE {
-  uint32_t block_num;
-  uint8_t block[1024];
+  u32 block_num;
+  u8 block[1024];
 };
 
 #define NUM_BLOCK_CACHE 30
 struct BLOCK_CACHE cache[NUM_BLOCK_CACHE] = {0};
-uint8_t last_taken_cache = 0;
+u8 last_taken_cache = 0;
 
-void cached_read_block(uint32_t block, void *address, size_t size,
+void cached_read_block(u32 block, void *address, size_t size,
                        size_t offset) {
   int free_found = -1;
   for (int i = 0; i < NUM_BLOCK_CACHE; i++) {
@@ -61,12 +61,12 @@ void cached_read_block(uint32_t block, void *address, size_t size,
   cached_read_block(block, address, size, offset);
 }
 
-void ext2_read_block(uint32_t block, void *address, size_t size,
+void ext2_read_block(u32 block, void *address, size_t size,
                      size_t offset) {
   cached_read_block(block, address, size, offset);
 }
 
-void ext2_write_block(uint32_t block, void *address, size_t size,
+void ext2_write_block(u32 block, void *address, size_t size,
                       size_t offset) {
   // Invalidate a old cache
   for (int i = 0; i < NUM_BLOCK_CACHE; i++) {
@@ -78,19 +78,19 @@ void ext2_write_block(uint32_t block, void *address, size_t size,
   write_lba(block * block_byte_size / 512, address, size, offset);
 }
 
-void write_group_descriptor(uint32_t group_index, bgdt_t *block_group) {
+void write_group_descriptor(u32 group_index, bgdt_t *block_group) {
   int starting_block = (1024 == block_byte_size) ? 2 : 1;
   ext2_write_block(starting_block, block_group, sizeof(bgdt_t),
                    group_index * sizeof(bgdt_t));
 }
 
-void get_group_descriptor(uint32_t group_index, bgdt_t *block_group) {
+void get_group_descriptor(u32 group_index, bgdt_t *block_group) {
   int starting_block = (1024 == block_byte_size) ? 2 : 1;
   ext2_read_block(starting_block, block_group, sizeof(bgdt_t),
                   group_index * sizeof(bgdt_t));
 }
 
-uint32_t num_block_groups(void) {
+u32 num_block_groups(void) {
   // Determining the Number of Block Groups
 
   // From the Superblock, extract the size of each block, the total
@@ -101,17 +101,17 @@ uint32_t num_block_groups(void) {
 
   // Rounding up the total number of blocks divided by the number of
   // blocks per block group
-  uint32_t num_blocks = superblock->num_blocks;
-  uint32_t num_blocks_in_group = superblock->num_blocks_in_group;
-  uint32_t b = num_blocks / num_blocks_in_group;
+  u32 num_blocks = superblock->num_blocks;
+  u32 num_blocks_in_group = superblock->num_blocks_in_group;
+  u32 b = num_blocks / num_blocks_in_group;
   if (num_blocks % num_blocks_in_group != 0)
     b++;
 
   // Rounding up the total number of inodes divided by the number of
   // inodes per block group
-  uint32_t num_inodes = superblock->num_inodes;
-  uint32_t num_inodes_in_group = superblock->num_inodes_in_group;
-  uint32_t i = num_inodes / num_inodes_in_group;
+  u32 num_inodes = superblock->num_inodes;
+  u32 num_inodes_in_group = superblock->num_inodes_in_group;
+  u32 i = num_inodes / num_inodes_in_group;
   if (num_inodes % num_inodes_in_group != 0)
     i++;
   // Both (and check them against each other)
@@ -119,14 +119,14 @@ uint32_t num_block_groups(void) {
   return i;
 }
 
-void ext2_block_containing_inode(uint32_t inode_index, uint32_t *block_index,
-                                 uint32_t *offset) {
+void ext2_block_containing_inode(u32 inode_index, u32 *block_index,
+                                 u32 *offset) {
   assert(0 != inode_index);
   bgdt_t block_group;
   get_group_descriptor((inode_index - 1) / superblock->num_inodes_in_group,
                        &block_group);
 
-  uint64_t full_offset =
+  u64 full_offset =
       ((inode_index - 1) % superblock->num_inodes_in_group) * inode_size;
   *block_index = block_group.starting_inode_table +
                  (full_offset >> (superblock->block_size + 10));
@@ -143,11 +143,11 @@ void ext2_get_inode_header(int inode_index, inode_t *data) {
     memcpy(data, &ext2_last_inode, sizeof(inode_t));
     return;
   }
-  uint32_t block_index;
-  uint32_t block_offset;
+  u32 block_index;
+  u32 block_offset;
   ext2_block_containing_inode(inode_index, &block_index, &block_offset);
 
-  uint8_t mem_block[inode_size];
+  u8 mem_block[inode_size];
   ext2_read_block(block_index, mem_block, inode_size, block_offset);
 
   memcpy(data, mem_block, inode_size);
@@ -158,21 +158,21 @@ void ext2_get_inode_header(int inode_index, inode_t *data) {
 void ext2_write_inode(int inode_index, inode_t *data) {
   if (ext2_last_inode_read == inode_index)
     ext2_last_inode_read = -1; // Invalidate the cache
-  uint32_t block_index;
-  uint32_t block_offset;
+  u32 block_index;
+  u32 block_offset;
   ext2_block_containing_inode(inode_index, &block_index, &block_offset);
 
-  uint8_t mem_block[inode_size];
+  u8 mem_block[inode_size];
   memcpy(mem_block, data, inode_size);
   ext2_write_block(block_index, mem_block, inode_size, block_offset);
 }
 
 int ext2_get_inode_in_directory(int dir_inode, char *file,
                                 direntry_header_t *entry) {
-  uint64_t file_size;
+  u64 file_size;
   ASSERT_BUT_FIXME_PROPOGATE(-1 !=
                              read_inode(dir_inode, NULL, 0, 0, &file_size));
-  uint64_t allocation_size = file_size;
+  u64 allocation_size = file_size;
   char *data = kmalloc(allocation_size);
   ASSERT_BUT_FIXME_PROPOGATE(
       -1 != read_inode(dir_inode, data, allocation_size, 0, NULL));
@@ -200,7 +200,7 @@ int ext2_get_inode_in_directory(int dir_inode, char *file,
 }
 
 int ext2_read_dir(int dir_inode, char *buffer, size_t len, size_t offset) {
-  uint64_t file_size;
+  u64 file_size;
   get_inode_data_size(dir_inode, &file_size);
   char *data = kmalloc(file_size);
   read_inode(dir_inode, data, file_size, 0, NULL);
@@ -224,7 +224,7 @@ int ext2_read_dir(int dir_inode, char *buffer, size_t len, size_t offset) {
     memcpy(tmp_entry.d_name, data_p + sizeof(direntry_header_t),
            dir->name_length);
     tmp_entry.d_name[dir->name_length] = '\0';
-    uint8_t *p = (uint8_t *)&tmp_entry;
+    u8 *p = (u8 *)&tmp_entry;
     size_t l = sizeof(struct dirent);
 
     l = (len < l) ? len : l;
@@ -236,7 +236,7 @@ int ext2_read_dir(int dir_inode, char *buffer, size_t len, size_t offset) {
   return rc;
 }
 
-uint32_t ext2_find_inode(const char *file) {
+u32 ext2_find_inode(const char *file) {
   int cur_path_inode = EXT2_ROOT_INODE;
 
   if (*file == '/' && *(file + 1) == '\0')
@@ -279,27 +279,27 @@ uint32_t ext2_find_inode(const char *file) {
   return cur_path_inode;
 }
 
-uint32_t get_singly_block_index(uint32_t singly_block_ptr, uint32_t i) {
-  uint8_t block[block_byte_size];
+u32 get_singly_block_index(u32 singly_block_ptr, u32 i) {
+  u8 block[block_byte_size];
   ext2_read_block(singly_block_ptr, block, block_byte_size, 0);
-  uint32_t index = *(uint32_t *)(block + (i * (32 / 8)));
+  u32 index = *(u32 *)(block + (i * (32 / 8)));
   return index;
 }
 
-int get_block(inode_t *inode, uint32_t i) {
+int get_block(inode_t *inode, u32 i) {
   if (i < 12)
     return inode->block_pointers[i];
 
   i -= 12;
-  uint32_t singly_block_size = block_byte_size / (32 / 8);
-  uint32_t double_block_size = (singly_block_size * singly_block_size);
+  u32 singly_block_size = block_byte_size / (32 / 8);
+  u32 double_block_size = (singly_block_size * singly_block_size);
   if (i < singly_block_size) {
     return get_singly_block_index(inode->single_indirect_block_pointer, i);
   } else if (i < double_block_size) {
     i -= singly_block_size;
-    uint32_t singly_entry = get_singly_block_index(
+    u32 singly_entry = get_singly_block_index(
         inode->double_indirect_block_pointer, i / singly_block_size);
-    uint32_t offset_in_entry = i % singly_block_size;
+    u32 offset_in_entry = i % singly_block_size;
     int block = get_singly_block_index(singly_entry, offset_in_entry);
     return block;
   }
@@ -309,9 +309,9 @@ int get_block(inode_t *inode, uint32_t i) {
 
 int get_free_block(int allocate) {
   bgdt_t block_group;
-  uint8_t bitmap[BLOCK_SIZE];
+  u8 bitmap[BLOCK_SIZE];
   assert(0 < superblock->num_blocks_unallocated);
-  for (uint32_t g = 0; g < num_block_groups(); g++) {
+  for (u32 g = 0; g < num_block_groups(); g++) {
     get_group_descriptor(g, &block_group);
 
     if (block_group.num_unallocated_blocks_in_group == 0) {
@@ -320,7 +320,7 @@ int get_free_block(int allocate) {
     }
 
     ext2_read_block(block_group.block_usage_bitmap, bitmap, BLOCK_SIZE, 0);
-    for (uint32_t i = 0; i < superblock->num_blocks_in_group; i++) {
+    for (u32 i = 0; i < superblock->num_blocks_in_group; i++) {
       if (!(bitmap[i >> 3] & (1 << (i % 8)))) {
         if (allocate) {
           bitmap[i >> 3] |= (1 << (i % 8));
@@ -342,15 +342,15 @@ int get_free_block(int allocate) {
 int get_free_inode(int allocate) {
   bgdt_t block_group;
   assert(0 < superblock->num_inodes_unallocated);
-  for (uint32_t g = 0; g < num_block_groups(); g++) {
+  for (u32 g = 0; g < num_block_groups(); g++) {
     get_group_descriptor(g, &block_group);
 
     if (0 == block_group.num_unallocated_inodes_in_group)
       continue;
 
-    uint8_t bitmap[BLOCK_SIZE];
+    u8 bitmap[BLOCK_SIZE];
     ext2_read_block(block_group.inode_usage_bitmap, bitmap, BLOCK_SIZE, 0);
-    for (uint32_t i = 0; i < superblock->num_inodes_in_group; i++) {
+    for (u32 i = 0; i < superblock->num_inodes_in_group; i++) {
       if (!(bitmap[i / 8] & (1 << (i % 8)))) {
         if (allocate) {
           bitmap[i / 8] |= (1 << (i % 8));
@@ -369,20 +369,20 @@ int get_free_inode(int allocate) {
   return -1;
 }
 
-int write_inode(int inode_num, char *data, uint64_t size, uint64_t offset,
-                uint64_t *file_size, int append) {
+int write_inode(int inode_num, char *data, u64 size, u64 offset,
+                u64 *file_size, int append) {
   (void)file_size;
-  uint8_t inode_buffer[inode_size];
+  u8 inode_buffer[inode_size];
   ext2_get_inode_header(inode_num, (inode_t *)inode_buffer);
   inode_t *inode = (inode_t *)inode_buffer;
 
-  uint64_t fsize = (uint64_t)(((uint64_t)inode->_upper_32size << 32) |
-                              (uint64_t)inode->low_32size);
+  u64 fsize = (u64)(((u64)inode->_upper_32size << 32) |
+                              (u64)inode->low_32size);
   if (append)
     offset = fsize;
 
-  uint32_t block_start = offset / block_byte_size;
-  uint32_t block_offset = offset % block_byte_size;
+  u32 block_start = offset / block_byte_size;
+  u32 block_offset = offset % block_byte_size;
 
   int num_blocks_used = inode->num_disk_sectors / (BLOCK_SIZE / SECTOR_SIZE);
 
@@ -403,7 +403,7 @@ int write_inode(int inode_num, char *data, uint64_t size, uint64_t offset,
 
   int bytes_written = 0;
   for (int i = block_start; size; i++) {
-    uint32_t block = get_block(inode, i);
+    u32 block = get_block(inode, i);
     if (0 == block) {
       kprintf("block_not_found\n");
       break;
@@ -423,16 +423,16 @@ int write_inode(int inode_num, char *data, uint64_t size, uint64_t offset,
   return bytes_written;
 }
 
-int read_inode(int inode_num, char *data, uint64_t size, uint64_t offset,
-               uint64_t *file_size) {
+int read_inode(int inode_num, char *data, u64 size, u64 offset,
+               u64 *file_size) {
   // TODO: Fail if size is lower than the size of the file being read, and
   //       return the size of the file the callers is trying to read.
-  uint8_t inode_buffer[inode_size];
+  u8 inode_buffer[inode_size];
   ext2_get_inode_header(inode_num, (inode_t *)inode_buffer);
   inode_t *inode = (inode_t *)inode_buffer;
 
-  uint64_t fsize = (uint64_t)(((uint64_t)inode->_upper_32size << 32) |
-                              (uint64_t)inode->low_32size);
+  u64 fsize = (u64)(((u64)inode->_upper_32size << 32) |
+                              (u64)inode->low_32size);
 
   if (file_size)
     *file_size = fsize;
@@ -446,12 +446,12 @@ int read_inode(int inode_num, char *data, uint64_t size, uint64_t offset,
   if (offset > fsize)
     return 0;
 
-  uint32_t block_start = offset / block_byte_size;
-  uint32_t block_offset = offset % block_byte_size;
+  u32 block_start = offset / block_byte_size;
+  u32 block_offset = offset % block_byte_size;
 
   int bytes_read = 0;
   for (int i = block_start; size; i++) {
-    uint32_t block = get_block(inode, i);
+    u32 block = get_block(inode, i);
     if (0 == block) {
       klog("Filesystem EXT2: Unable to find block", LOG_WARN);
       return -1;
@@ -468,23 +468,23 @@ int read_inode(int inode_num, char *data, uint64_t size, uint64_t offset,
   return bytes_read;
 }
 
-size_t ext2_read_file_offset(const char *file, char *data, uint64_t size,
-                             uint64_t offset, uint64_t *file_size) {
+size_t ext2_read_file_offset(const char *file, char *data, u64 size,
+                             u64 offset, u64 *file_size) {
   // TODO: Fail if the file does not exist.
-  uint32_t inode = ext2_find_inode(file);
+  u32 inode = ext2_find_inode(file);
   return read_inode(inode, data, size, offset, file_size);
 }
 
 size_t ext2_read_file(const char *file, char *data, size_t size,
-                      uint64_t *file_size) {
+                      u64 *file_size) {
   return ext2_read_file_offset(file, data, size, 0, file_size);
 }
 
 int resolve_link(int inode_num) {
-  uint8_t tmp[inode_size];
+  u8 tmp[inode_size];
   inode_t *inode = (inode_t *)tmp;
-  uint64_t inode_size =
-      (((uint64_t)inode->_upper_32size) << 32) & inode->low_32size;
+  u64 inode_size =
+      (((u64)inode->_upper_32size) << 32) & inode->low_32size;
   assert(inode_size <= 60);
   ext2_get_inode_header(inode_num, inode);
   char *path = (char *)(tmp + (10 * 4));
@@ -493,8 +493,8 @@ int resolve_link(int inode_num) {
   return ext2_find_inode(path);
 }
 
-int ext2_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
-  uint64_t file_size;
+int ext2_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
+  u64 file_size;
   int rc;
   int inode_num = fd->inode->inode_num;
   assert(fd->inode->type != FS_TYPE_DIRECTORY);
@@ -505,8 +505,8 @@ int ext2_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
   return rc;
 }
 
-int ext2_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
-  uint64_t file_size;
+int ext2_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
+  u64 file_size;
   int rc;
   int inode_num = fd->inode->inode_num;
   if (fd->inode->type == FS_TYPE_DIRECTORY) {
@@ -536,16 +536,16 @@ int ext2_truncate(vfs_fd_t *fd, size_t length) {
 }
 
 vfs_inode_t *ext2_open(const char *path) {
-  uint32_t inode_num = ext2_find_inode(path);
+  u32 inode_num = ext2_find_inode(path);
   if (0 == inode_num)
     return NULL;
 
   inode_t ext2_inode[inode_size];
   ext2_get_inode_header(inode_num, ext2_inode);
-  uint64_t file_size =
-      ((uint64_t)(ext2_inode->_upper_32size) << 32) | ext2_inode->low_32size;
+  u64 file_size =
+      ((u64)(ext2_inode->_upper_32size) << 32) | ext2_inode->low_32size;
 
-  uint8_t type;
+  u8 type;
   switch ((ext2_inode->types_permissions / 0x1000)) {
   case 0xA:
     type = FS_TYPE_LINK;
@@ -565,17 +565,17 @@ vfs_inode_t *ext2_open(const char *path) {
                           NULL /*get_vm_object*/, ext2_truncate /*truncate*/);
 }
 
-uint64_t end_of_last_entry_position(int dir_inode, uint64_t *entry_offset,
+u64 end_of_last_entry_position(int dir_inode, u64 *entry_offset,
                                     direntry_header_t *meta) {
-  uint64_t file_size;
+  u64 file_size;
   get_inode_data_size(dir_inode, &file_size);
   char *data = kmalloc(file_size);
   read_inode(dir_inode, data, file_size, 0, NULL);
 
   direntry_header_t *dir;
   char *data_p = data;
-  uint64_t pos = 0;
-  uint64_t prev = pos;
+  u64 pos = 0;
+  u64 prev = pos;
   for (; pos < file_size && (dir = (direntry_header_t *)data_p)->size;
        data_p += dir->size, prev = pos, pos += dir->size)
     ;
@@ -589,11 +589,11 @@ uint64_t end_of_last_entry_position(int dir_inode, uint64_t *entry_offset,
 
 void ext2_create_entry(int directory_inode, direntry_header_t entry_header,
                        const char *name) {
-  uint64_t entry_offset = 0;
+  u64 entry_offset = 0;
   direntry_header_t meta;
   end_of_last_entry_position(directory_inode, &entry_offset, &meta);
 
-  uint32_t padding_in_use = block_byte_size - entry_offset;
+  u32 padding_in_use = block_byte_size - entry_offset;
 
   //  assert(padding_in_use == meta.size);
   assert(padding_in_use >=
@@ -606,17 +606,17 @@ void ext2_create_entry(int directory_inode, direntry_header_t entry_header,
               entry_offset, NULL, 0);
 
   // Create new entry
-  uint32_t new_entry_offset = entry_offset + meta.size;
+  u32 new_entry_offset = entry_offset + meta.size;
   entry_header.size = (sizeof(direntry_header_t) + entry_header.name_length);
   entry_header.size += (4 - (entry_header.size % 4));
 
-  uint32_t length_till_next_block = 1024 - (new_entry_offset % 1024);
+  u32 length_till_next_block = 1024 - (new_entry_offset % 1024);
   if (0 == length_till_next_block)
     length_till_next_block = 1024;
   assert(entry_header.size < length_till_next_block);
   entry_header.size = length_till_next_block;
 
-  uint8_t buffer[entry_header.size];
+  u8 buffer[entry_header.size];
   memset(buffer, 0, entry_header.size);
   memcpy(buffer, &entry_header, sizeof(entry_header));
   memcpy(buffer + sizeof(entry_header), name, entry_header.name_length);
@@ -624,7 +624,7 @@ void ext2_create_entry(int directory_inode, direntry_header_t entry_header,
               new_entry_offset, NULL, 0);
 }
 
-int ext2_find_parent(char *path, uint32_t *parent_inode, char **filename) {
+int ext2_find_parent(char *path, u32 *parent_inode, char **filename) {
   char *e = path;
   for (; *e; e++)
     ;
@@ -648,13 +648,13 @@ int ext2_find_parent(char *path, uint32_t *parent_inode, char **filename) {
 int ext2_create_directory(const char *path, int mode) {
   (void)mode;
   // Check if the directory already exists
-  uint32_t inode_num = ext2_find_inode(path);
+  u32 inode_num = ext2_find_inode(path);
   if (0 != inode_num) {
     klog("ext2_create_directory: Directory already exists", LOG_WARN);
     return inode_num;
   }
 
-  uint32_t parent_inode;
+  u32 parent_inode;
   // Get the parent directory
   char path_buffer[strlen(path) + 1];
   char *filename;
@@ -679,7 +679,7 @@ int ext2_create_directory(const char *path, int mode) {
 
   ext2_create_entry(parent_inode, entry_header, filename);
   // Create the inode header
-  uint8_t inode_buffer[inode_size];
+  u8 inode_buffer[inode_size];
   inode_t *new_inode = (inode_t *)inode_buffer;
   memset(inode_buffer, 0, inode_size);
   new_inode->types_permissions = DIRECTORY;
@@ -708,13 +708,13 @@ int ext2_create_directory(const char *path, int mode) {
 
 int ext2_create_file(const char *path, int mode) {
   // Check if the file already exists
-  uint32_t inode_num = ext2_find_inode(path);
+  u32 inode_num = ext2_find_inode(path);
   if (0 != inode_num) {
     klog("ext2_create_file: File already exists", LOG_WARN);
     return inode_num;
   }
 
-  uint32_t parent_inode;
+  u32 parent_inode;
   // Get the parent directory
   char path_buffer[strlen(path) + 1];
   char *filename;
@@ -739,7 +739,7 @@ int ext2_create_file(const char *path, int mode) {
 
   ext2_create_entry(parent_inode, entry_header, filename);
   // Create the inode header
-  uint8_t inode_buffer[inode_size];
+  u8 inode_buffer[inode_size];
   inode_t *new_inode = (inode_t *)inode_buffer;
   memset(inode_buffer, 0, inode_size);
   new_inode->types_permissions = 0x8000;
diff --git a/kernel/fs/ext2.h b/kernel/fs/ext2.h
index 4b4dec0..575a000 100644
--- a/kernel/fs/ext2.h
+++ b/kernel/fs/ext2.h
@@ -3,97 +3,97 @@
 #include <drivers/ata.h>
 #include <fs/vfs.h>
 #include <kmalloc.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 typedef struct Superblock {
-  uint32_t num_inodes;
-  uint32_t num_blocks;
-  uint32_t num_blocks_reserved;
-  uint32_t num_blocks_unallocated;
-  uint32_t num_inodes_unallocated;
-  uint32_t superblock_block_num;
-  uint32_t block_size;
-  uint32_t fragment_size;
-  uint32_t num_blocks_in_group;
-  uint32_t num_fragments_in_group;
-  uint32_t num_inodes_in_group;
-  uint32_t last_mount;
-  uint32_t last_write;
-  uint16_t num_mounts_since_fsck;
-  uint16_t num_mounts_allowed;
-  uint16_t ext2_signature; // 0xEF53
-  uint16_t fs_state;
-  uint16_t when_error;
-  uint16_t minor_version;
-  uint32_t last_fsck;
-  uint32_t interval_fsck;
-  uint32_t os_id;
-  uint32_t major_version;
-  uint16_t userid_reserved_blocks;
-  uint16_t groupid_reserved_blocks;
+  u32 num_inodes;
+  u32 num_blocks;
+  u32 num_blocks_reserved;
+  u32 num_blocks_unallocated;
+  u32 num_inodes_unallocated;
+  u32 superblock_block_num;
+  u32 block_size;
+  u32 fragment_size;
+  u32 num_blocks_in_group;
+  u32 num_fragments_in_group;
+  u32 num_inodes_in_group;
+  u32 last_mount;
+  u32 last_write;
+  u16 num_mounts_since_fsck;
+  u16 num_mounts_allowed;
+  u16 ext2_signature; // 0xEF53
+  u16 fs_state;
+  u16 when_error;
+  u16 minor_version;
+  u32 last_fsck;
+  u32 interval_fsck;
+  u32 os_id;
+  u32 major_version;
+  u16 userid_reserved_blocks;
+  u16 groupid_reserved_blocks;
 } __attribute__((packed)) superblock_t;
 
 typedef struct ExtendedSuperblock {
-  uint32_t num_inodes;
-  uint32_t num_blocks;
-  uint32_t num_blocks_reserved;
-  uint32_t num_blocks_unallocated;
-  uint32_t num_inodes_unallocated;
-  uint32_t superblock_block_num;
-  uint32_t block_size;
-  uint32_t fragment_size;
-  uint32_t num_blocks_group;
-  uint32_t num_fragments_group;
-  uint32_t num_inodes_group;
-  uint32_t last_mount;
-  uint32_t last_write;
-  uint16_t num_mounts_since_fsck;
-  uint16_t num_mounts_allowed;
-  uint16_t ext2_signature; // 0xEF53
-  uint16_t fs_state;
-  uint16_t when_error;
-  uint16_t minor_version;
-  uint32_t last_fsck;
-  uint32_t interval_fsck;
-  uint32_t os_id;
-  uint32_t major_version;
-  uint16_t userid_reserved_blocks;
-  uint16_t groupid_reserved_blocks;
-  uint32_t pad;
-  uint16_t inode_size;
+  u32 num_inodes;
+  u32 num_blocks;
+  u32 num_blocks_reserved;
+  u32 num_blocks_unallocated;
+  u32 num_inodes_unallocated;
+  u32 superblock_block_num;
+  u32 block_size;
+  u32 fragment_size;
+  u32 num_blocks_group;
+  u32 num_fragments_group;
+  u32 num_inodes_group;
+  u32 last_mount;
+  u32 last_write;
+  u16 num_mounts_since_fsck;
+  u16 num_mounts_allowed;
+  u16 ext2_signature; // 0xEF53
+  u16 fs_state;
+  u16 when_error;
+  u16 minor_version;
+  u32 last_fsck;
+  u32 interval_fsck;
+  u32 os_id;
+  u32 major_version;
+  u16 userid_reserved_blocks;
+  u16 groupid_reserved_blocks;
+  u32 pad;
+  u16 inode_size;
 } __attribute__((packed)) ext_superblock_t;
 
 typedef struct BlockGroupDescriptorTable {
-  uint32_t block_usage_bitmap;
-  uint32_t inode_usage_bitmap;
-  uint32_t starting_inode_table;
-  uint16_t num_unallocated_blocks_in_group;
-  uint16_t num_unallocated_inodes_in_group;
-  uint16_t num_directories_group;
+  u32 block_usage_bitmap;
+  u32 inode_usage_bitmap;
+  u32 starting_inode_table;
+  u16 num_unallocated_blocks_in_group;
+  u16 num_unallocated_inodes_in_group;
+  u16 num_directories_group;
 } __attribute__((packed)) bgdt_t;
 
 typedef struct INode {
-  uint16_t types_permissions;
-  uint16_t user_id;
-  uint32_t low_32size;
-  uint32_t last_access_time;
-  uint32_t creation_time;
-  uint32_t last_modification_time;
-  uint32_t deletion_time;
-  uint16_t group_id;
-  uint16_t num_hard_links;
-  uint32_t num_disk_sectors;
-  uint32_t flags;
-  uint32_t os_specific;
-  uint32_t block_pointers[12];
-  uint32_t single_indirect_block_pointer;
-  uint32_t double_indirect_block_pointer;
-  uint32_t triple_indirect_block_pointer;
-  uint32_t gen_number;
-  uint32_t _extended_attribute_block;
-  uint32_t _upper_32size;
-  uint32_t address_fragment;
-  uint32_t os_specific2;
+  u16 types_permissions;
+  u16 user_id;
+  u32 low_32size;
+  u32 last_access_time;
+  u32 creation_time;
+  u32 last_modification_time;
+  u32 deletion_time;
+  u16 group_id;
+  u16 num_hard_links;
+  u32 num_disk_sectors;
+  u32 flags;
+  u32 os_specific;
+  u32 block_pointers[12];
+  u32 single_indirect_block_pointer;
+  u32 double_indirect_block_pointer;
+  u32 triple_indirect_block_pointer;
+  u32 gen_number;
+  u32 _extended_attribute_block;
+  u32 _upper_32size;
+  u32 address_fragment;
+  u32 os_specific2;
 } __attribute__((packed)) inode_t;
 
 // 0    Unknown type
@@ -122,18 +122,18 @@ typedef struct INode {
 #define UNIX_SOCKET 0xC000
 
 typedef struct DirectoryEntryHeader {
-  uint32_t inode;
-  uint16_t size;
-  uint8_t name_length;
-  uint8_t type_indicator;
+  u32 inode;
+  u16 size;
+  u8 name_length;
+  u8 type_indicator;
 } __attribute__((packed)) direntry_header_t;
 
 int ext2_create_file(const char *path, int mode);
 vfs_inode_t *ext2_mount(void);
 void parse_superblock(void);
-size_t ext2_read_file_offset(const char *file, char *data, uint64_t size,
-                             uint64_t offset, uint64_t *file_size);
+size_t ext2_read_file_offset(const char *file, char *data, u64 size,
+                             u64 offset, u64 *file_size);
 size_t ext2_read_file(const char *file, char *data, size_t size,
-                      uint64_t *file_size);
+                      u64 *file_size);
 int ext2_create_directory(const char *path, int mode);
 #endif
diff --git a/kernel/fs/fifo.c b/kernel/fs/fifo.c
index d515ed7..5033717 100644
--- a/kernel/fs/fifo.c
+++ b/kernel/fs/fifo.c
@@ -9,7 +9,7 @@ void fifo_close(vfs_fd_t *fd) {
   return;
 }
 
-int fifo_object_write(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fifo_object_write(u8 *buffer, u64 offset, u64 len,
                       FIFO_FILE *file) {
   (void)offset;
   file->has_data = 1;
@@ -22,7 +22,7 @@ int fifo_object_write(uint8_t *buffer, uint64_t offset, uint64_t len,
   return len;
 }
 
-int fifo_object_read(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fifo_object_read(u8 *buffer, u64 offset, u64 len,
                      FIFO_FILE *file) {
   (void)offset;
   if (file->write_len == 0) {
@@ -78,7 +78,7 @@ int create_fifo(void) {
   return fd_n;
 }
 
-int fifo_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int fifo_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)offset;
   FIFO_FILE *file = (FIFO_FILE *)fd->inode->internal_object;
   int rc = fifo_object_write(buffer, offset, len, file);
@@ -87,7 +87,7 @@ int fifo_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
   return rc;
 }
 
-int fifo_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int fifo_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   FIFO_FILE *file = (FIFO_FILE *)fd->inode->internal_object;
   file->is_blocking = !(fd->flags & O_NONBLOCK);
   int rc = fifo_object_read(buffer, offset, len, file);
diff --git a/kernel/fs/fifo.h b/kernel/fs/fifo.h
index 1ba7168..e504c9a 100644
--- a/kernel/fs/fifo.h
+++ b/kernel/fs/fifo.h
@@ -3,25 +3,25 @@ typedef struct S_FIFO_FILE FIFO_FILE;
 #define FIFO_H
 #include "vfs.h"
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 struct S_FIFO_FILE {
   char *buffer;
-  uint64_t buffer_len;
-  uint64_t write_len;
-  uint8_t is_blocking;
-  uint8_t has_data;
-  uint8_t can_write;
+  u64 buffer_len;
+  u64 write_len;
+  u8 is_blocking;
+  u8 has_data;
+  u8 can_write;
 };
 
 int create_fifo(void);
 FIFO_FILE *create_fifo_object(void);
-int fifo_object_write(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fifo_object_write(u8 *buffer, u64 offset, u64 len,
                       FIFO_FILE *file);
-int fifo_object_read(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fifo_object_read(u8 *buffer, u64 offset, u64 len,
                      FIFO_FILE *file);
-int fifo_write(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fifo_write(u8 *buffer, u64 offset, u64 len,
                vfs_fd_t *fd);
-int fifo_read(uint8_t *buffer, uint64_t offset, uint64_t len,
+int fifo_read(u8 *buffer, u64 offset, u64 len,
               vfs_fd_t *fd);
 #endif
diff --git a/kernel/fs/shm.c b/kernel/fs/shm.c
index 4d5f2ab..1bbe07f 100644
--- a/kernel/fs/shm.c
+++ b/kernel/fs/shm.c
@@ -11,7 +11,7 @@ HashMap *shared_memory_objects;
 
 void shm_init(void) { shared_memory_objects = hashmap_create(10); }
 
-int shm_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int shm_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   vfs_vm_object_t *p = fd->inode->internal_object;
 
   if (offset > p->size)
@@ -25,7 +25,7 @@ int shm_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
   return len;
 }
 
-int shm_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int shm_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   vfs_vm_object_t *p = fd->inode->internal_object;
 
   if (offset > p->size)
@@ -39,7 +39,7 @@ int shm_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
   return len;
 }
 
-vfs_vm_object_t *shm_get_vm_object(uint64_t length, uint64_t offset,
+vfs_vm_object_t *shm_get_vm_object(u64 length, u64 offset,
                                    vfs_fd_t *fd) {
   (void)length;
   (void)offset;
@@ -51,7 +51,7 @@ int shm_ftruncate(vfs_fd_t *fd, size_t length) {
   vfs_vm_object_t *p = fd->inode->internal_object;
   p->size = length;
   p->virtual_object = ksbrk(length);
-  int n = (uintptr_t)align_page((void *)(uint32_t)length) / 0x1000;
+  int n = (uintptr_t)align_page((void *)(u32)length) / 0x1000;
   p->object = kmalloc(sizeof(void *) * n);
   for (int i = 0; i < n; i++)
     p->object[i] =
diff --git a/kernel/fs/shm.h b/kernel/fs/shm.h
index fbbdb5c..977c18f 100644
--- a/kernel/fs/shm.h
+++ b/kernel/fs/shm.h
@@ -1,13 +1,13 @@
 #ifndef SHM_H
 #define SHM_H
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 typedef int mode_t;
 
 void shm_init(void);
 int shm_open(const char *name, int oflag, mode_t mode);
 int shm_unlink(const char *name);
-int ftruncate(int fildes, uint64_t length);
+int ftruncate(int fildes, u64 length);
 
 #endif
diff --git a/kernel/fs/tmpfs.c b/kernel/fs/tmpfs.c
index a9a3c1f..0996507 100644
--- a/kernel/fs/tmpfs.c
+++ b/kernel/fs/tmpfs.c
@@ -4,14 +4,14 @@
 #include <fs/tmpfs.h>
 #include <halts.h>
 #include <sched/scheduler.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 void tmp_close(vfs_fd_t *fd) {
   fd->inode->is_open = 0;
   ((tmp_inode *)fd->inode->internal_object)->read_inode->is_open = 0;
 }
 
-int tmp_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int tmp_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   tmp_inode *calling_file = fd->inode->internal_object;
   tmp_inode *child_file = calling_file->read_inode->internal_object;
   if (child_file->is_closed)
@@ -23,7 +23,7 @@ int tmp_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
   return rc;
 }
 
-int tmp_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int tmp_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   tmp_inode *calling_file = fd->inode->internal_object;
   tmp_inode *child_file = calling_file->read_inode->internal_object;
   if (calling_file->is_closed)
diff --git a/kernel/fs/tmpfs.h b/kernel/fs/tmpfs.h
index 4052bd5..81ba0ef 100644
--- a/kernel/fs/tmpfs.h
+++ b/kernel/fs/tmpfs.h
@@ -7,7 +7,7 @@
 
 typedef struct {
   FIFO_FILE *fifo;
-  uint8_t is_closed;
+  u8 is_closed;
   vfs_inode_t *read_inode;
 } tmp_inode;
 
diff --git a/kernel/fs/vfs.c b/kernel/fs/vfs.c
index 0c616a2..0c62db8 100644
--- a/kernel/fs/vfs.c
+++ b/kernel/fs/vfs.c
@@ -23,15 +23,15 @@ vfs_fd_t *get_vfs_fd(int fd) {
 }
 
 vfs_inode_t *vfs_create_inode(
-    int inode_num, int type, uint8_t has_data, uint8_t can_write,
-    uint8_t is_open, void *internal_object, uint64_t file_size,
+    int inode_num, int type, u8 has_data, u8 can_write,
+    u8 is_open, void *internal_object, u64 file_size,
     vfs_inode_t *(*open)(const char *path),
     int (*create_file)(const char *path, int mode),
-    int (*read)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
-    int (*write)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
+    int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
     void (*close)(vfs_fd_t *fd),
     int (*create_directory)(const char *path, int mode),
-    vfs_vm_object_t *(*get_vm_object)(uint64_t length, uint64_t offset,
+    vfs_vm_object_t *(*get_vm_object)(u64 length, u64 offset,
                                       vfs_fd_t *fd),
     int (*truncate)(vfs_fd_t *fd, size_t length)) {
   vfs_inode_t *r = kmalloc(sizeof(inode_t));
@@ -226,14 +226,14 @@ int vfs_close(int fd) {
   return 0;
 }
 
-int raw_vfs_pread(vfs_fd_t *vfs_fd, void *buf, uint64_t count,
-                  uint64_t offset) {
+int raw_vfs_pread(vfs_fd_t *vfs_fd, void *buf, u64 count,
+                  u64 offset) {
   if (!(vfs_fd->flags & O_READ))
     return -EBADF;
   return vfs_fd->inode->read(buf, offset, count, vfs_fd);
 }
 
-int vfs_pread(int fd, void *buf, uint64_t count, uint64_t offset) {
+int vfs_pread(int fd, void *buf, u64 count, u64 offset) {
   if (fd >= 100) {
     kprintf("EBADF : %x\n", fd);
     return -EBADF;
@@ -260,15 +260,15 @@ int vfs_pread(int fd, void *buf, uint64_t count, uint64_t offset) {
   return rc;
 }
 
-int raw_vfs_pwrite(vfs_fd_t *vfs_fd, void *buf, uint64_t count,
-                   uint64_t offset) {
+int raw_vfs_pwrite(vfs_fd_t *vfs_fd, void *buf, u64 count,
+                   u64 offset) {
   assert(vfs_fd);
   assert(vfs_fd->inode);
   assert(vfs_fd->inode->write);
   return vfs_fd->inode->write(buf, offset, count, vfs_fd);
 }
 
-int vfs_pwrite(int fd, void *buf, uint64_t count, uint64_t offset) {
+int vfs_pwrite(int fd, void *buf, u64 count, u64 offset) {
   vfs_fd_t *vfs_fd = get_vfs_fd(fd);
   if (!vfs_fd)
     return -EBADF;
@@ -278,7 +278,7 @@ int vfs_pwrite(int fd, void *buf, uint64_t count, uint64_t offset) {
   return raw_vfs_pwrite(vfs_fd, buf, count, offset);
 }
 
-vfs_vm_object_t *vfs_get_vm_object(int fd, uint64_t length, uint64_t offset) {
+vfs_vm_object_t *vfs_get_vm_object(int fd, u64 length, u64 offset) {
   vfs_fd_t *vfs_fd = get_vfs_fd(fd);
   if (!vfs_fd)
     return NULL;
diff --git a/kernel/fs/vfs.h b/kernel/fs/vfs.h
index f8a4b19..0ce5cd1 100644
--- a/kernel/fs/vfs.h
+++ b/kernel/fs/vfs.h
@@ -8,7 +8,7 @@ typedef struct vfs_mounts vfs_mounts_t;
 #include <sched/scheduler.h>
 #include <socket.h>
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 // FIXME: Is there some standard value for this?
 #define O_NONBLOCK (1 << 0)
@@ -29,7 +29,7 @@ typedef struct vfs_mounts vfs_mounts_t;
 struct vfs_vm_object {
   void *virtual_object;
   void **object;
-  uint64_t size;
+  u64 size;
 };
 
 struct vfs_mounts {
@@ -55,18 +55,18 @@ struct vfs_fd {
 struct vfs_inode {
   int inode_num;
   int type;
-  uint8_t has_data;
-  uint8_t can_write;
-  uint8_t is_open;
+  u8 has_data;
+  u8 can_write;
+  u8 is_open;
   void *internal_object;
-  uint64_t file_size;
+  u64 file_size;
   vfs_inode_t *(*open)(const char *path);
   int (*create_file)(const char *path, int mode);
-  int (*read)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd);
-  int (*write)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd);
+  int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd);
+  int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd);
   void (*close)(vfs_fd_t *fd);
   int (*create_directory)(const char *path, int mode);
-  vfs_vm_object_t *(*get_vm_object)(uint64_t length, uint64_t offset,
+  vfs_vm_object_t *(*get_vm_object)(u64 length, u64 offset,
                                     vfs_fd_t *fd);
   int (*truncate)(vfs_fd_t *fd, size_t length);
 };
@@ -75,26 +75,26 @@ int vfs_close(int fd);
 vfs_fd_t *get_vfs_fd(int fd);
 int vfs_open(const char *file, int flags, int mode);
 void vfs_mount(char *path, vfs_inode_t *local_root);
-int vfs_pwrite(int fd, void *buf, uint64_t count, uint64_t offset);
-int raw_vfs_pwrite(vfs_fd_t *vfs_fd, void *buf, uint64_t count,
-                   uint64_t offset);
-int vfs_pread(int fd, void *buf, uint64_t count, uint64_t offset);
-vfs_vm_object_t *vfs_get_vm_object(int fd, uint64_t length, uint64_t offset);
+int vfs_pwrite(int fd, void *buf, u64 count, u64 offset);
+int raw_vfs_pwrite(vfs_fd_t *vfs_fd, void *buf, u64 count,
+                   u64 offset);
+int vfs_pread(int fd, void *buf, u64 count, u64 offset);
+vfs_vm_object_t *vfs_get_vm_object(int fd, u64 length, u64 offset);
 int vfs_dup2(int org_fd, int new_fd);
 vfs_inode_t *vfs_internal_open(const char *file);
 int vfs_mkdir(const char *path, int mode);
 int vfs_create_fd(int flags, int mode, vfs_inode_t *inode, vfs_fd_t **fd);
 int vfs_ftruncate(int fd, size_t length);
 vfs_inode_t *vfs_create_inode(
-    int inode_num, int type, uint8_t has_data, uint8_t can_write,
-    uint8_t is_open, void *internal_object, uint64_t file_size,
+    int inode_num, int type, u8 has_data, u8 can_write,
+    u8 is_open, void *internal_object, u64 file_size,
     vfs_inode_t *(*open)(const char *path),
     int (*create_file)(const char *path, int mode),
-    int (*read)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
-    int (*write)(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd),
+    int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
     void (*close)(vfs_fd_t *fd),
     int (*create_directory)(const char *path, int mode),
-    vfs_vm_object_t *(*get_vm_object)(uint64_t length, uint64_t offset,
+    vfs_vm_object_t *(*get_vm_object)(u64 length, u64 offset,
                                       vfs_fd_t *fd),
     int (*truncate)(vfs_fd_t *fd, size_t length));
 #endif
diff --git a/kernel/halts.h b/kernel/halts.h
index bd71673..11e47ff 100644
--- a/kernel/halts.h
+++ b/kernel/halts.h
@@ -1,11 +1,11 @@
 #ifndef HALTS_H
 #define HALTS_H
 #include <fs/vfs.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 typedef struct {
-  uint8_t *ptr;
-  uint8_t active;
+  u8 *ptr;
+  u8 active;
 } halt_t;
 
 int create_read_fdhalt(vfs_fd_t *fd);
diff --git a/kernel/hashmap/hashmap.c b/kernel/hashmap/hashmap.c
index 2eeef98..72524e7 100644
--- a/kernel/hashmap/hashmap.c
+++ b/kernel/hashmap/hashmap.c
@@ -17,7 +17,7 @@
  * one that can be found in hash.c. But it should be possible to use any
  * other hashing algorithm should you want to as long as it uses these
  * types:
- * uint32_t hash_function(uint8_t*, size_t)
+ * u32 hash_function(u8*, size_t)
  *
  * The hashing algorithm can be changed via changing the "hash_function"
  * pointer in the HashMap structure.
@@ -35,7 +35,7 @@
 
 #define CONSTANT 0x031b5515
 
-uint32_t mix(uint32_t x) {
+u32 mix(u32 x) {
   x ^= CONSTANT;
   x ^= (x << 13);
   x ^= (x >> 7);
@@ -43,11 +43,11 @@ uint32_t mix(uint32_t x) {
   return x;
 }
 
-uint32_t hash(const uint8_t *data, size_t len) {
-  uint32_t hash = 0;
+u32 hash(const u8 *data, size_t len) {
+  u32 hash = 0;
   for (; len;) {
-    uint32_t value = 0;
-    uint8_t read_len = (sizeof(uint32_t) < len) ? sizeof(uint32_t) : len;
+    u32 value = 0;
+    u8 read_len = (sizeof(u32) < len) ? sizeof(u32) : len;
     memcpy(&value, data, read_len);
     hash ^= mix(value);
     data += read_len;
@@ -67,7 +67,7 @@ char *copy_c_string(const char *str) {
   return ret_string;
 }
 
-uint32_t limit_hash(HashMap *m, uint32_t hash) { return hash % m->size; }
+u32 limit_hash(HashMap *m, u32 hash) { return hash % m->size; }
 
 void free_linkedlist_entry(LinkedList *entry) {
   if (entry->key_allocated) {
@@ -104,8 +104,8 @@ void *get_linkedlist_value(LinkedList *list, const char *key) {
   return entry->value;
 }
 
-uint32_t find_index(HashMap *m, const char *key) {
-  return limit_hash(m, m->hash_function((uint8_t *)key, strlen(key)));
+u32 find_index(HashMap *m, const char *key) {
+  return limit_hash(m, m->hash_function((u8 *)key, strlen(key)));
 }
 
 int hashmap_add_entry(HashMap *m, const char *key, void *value,
@@ -128,7 +128,7 @@ int hashmap_add_entry(HashMap *m, const char *key, void *value,
   entry->upon_deletion = upon_deletion;
 
   // Add the new entry to the list.
-  uint32_t index = find_index(m, key);
+  u32 index = find_index(m, key);
   LinkedList **list_pointer = &m->entries[index];
   for (; *list_pointer;)
     list_pointer = &(*list_pointer)->next;
@@ -139,7 +139,7 @@ int hashmap_add_entry(HashMap *m, const char *key, void *value,
 }
 
 void *hashmap_get_entry(HashMap *m, const char *key) {
-  uint32_t index = find_index(m, key);
+  u32 index = find_index(m, key);
   if (!m->entries[index])
     return NULL;
   return get_linkedlist_value(m->entries[index], key);
diff --git a/kernel/hashmap/hashmap.h b/kernel/hashmap/hashmap.h
index 40f146a..d4556dc 100644
--- a/kernel/hashmap/hashmap.h
+++ b/kernel/hashmap/hashmap.h
@@ -6,7 +6,7 @@
 #ifndef HASHMAP_H
 #define HASHMAP_H
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 typedef struct LinkedList {
   const char *key;
@@ -20,7 +20,7 @@ typedef struct HashMap {
   LinkedList **entries;
   size_t size;
   size_t num_entries;
-  uint32_t (*hash_function)(const uint8_t *data, size_t len);
+  u32 (*hash_function)(const u8 *data, size_t len);
 } HashMap;
 
 HashMap *hashmap_create(size_t size);
diff --git a/kernel/includes/mmu.h b/kernel/includes/mmu.h
index f3af5e4..c9b682f 100644
--- a/kernel/includes/mmu.h
+++ b/kernel/includes/mmu.h
@@ -1,9 +1,9 @@
 #ifndef PAGING_H
 #define PAGING_H
 #include "kmalloc.h"
-#include <stdint.h>
+#include <typedefs.h>
 
-typedef uint8_t mmu_flags;
+typedef u8 mmu_flags;
 
 #define MMU_FLAG_RW (1 << 0)
 #define MMU_FLAG_KERNEL (1 << 1)
@@ -12,13 +12,13 @@ void *next_page(void *a);
 void *align_page(void *a);
 
 typedef struct Page {
-  uint32_t present : 1;
-  uint32_t rw : 1;
-  uint32_t user : 1;
-  uint32_t accessed : 1;
-  uint32_t dirty : 1;
-  uint32_t unused : 7;
-  uint32_t frame : 20;
+  u32 present : 1;
+  u32 rw : 1;
+  u32 user : 1;
+  u32 accessed : 1;
+  u32 dirty : 1;
+  u32 unused : 7;
+  u32 frame : 20;
 } __attribute__((packed)) Page;
 
 typedef struct PageTable {
@@ -27,8 +27,8 @@ typedef struct PageTable {
 
 typedef struct PageDirectory {
   PageTable *tables[1024];
-  uint32_t physical_tables[1024];
-  uint32_t physical_address;
+  u32 physical_tables[1024];
+  u32 physical_address;
 } PageDirectory;
 
 int mmu_allocate_region(void *ptr, size_t n, mmu_flags flags,
@@ -39,16 +39,16 @@ void mmu_remove_virtual_physical_address_mapping(void *ptr, size_t length);
 void mmu_free_address_range(void *ptr, size_t length);
 void mmu_map_directories(void *dst, PageDirectory *d, void *src,
                          PageDirectory *s, size_t length);
-uint32_t mmu_get_number_of_allocated_frames(void);
+u32 mmu_get_number_of_allocated_frames(void);
 void *mmu_map_frames(void *ptr, size_t s);
 void mmu_map_physical(void *dst, PageDirectory *d, void *physical,
                       size_t length);
-void mmu_free_pages(void *a, uint32_t n);
+void mmu_free_pages(void *a, u32 n);
 
 void flush_tlb(void);
-void paging_init(uint64_t memsize);
+void paging_init(u64 memsize);
 PageDirectory *get_active_pagedirectory(void);
-void move_stack(uint32_t new_stack_address, uint32_t size);
+void move_stack(u32 new_stack_address, u32 size);
 void switch_page_directory(PageDirectory *directory);
 void *allocate_frame(Page *page, int rw, int is_kernel);
 PageDirectory *clone_directory(PageDirectory *original);
diff --git a/kernel/init/kernel.c b/kernel/init/kernel.c
index 9fe7ac4..217967a 100644
--- a/kernel/init/kernel.c
+++ b/kernel/init/kernel.c
@@ -22,9 +22,10 @@
 #include <sched/scheduler.h>
 #include <stdbool.h>
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 #include <stdio.h>
 #include <string.h>
+#include <typedefs.h>
 
 #if defined(__linux__)
 #error "You are not using a cross-compiler."
@@ -34,11 +35,11 @@
 #error "This OS needs to be compiled with a ix86-elf compiler"
 #endif
 
-uint32_t inital_esp;
+u32 inital_esp;
 uintptr_t data_end;
 
-void kernel_main(uint32_t kernel_end, unsigned long magic, unsigned long addr,
-                 uint32_t inital_stack) {
+void kernel_main(u32 kernel_end, unsigned long magic, unsigned long addr,
+                 u32 inital_stack) {
   (void)kernel_end;
   data_end = 0xc0400000;
   inital_esp = inital_stack;
@@ -48,9 +49,9 @@ void kernel_main(uint32_t kernel_end, unsigned long magic, unsigned long addr,
   assert(magic == MULTIBOOT_BOOTLOADER_MAGIC);
 
   multiboot_info_t *mb = (multiboot_info_t *)(addr + 0xc0000000);
-  uint32_t mem_kb = mb->mem_lower;
-  uint32_t mem_mb = (mb->mem_upper - 1000) / 1000;
-  uint64_t memsize_kb = mem_mb * 1000 + mem_kb;
+  u32 mem_kb = mb->mem_lower;
+  u32 mem_mb = (mb->mem_upper - 1000) / 1000;
+  u64 memsize_kb = mem_mb * 1000 + mem_kb;
   paging_init(memsize_kb);
   klog("Paging Initalized", LOG_SUCCESS);
   mb = mmu_map_frames((multiboot_info_t *)addr, sizeof(multiboot_info_t));
diff --git a/kernel/kmalloc.c b/kernel/kmalloc.c
index 75bc74b..2fb4f03 100644
--- a/kernel/kmalloc.c
+++ b/kernel/kmalloc.c
@@ -9,17 +9,17 @@
 #define IS_FINAL (1 << 1)
 
 typedef struct MallocHeader {
-  uint64_t magic;
-  uint32_t size;
-  uint8_t flags;
+  u64 magic;
+  u32 size;
+  u8 flags;
   struct MallocHeader *n;
 } MallocHeader;
 
-uint64_t delta_page(uint64_t a) { return 0x1000 - (a % 0x1000); }
+u64 delta_page(u64 a) { return 0x1000 - (a % 0x1000); }
 
 MallocHeader *head = NULL;
 MallocHeader *final = NULL;
-uint32_t total_heap_size = 0;
+u32 total_heap_size = 0;
 
 int init_heap(void) {
   head = (MallocHeader *)ksbrk(NEW_ALLOC_SIZE);
@@ -42,7 +42,7 @@ int add_heap_memory(size_t min_desired) {
   }
   total_heap_size += allocation_size - sizeof(MallocHeader);
   void *e = final;
-  e = (void *)((uint32_t)e + final->size);
+  e = (void *)((u32)e + final->size);
   if (p == e) {
     final->size += allocation_size - sizeof(MallocHeader);
     return 1;
@@ -77,7 +77,7 @@ MallocHeader *next_close_header(MallocHeader *a) {
   return next_header(a);
 }
 
-MallocHeader *find_free_entry(uint32_t s) {
+MallocHeader *find_free_entry(u32 s) {
   // A new header is required as well as the newly allocated chunk
   s += sizeof(MallocHeader);
   if (!head)
@@ -87,7 +87,7 @@ MallocHeader *find_free_entry(uint32_t s) {
     assert(p->magic == 0xdde51ab9410268b1);
     if (!(p->flags & IS_FREE))
       continue;
-    uint64_t required_size = s;
+    u64 required_size = s;
     if (p->size < required_size)
       continue;
     return p;
@@ -151,7 +151,7 @@ void *kmalloc(size_t s) {
 #define PHYS 0x403000
 
 void *latest = NULL;
-uint64_t left = 0;
+u64 left = 0;
 
 void *kmalloc_eternal_physical_align(size_t s, void **physical) {
   void *return_address = ksbrk(s);
diff --git a/kernel/kmalloc.h b/kernel/kmalloc.h
index 69e0de3..6509cb0 100644
--- a/kernel/kmalloc.h
+++ b/kernel/kmalloc.h
@@ -1,7 +1,7 @@
 #include <log.h>
 #include <mmu.h>
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 #include <string.h>
 
 void kmalloc_allocate_heap(void);
diff --git a/kernel/ksbrk.c b/kernel/ksbrk.c
index 755a4ed..82fc5ed 100644
--- a/kernel/ksbrk.c
+++ b/kernel/ksbrk.c
@@ -2,7 +2,7 @@
 #include <ksbrk.h>
 #include <mmu.h>
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 /*
 extern uintptr_t data_end;
diff --git a/kernel/ksbrk.h b/kernel/ksbrk.h
index 34987dc..a55d985 100644
--- a/kernel/ksbrk.h
+++ b/kernel/ksbrk.h
@@ -1,7 +1,7 @@
 #ifndef KSBRK_H
 #define KSBRK_H
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 void* ksbrk(size_t s);
 void *ksbrk_physical(size_t s, void **physical);
diff --git a/kernel/kubsan.h b/kernel/kubsan.h
index dac5407..8f10624 100644
--- a/kernel/kubsan.h
+++ b/kernel/kubsan.h
@@ -1,10 +1,10 @@
-#include <stdint.h>
+#include <typedefs.h>
 
 enum { type_kind_int = 0, type_kind_float = 1, type_unknown = 0xffff };
 
 struct type_descriptor {
-  uint16_t type_kind;
-  uint16_t type_info;
+  u16 type_kind;
+  u16 type_info;
   char type_name[1];
 };
 
@@ -13,8 +13,8 @@ struct source_location {
   union {
     unsigned long reported;
     struct {
-      uint32_t line;
-      uint32_t column;
+      u32 line;
+      u32 column;
     };
   };
 };
diff --git a/kernel/libc/include/string.h b/kernel/libc/include/string.h
index 7cee4b2..707d391 100644
--- a/kernel/libc/include/string.h
+++ b/kernel/libc/include/string.h
@@ -1,16 +1,16 @@
 #ifndef STRING_H
 #define STRING_H
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 unsigned long strlen(const char *s);
-void *memcpy(void *dest, const void *src, uint32_t n);
-void *memset(void *dst, const unsigned char c, uint32_t n);
-int memcmp(const void *s1, const void *s2, uint32_t n);
+void *memcpy(void *dest, const void *src, u32 n);
+void *memset(void *dst, const unsigned char c, u32 n);
+int memcmp(const void *s1, const void *s2, u32 n);
 char *strcpy(char *d, const char *s);
 int strcmp(const char *s1, const char *s2);
 int isequal(const char *s1, const char *s2);
-int isequal_n(const char *s1, const char *s2, uint32_t n);
+int isequal_n(const char *s1, const char *s2, u32 n);
 char *copy_and_allocate_string(const char *s);
 char *copy_and_allocate_user_string(const char *s);
 char *strncpy(char *dest, const char *src, size_t n);
diff --git a/kernel/libc/stdio/print.c b/kernel/libc/stdio/print.c
index 8174983..f1a4918 100644
--- a/kernel/libc/stdio/print.c
+++ b/kernel/libc/stdio/print.c
@@ -10,7 +10,7 @@ const char HEX_SET[0x10] = {'0', '1', '2', '3', '4', '5', '6', '7',
 
 inline void putc(const char c) { write_serial(c); }
 
-int kprint_hex(uint64_t num) {
+int kprint_hex(u64 num) {
   int c = 2;
 
   if (num == 0) {
@@ -79,7 +79,7 @@ int kprintf(const char *format, ...) {
         ;
       break;
     case 'x':
-      c += kprint_hex(va_arg(list, const uint32_t));
+      c += kprint_hex(va_arg(list, const u32));
       break;
     case '%':
       putc('%');
diff --git a/kernel/libc/string/isequal.c b/kernel/libc/string/isequal.c
index cdbd3cc..75f7366 100644
--- a/kernel/libc/string/isequal.c
+++ b/kernel/libc/string/isequal.c
@@ -7,7 +7,7 @@ int isequal(const char *s1, const char *s2) {
     return 1;
 }
 
-int isequal_n(const char *s1, const char *s2, uint32_t n) {
+int isequal_n(const char *s1, const char *s2, u32 n) {
     for(;*s1 && n;s1++,s2++,n--)
         if(*s1 != *s2)
             return 0;
diff --git a/kernel/libc/string/memcmp.c b/kernel/libc/string/memcmp.c
index 72c680a..db13ed2 100644
--- a/kernel/libc/string/memcmp.c
+++ b/kernel/libc/string/memcmp.c
@@ -1,10 +1,10 @@
 #include "../include/string.h"
 
-int memcmp(const void *s1, const void *s2, uint32_t n)
+int memcmp(const void *s1, const void *s2, u32 n)
 {
 	int return_value = 0;
 
-	for(uint32_t i = 0;i < n;i++)
+	for(u32 i = 0;i < n;i++)
 		if(((unsigned char *)(s1))[i] != ((unsigned char *)(s2))[i])
 			return_value++;
 
diff --git a/kernel/libc/string/memcpy.c b/kernel/libc/string/memcpy.c
index 5c04407..1313261 100644
--- a/kernel/libc/string/memcpy.c
+++ b/kernel/libc/string/memcpy.c
@@ -1,18 +1,18 @@
 #include "../include/string.h"
 
 void *
-memcpy(void *dest, const void *src, uint32_t n) {
+memcpy(void *dest, const void *src, u32 n) {
   unsigned char *d = dest;
   const unsigned char *s = src;
 
   for (; n >= 8; n -= 8, d += 8, s += 8)
-    *(uint64_t *)d = *(uint64_t *)s;
+    *(u64 *)d = *(u64 *)s;
 
   for (; n >= 4; n -= 4, d += 4, s += 4)
-    *(uint32_t *)d = *(uint32_t *)s;
+    *(u32 *)d = *(u32 *)s;
 
   for (; n >= 2; n -= 2, d += 2, s += 2)
-    *(uint16_t *)d = *(uint16_t *)s;
+    *(u16 *)d = *(u16 *)s;
 
   for (; n; n--)
     *d++ = *s++;
diff --git a/kernel/libc/string/memset.c b/kernel/libc/string/memset.c
index a446eb4..5d7de62 100644
--- a/kernel/libc/string/memset.c
+++ b/kernel/libc/string/memset.c
@@ -1,8 +1,8 @@
 #include <string.h>
 
-void *memset(void *dst, const unsigned char c, uint32_t n) {
+void *memset(void *dst, const unsigned char c, u32 n) {
   uintptr_t d = (uintptr_t)dst;
-  for (uint32_t i = 0; i < n; i++, d++)
+  for (u32 i = 0; i < n; i++, d++)
     *(unsigned char *)d = c;
 
   return (void *)d;
diff --git a/kernel/log.c b/kernel/log.c
index 56d38e8..fddf3b5 100644
--- a/kernel/log.c
+++ b/kernel/log.c
@@ -3,14 +3,14 @@
 
 struct stackframe {
   struct stackframe *ebp;
-  uint32_t eip;
+  u32 eip;
 };
 
-void dump_backtrace(uint32_t max_frames) {
+void dump_backtrace(u32 max_frames) {
   struct stackframe *stk;
   asm("mov %%ebp,%0" : "=r"(stk)::);
   kprintf("Stack trace:\n");
-  for (uint32_t frame = 0; stk && frame < max_frames; ++frame) {
+  for (u32 frame = 0; stk && frame < max_frames; ++frame) {
     kprintf(" 0x%x\n", stk->eip);
     stk = stk->ebp;
   }
diff --git a/kernel/log.h b/kernel/log.h
index fe499bc..10164d0 100644
--- a/kernel/log.h
+++ b/kernel/log.h
@@ -1,5 +1,5 @@
 #include <stdio.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 #define LOG_NOTE 3
 #define LOG_WARN 2
@@ -7,4 +7,4 @@
 #define LOG_SUCCESS 0
 
 void klog(char *str, int code);
-void dump_backtrace(uint32_t max_frames);
+void dump_backtrace(u32 max_frames);
diff --git a/kernel/multiboot.h b/kernel/multiboot.h
index ecbb6a0..02bf77e 100644
--- a/kernel/multiboot.h
+++ b/kernel/multiboot.h
@@ -1,4 +1,4 @@
-#include <stdint.h>
+#include <typedefs.h>
 #ifndef MULTIBOOT_HEADER
 #define MULTIBOOT_HEADER 1
 
@@ -71,71 +71,71 @@
 
 #ifndef ASM_FILE
 
-typedef uint8_t multiboot_uint8_t;
-typedef uint16_t multiboot_uint16_t;
-typedef uint32_t multiboot_uint32_t;
-typedef uint64_t multiboot_uint64_t;
+typedef u8 multiboot_u8;
+typedef u16 multiboot_u16;
+typedef u32 multiboot_u32;
+typedef u64 multiboot_u64;
 
 struct multiboot_header {
   /* Must be MULTIBOOT_MAGIC - see above. */
-  multiboot_uint32_t magic;
+  multiboot_u32 magic;
 
   /* Feature flags. */
-  multiboot_uint32_t flags;
+  multiboot_u32 flags;
 
   /* The above fields plus this one must equal 0 mod 2^32. */
-  multiboot_uint32_t checksum;
+  multiboot_u32 checksum;
 
   /* These are only valid if MULTIBOOT_AOUT_KLUDGE is set. */
-  multiboot_uint32_t header_addr;
-  multiboot_uint32_t load_addr;
-  multiboot_uint32_t load_end_addr;
-  multiboot_uint32_t bss_end_addr;
-  multiboot_uint32_t entry_addr;
+  multiboot_u32 header_addr;
+  multiboot_u32 load_addr;
+  multiboot_u32 load_end_addr;
+  multiboot_u32 bss_end_addr;
+  multiboot_u32 entry_addr;
 
   /* These are only valid if MULTIBOOT_VIDEO_MODE is set. */
-  multiboot_uint32_t mode_type;
-  multiboot_uint32_t width;
-  multiboot_uint32_t height;
-  multiboot_uint32_t depth;
+  multiboot_u32 mode_type;
+  multiboot_u32 width;
+  multiboot_u32 height;
+  multiboot_u32 depth;
 };
 
 /* The symbol table for a.out. */
 struct multiboot_aout_symbol_table {
-  multiboot_uint32_t tabsize;
-  multiboot_uint32_t strsize;
-  multiboot_uint32_t addr;
-  multiboot_uint32_t reserved;
+  multiboot_u32 tabsize;
+  multiboot_u32 strsize;
+  multiboot_u32 addr;
+  multiboot_u32 reserved;
 };
 typedef struct multiboot_aout_symbol_table multiboot_aout_symbol_table_t;
 
 /* The section header table for ELF. */
 struct multiboot_elf_section_header_table {
-  multiboot_uint32_t num;
-  multiboot_uint32_t size;
-  multiboot_uint32_t addr;
-  multiboot_uint32_t shndx;
+  multiboot_u32 num;
+  multiboot_u32 size;
+  multiboot_u32 addr;
+  multiboot_u32 shndx;
 };
 typedef struct multiboot_elf_section_header_table
     multiboot_elf_section_header_table_t;
 
 struct multiboot_info {
   /* Multiboot info version number */
-  multiboot_uint32_t flags;
+  multiboot_u32 flags;
 
   /* Available memory from BIOS */
-  multiboot_uint32_t mem_lower;
-  multiboot_uint32_t mem_upper;
+  multiboot_u32 mem_lower;
+  multiboot_u32 mem_upper;
 
   /* "root" partition */
-  multiboot_uint32_t boot_device;
+  multiboot_u32 boot_device;
 
   /* Kernel command line */
-  multiboot_uint32_t cmdline;
+  multiboot_u32 cmdline;
 
   /* Boot-Module list */
-  multiboot_uint32_t mods_count;
-  multiboot_uint32_t mods_addr;
+  multiboot_u32 mods_count;
+  multiboot_u32 mods_addr;
 
   union {
     multiboot_aout_symbol_table_t aout_sym;
@@ -143,99 +143,99 @@ struct multiboot_info {
   } u;
 
   /* Memory Mapping buffer */
-  multiboot_uint32_t mmap_length;
-  multiboot_uint32_t mmap_addr;
+  multiboot_u32 mmap_length;
+  multiboot_u32 mmap_addr;
 
   /* Drive Info buffer */
-  multiboot_uint32_t drives_length;
-  multiboot_uint32_t drives_addr;
+  multiboot_u32 drives_length;
+  multiboot_u32 drives_addr;
 
   /* ROM configuration table */
-  multiboot_uint32_t config_table;
+  multiboot_u32 config_table;
 
   /* Boot Loader Name */
-  multiboot_uint32_t boot_loader_name;
+  multiboot_u32 boot_loader_name;
 
   /* APM table */
-  multiboot_uint32_t apm_table;
+  multiboot_u32 apm_table;
 
   /* Video */
-  multiboot_uint32_t vbe_control_info;
-  multiboot_uint32_t vbe_mode_info;
-  multiboot_uint16_t vbe_mode;
-  multiboot_uint16_t vbe_interface_seg;
-  multiboot_uint16_t vbe_interface_off;
-  multiboot_uint16_t vbe_interface_len;
-
-  multiboot_uint64_t framebuffer_addr;
-  multiboot_uint32_t framebuffer_pitch;
-  multiboot_uint32_t framebuffer_width;
-  multiboot_uint32_t framebuffer_height;
-  multiboot_uint8_t framebuffer_bpp;
+  multiboot_u32 vbe_control_info;
+  multiboot_u32 vbe_mode_info;
+  multiboot_u16 vbe_mode;
+  multiboot_u16 vbe_interface_seg;
+  multiboot_u16 vbe_interface_off;
+  multiboot_u16 vbe_interface_len;
+
+  multiboot_u64 framebuffer_addr;
+  multiboot_u32 framebuffer_pitch;
+  multiboot_u32 framebuffer_width;
+  multiboot_u32 framebuffer_height;
+  multiboot_u8 framebuffer_bpp;
 #define MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED 0
 #define MULTIBOOT_FRAMEBUFFER_TYPE_RGB 1
 #define MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT 2
-  multiboot_uint8_t framebuffer_type;
+  multiboot_u8 framebuffer_type;
   union {
     struct {
-      multiboot_uint32_t framebuffer_palette_addr;
-      multiboot_uint16_t framebuffer_palette_num_colors;
+      multiboot_u32 framebuffer_palette_addr;
+      multiboot_u16 framebuffer_palette_num_colors;
     };
     struct {
-      multiboot_uint8_t framebuffer_red_field_position;
-      multiboot_uint8_t framebuffer_red_mask_size;
-      multiboot_uint8_t framebuffer_green_field_position;
-      multiboot_uint8_t framebuffer_green_mask_size;
-      multiboot_uint8_t framebuffer_blue_field_position;
-      multiboot_uint8_t framebuffer_blue_mask_size;
+      multiboot_u8 framebuffer_red_field_position;
+      multiboot_u8 framebuffer_red_mask_size;
+      multiboot_u8 framebuffer_green_field_position;
+      multiboot_u8 framebuffer_green_mask_size;
+      multiboot_u8 framebuffer_blue_field_position;
+      multiboot_u8 framebuffer_blue_mask_size;
     };
   };
 };
 typedef struct multiboot_info multiboot_info_t;
 
 struct multiboot_color {
-  multiboot_uint8_t red;
-  multiboot_uint8_t green;
-  multiboot_uint8_t blue;
+  multiboot_u8 red;
+  multiboot_u8 green;
+  multiboot_u8 blue;
 };
 
 struct multiboot_mmap_entry {
-  multiboot_uint32_t size;
-  multiboot_uint64_t addr;
-  multiboot_uint64_t len;
+  multiboot_u32 size;
+  multiboot_u64 addr;
+  multiboot_u64 len;
 #define MULTIBOOT_MEMORY_AVAILABLE 1
 #define MULTIBOOT_MEMORY_RESERVED 2
 #define MULTIBOOT_MEMORY_ACPI_RECLAIMABLE 3
 #define MULTIBOOT_MEMORY_NVS 4
 #define MULTIBOOT_MEMORY_BADRAM 5
-  multiboot_uint32_t type;
+  multiboot_u32 type;
 } __attribute__((packed));
 typedef struct multiboot_mmap_entry multiboot_memory_map_t;
 
 struct multiboot_mod_list {
   /* the memory used goes from bytes ’mod_start’ to ’mod_end-1’ inclusive */
-  multiboot_uint32_t mod_start;
-  multiboot_uint32_t mod_end;
+  multiboot_u32 mod_start;
+  multiboot_u32 mod_end;
 
   /* Module command line */
-  multiboot_uint32_t cmdline;
+  multiboot_u32 cmdline;
 
   /* padding to take it to 16 bytes (must be zero) */
-  multiboot_uint32_t pad;
+  multiboot_u32 pad;
 };
 typedef struct multiboot_mod_list multiboot_module_t;
 
 /* APM BIOS info. */
 struct multiboot_apm_info {
-  multiboot_uint16_t version;
-  multiboot_uint16_t cseg;
-  multiboot_uint32_t offset;
-  multiboot_uint16_t cseg_16;
-  multiboot_uint16_t dseg;
-  multiboot_uint16_t flags;
-  multiboot_uint16_t cseg_len;
-  multiboot_uint16_t cseg_16_len;
-  multiboot_uint16_t dseg_len;
+  multiboot_u16 version;
+  multiboot_u16 cseg;
+  multiboot_u32 offset;
+  multiboot_u16 cseg_16;
+  multiboot_u16 dseg;
+  multiboot_u16 flags;
+  multiboot_u16 cseg_len;
+  multiboot_u16 cseg_16_len;
+  multiboot_u16 dseg_len;
 };
 
 #endif /* ! ASM_FILE */
diff --git a/kernel/network/arp.c b/kernel/network/arp.c
index 179f6c1..ddeb553 100644
--- a/kernel/network/arp.c
+++ b/kernel/network/arp.c
@@ -7,29 +7,29 @@
 #include <string.h>
 
 struct ARP_DATA {
-  uint16_t htype;   // Hardware type
-  uint16_t ptype;   // Protocol type
-  uint8_t hlen;     // Hardware address length (Ethernet = 6)
-  uint8_t plen;     // Protocol address length (IPv4 = 4)
-  uint16_t opcode;  // ARP Operation Code
-  uint8_t srchw[6]; // Source hardware address - hlen bytes (see above)
-  uint8_t srcpr[4]; // Source protocol address - plen bytes (see above).
+  u16 htype;   // Hardware type
+  u16 ptype;   // Protocol type
+  u8 hlen;     // Hardware address length (Ethernet = 6)
+  u8 plen;     // Protocol address length (IPv4 = 4)
+  u16 opcode;  // ARP Operation Code
+  u8 srchw[6]; // Source hardware address - hlen bytes (see above)
+  u8 srcpr[4]; // Source protocol address - plen bytes (see above).
                     // If IPv4 can just be a "u32" type.
-  uint8_t dsthw[6]; // Destination hardware address - hlen bytes (see above)
-  uint8_t dstpr[4]; // Destination protocol address - plen bytes (see
+  u8 dsthw[6]; // Destination hardware address - hlen bytes (see above)
+  u8 dstpr[4]; // Destination protocol address - plen bytes (see
                     // above). If IPv4 can just be a "u32" type.
 };
 
 struct ARP_TABLE_ENTRY {
-  uint8_t is_used;
-  uint8_t mac[6];
-  uint8_t ip[4];
+  u8 is_used;
+  u8 mac[6];
+  u8 ip[4];
 };
 
 struct ARP_TABLE_ENTRY arp_table[10] = {0};
 
 // FIXME: This is hardcoded, don't do this.
-uint8_t ip_address[4] = {10, 0, 2, 15};
+u8 ip_address[4] = {10, 0, 2, 15};
 
 struct ARP_TABLE_ENTRY *find_arp_entry_to_use(void) {
   // This does not need to find a "free" entry as a ARP table is
@@ -42,7 +42,7 @@ struct ARP_TABLE_ENTRY *find_arp_entry_to_use(void) {
   return &arp_table[0];
 }
 
-void print_mac(const char *str, uint8_t *mac) {
+void print_mac(const char *str, u8 *mac) {
   kprintf("%s: ", str);
   for (int i = 0; i < 6; i++) {
     kprintf("%x", mac[i]);
@@ -52,7 +52,7 @@ void print_mac(const char *str, uint8_t *mac) {
   kprintf("\n");
 }
 
-void print_ip(const char *str, const uint8_t *ip) {
+void print_ip(const char *str, const u8 *ip) {
   kprintf("%s: ", str);
   for (int i = 0; i < 4; i++) {
     kprintf("%d", ip[i]);
@@ -62,7 +62,7 @@ void print_ip(const char *str, const uint8_t *ip) {
   kprintf("\n");
 }
 
-void send_arp_request(const uint8_t ip[4]) {
+void send_arp_request(const u8 ip[4]) {
   struct ARP_DATA data;
   data.htype = htons(1);
   data.ptype = htons(0x0800);
@@ -72,37 +72,37 @@ void send_arp_request(const uint8_t ip[4]) {
 
   data.opcode = htons(0x0001);
   get_mac_address(data.srchw);
-  memcpy(data.srcpr, ip_address, sizeof(uint8_t[4]));
+  memcpy(data.srcpr, ip_address, sizeof(u8[4]));
 
-  memset(data.dsthw, 0, sizeof(uint8_t[6]));
-  memcpy(data.dstpr, ip, sizeof(uint8_t[4]));
+  memset(data.dsthw, 0, sizeof(u8[6]));
+  memcpy(data.dstpr, ip, sizeof(u8[4]));
 
-  uint8_t broadcast[6];
+  u8 broadcast[6];
   memset(broadcast, 0xFF, sizeof(broadcast));
-  send_ethernet_packet(broadcast, 0x0806, (uint8_t *)&data, sizeof(data));
+  send_ethernet_packet(broadcast, 0x0806, (u8 *)&data, sizeof(data));
 }
 
-int get_mac_from_ip(const uint8_t ip[4], uint8_t mac[6]) {
+int get_mac_from_ip(const u8 ip[4], u8 mac[6]) {
   print_ip("ARP GETTING MAC FROM IP: ", ip);
   for (int i = 0; i < 10; i++) {
-    if (0 != memcmp(arp_table[i].ip, ip, sizeof(uint8_t[4])))
+    if (0 != memcmp(arp_table[i].ip, ip, sizeof(u8[4])))
       continue;
-    memcpy(mac, arp_table[i].mac, sizeof(uint8_t[6]));
+    memcpy(mac, arp_table[i].mac, sizeof(u8[6]));
     return 1;
   }
   klog("ARP cache miss", LOG_NOTE);
   send_arp_request(ip);
   // TODO: Maybe wait a bit?
   for (int i = 0; i < 10; i++) {
-    if (0 != memcmp(arp_table[i].ip, ip, sizeof(uint8_t[4])))
+    if (0 != memcmp(arp_table[i].ip, ip, sizeof(u8[4])))
       continue;
-    memcpy(mac, arp_table[i].mac, sizeof(uint8_t[6]));
+    memcpy(mac, arp_table[i].mac, sizeof(u8[6]));
     return 1;
   }
   return 0;
 }
 
-void handle_arp(const uint8_t *payload) {
+void handle_arp(const u8 *payload) {
   struct ARP_DATA *data = (struct ARP_DATA *)payload;
 
   // Assert that communication is over ethernet
@@ -120,7 +120,7 @@ void handle_arp(const uint8_t *payload) {
     print_mac("dsthw: ", data->dsthw);
     print_ip("dstpr: ", data->dstpr);
 
-    assert(0 == memcmp(data->dstpr, ip_address, sizeof(uint8_t[4])));
+    assert(0 == memcmp(data->dstpr, ip_address, sizeof(u8[4])));
 
     // Now we have to construct a ARP response
     struct ARP_DATA response;
@@ -130,19 +130,19 @@ void handle_arp(const uint8_t *payload) {
     response.hlen = 6;
     response.plen = 4;
     get_mac_address(response.srchw);
-    memcpy(response.srcpr, ip_address, sizeof(uint8_t[4]));
+    memcpy(response.srcpr, ip_address, sizeof(u8[4]));
 
-    memcpy(response.dsthw, data->srchw, sizeof(uint8_t[6]));
-    memcpy(response.dstpr, data->srcpr, sizeof(uint8_t[4]));
+    memcpy(response.dsthw, data->srchw, sizeof(u8[6]));
+    memcpy(response.dstpr, data->srcpr, sizeof(u8[4]));
 
-    send_ethernet_packet(data->srchw, 0x0806, (uint8_t *)&response,
+    send_ethernet_packet(data->srchw, 0x0806, (u8 *)&response,
                          sizeof(response));
   } else if (0x0002 /*arp_response*/ == ntohs(data->opcode)) {
     // Find a entry to fill
     struct ARP_TABLE_ENTRY *entry = find_arp_entry_to_use();
     entry->is_used = 1;
-    memcpy(entry->mac, data->srchw, sizeof(uint8_t[6]));
-    memcpy(entry->ip, data->srcpr, sizeof(uint8_t[4]));
+    memcpy(entry->mac, data->srchw, sizeof(u8[6]));
+    memcpy(entry->ip, data->srcpr, sizeof(u8[4]));
     print_ip("Added ip: ", entry->ip);
   } else {
     kprintf("GOT A ARP REQEUST WITH TYPE: %x\n", ntohs(data->opcode));
diff --git a/kernel/network/arp.h b/kernel/network/arp.h
index 1e42dff..6e53fd9 100644
--- a/kernel/network/arp.h
+++ b/kernel/network/arp.h
@@ -1,5 +1,5 @@
-#include <stdint.h>
+#include <typedefs.h>
 
-int get_mac_from_ip(const uint8_t ip[4], uint8_t mac[6]);
-void send_arp_request(const uint8_t ip[4]);
-void handle_arp(const uint8_t *payload);
+int get_mac_from_ip(const u8 ip[4], u8 mac[6]);
+void send_arp_request(const u8 ip[4]);
+void handle_arp(const u8 *payload);
diff --git a/kernel/network/bytes.c b/kernel/network/bytes.c
index 94afa73..f502caf 100644
--- a/kernel/network/bytes.c
+++ b/kernel/network/bytes.c
@@ -1,10 +1,10 @@
 #include <network/bytes.h>
 
-uint16_t ntohs(uint16_t net) { return (net >> 8) | (net << 8); }
+u16 ntohs(u16 net) { return (net >> 8) | (net << 8); }
 
-uint16_t htons(uint16_t net) { return (net >> 8) | (net << 8); }
+u16 htons(u16 net) { return (net >> 8) | (net << 8); }
 
-uint32_t htonl(uint32_t net) {
+u32 htonl(u32 net) {
   return (((net & 0x000000FF) << 24) | ((net & 0x0000FF00) << 8) |
           ((net & 0x00FF0000) >> 8) | ((net & 0xFF000000) >> 24));
 }
diff --git a/kernel/network/bytes.h b/kernel/network/bytes.h
index c291589..b71b9a4 100644
--- a/kernel/network/bytes.h
+++ b/kernel/network/bytes.h
@@ -1,5 +1,5 @@
-#include <stdint.h>
+#include <typedefs.h>
 
-uint16_t ntohs(uint16_t net);
-uint16_t htons(uint16_t net);
-uint32_t htonl(uint32_t net);
+u16 ntohs(u16 net);
+u16 htons(u16 net);
+u32 htonl(u32 net);
diff --git a/kernel/network/ethernet.c b/kernel/network/ethernet.c
index e97ccbd..5cf1a54 100644
--- a/kernel/network/ethernet.c
+++ b/kernel/network/ethernet.c
@@ -8,16 +8,16 @@
 #include <stdio.h>
 
 struct ETHERNET_HEADER {
-  uint8_t mac_dst[6];
-  uint8_t mac_src[6];
-  uint16_t type;
+  u8 mac_dst[6];
+  u8 mac_src[6];
+  u16 type;
 };
 
-uint32_t crc32(const char *buf, size_t len) {
-  static uint32_t table[256];
+u32 crc32(const char *buf, size_t len) {
+  static u32 table[256];
   static int have_table = 0;
-  uint32_t rem;
-  uint8_t octet;
+  u32 rem;
+  u8 octet;
   int i, j;
   const char *p, *q;
 
@@ -36,7 +36,7 @@ uint32_t crc32(const char *buf, size_t len) {
     have_table = 1;
   }
 
-  uint32_t crc = 0xFFFFFFFF;
+  u32 crc = 0xFFFFFFFF;
   q = buf + len;
   for (p = buf; p < q; p++) {
     octet = *p;
@@ -45,17 +45,17 @@ uint32_t crc32(const char *buf, size_t len) {
   return ~crc;
 }
 
-void handle_ethernet(const uint8_t *packet, uint64_t packet_length) {
+void handle_ethernet(const u8 *packet, u64 packet_length) {
   struct ETHERNET_HEADER *eth_header = (struct ETHERNET_HEADER *)packet;
   packet += sizeof(struct ETHERNET_HEADER);
-  const uint8_t *payload = packet;
+  const u8 *payload = packet;
   packet += packet_length - sizeof(struct ETHERNET_HEADER);
-  uint32_t crc = *((uint32_t *)packet - 1);
+  u32 crc = *((u32 *)packet - 1);
   kprintf("PACKET crc: %x\n", crc);
   kprintf("OUR OWN CALCULATED crc: %x\n",
           crc32((const char *)eth_header, (packet_length - 4)));
 
-  uint16_t type = ntohs(eth_header->type);
+  u16 type = ntohs(eth_header->type);
   switch (type) {
   case 0x0806:
     handle_arp(payload);
@@ -69,22 +69,22 @@ void handle_ethernet(const uint8_t *packet, uint64_t packet_length) {
   }
 }
 
-void send_ethernet_packet(uint8_t mac_dst[6], uint16_t type, uint8_t *payload,
-                          uint64_t payload_length) {
+void send_ethernet_packet(u8 mac_dst[6], u16 type, u8 *payload,
+                          u64 payload_length) {
   // FIXME: Janky allocation, do this better
-  uint64_t buffer_size =
-      sizeof(struct ETHERNET_HEADER) + payload_length + sizeof(uint32_t);
-  uint8_t *buffer = kmalloc(buffer_size);
-  uint8_t *buffer_start = buffer;
+  u64 buffer_size =
+      sizeof(struct ETHERNET_HEADER) + payload_length + sizeof(u32);
+  u8 *buffer = kmalloc(buffer_size);
+  u8 *buffer_start = buffer;
   struct ETHERNET_HEADER *eth_header = (struct ETHERNET_HEADER *)buffer;
   buffer += sizeof(struct ETHERNET_HEADER);
   memcpy(buffer, payload, payload_length);
   buffer += payload_length;
 
-  memcpy(eth_header->mac_dst, mac_dst, sizeof(uint8_t[6]));
+  memcpy(eth_header->mac_dst, mac_dst, sizeof(u8[6]));
   get_mac_address(eth_header->mac_src);
   eth_header->type = htons(type);
-  *(uint32_t *)(buffer) =
+  *(u32 *)(buffer) =
       htonl(crc32((const char *)buffer_start, buffer_size - 4));
 
   assert(rtl8139_send_data(buffer_start, buffer_size));
diff --git a/kernel/network/ethernet.h b/kernel/network/ethernet.h
index 0fdcee3..ffb7893 100644
--- a/kernel/network/ethernet.h
+++ b/kernel/network/ethernet.h
@@ -1,5 +1,5 @@
-#include <stdint.h>
+#include <typedefs.h>
 
-void handle_ethernet(const uint8_t *packet, uint64_t packet_length);
-void send_ethernet_packet(uint8_t mac_dst[6], uint16_t type, uint8_t *payload,
-                          uint64_t payload_length);
+void handle_ethernet(const u8 *packet, u64 packet_length);
+void send_ethernet_packet(u8 mac_dst[6], u16 type, u8 *payload,
+                          u64 payload_length);
diff --git a/kernel/network/ipv4.c b/kernel/network/ipv4.c
index 7f480a3..891e74f 100644
--- a/kernel/network/ipv4.c
+++ b/kernel/network/ipv4.c
@@ -9,16 +9,16 @@
 #include <network/udp.h>
 #include <string.h>
 
-uint16_t ip_checksum(void *vdata, size_t length) {
+u16 ip_checksum(void *vdata, size_t length) {
   // Cast the data pointer to one that can be indexed.
   char *data = (char *)vdata;
 
   // Initialise the accumulator.
-  uint32_t acc = 0xffff;
+  u32 acc = 0xffff;
 
   // Handle complete 16-bit blocks.
   for (size_t i = 0; i + 1 < length; i += 2) {
-    uint16_t word;
+    u16 word;
     memcpy(&word, data + i, 2);
     acc += ntohs(word);
     if (acc > 0xffff) {
@@ -28,7 +28,7 @@ uint16_t ip_checksum(void *vdata, size_t length) {
 
   // Handle any partial block at the end of the data.
   if (length & 1) {
-    uint16_t word = 0;
+    u16 word = 0;
     memcpy(&word, data + length - 1, 1);
     acc += ntohs(word);
     if (acc > 0xffff) {
@@ -40,27 +40,27 @@ uint16_t ip_checksum(void *vdata, size_t length) {
   return htons(~acc);
 }
 
-extern uint8_t ip_address[4];
-void send_ipv4_packet(uint32_t ip, uint8_t protocol, const uint8_t *payload,
-                      uint16_t length) {
-  uint8_t header[20] = {0};
+extern u8 ip_address[4];
+void send_ipv4_packet(u32 ip, u8 protocol, const u8 *payload,
+                      u16 length) {
+  u8 header[20] = {0};
   header[0] = (4 /*version*/ << 4) | (5 /*IHL*/);
-  *((uint16_t *)(header + 2)) = htons(length + 20);
+  *((u16 *)(header + 2)) = htons(length + 20);
   header[8 /*TTL*/] = 0xF8;
   header[9] = protocol;
 
-  memcpy(header + 12 /*src_ip*/, ip_address, sizeof(uint8_t[4]));
-  memcpy(header + 16, &ip, sizeof(uint8_t[4]));
+  memcpy(header + 12 /*src_ip*/, ip_address, sizeof(u8[4]));
+  memcpy(header + 16, &ip, sizeof(u8[4]));
 
-  *((uint16_t *)(header + 10 /*checksum*/)) = ip_checksum(header, 20);
-  uint16_t packet_length = length + 20;
-  uint8_t *packet = kmalloc(packet_length);
+  *((u16 *)(header + 10 /*checksum*/)) = ip_checksum(header, 20);
+  u16 packet_length = length + 20;
+  u8 *packet = kmalloc(packet_length);
   memcpy(packet, header, 20);
   memcpy(packet + 20, payload, length);
 
-  uint8_t mac[6];
-  uint8_t ip_copy[4]; // TODO: Do I need to do this?
-  memcpy(ip_copy, &ip, sizeof(uint8_t[4]));
+  u8 mac[6];
+  u8 ip_copy[4]; // TODO: Do I need to do this?
+  memcpy(ip_copy, &ip, sizeof(u8[4]));
   for (; !get_mac_from_ip(ip_copy, mac);)
     ;
   kprintf("pre send_ethernet: %x\n", pit_num_ms());
@@ -69,29 +69,29 @@ void send_ipv4_packet(uint32_t ip, uint8_t protocol, const uint8_t *payload,
   kfree(packet);
 }
 
-void handle_ipv4(const uint8_t *payload, uint32_t packet_length) {
+void handle_ipv4(const u8 *payload, u32 packet_length) {
   assert(packet_length > 4);
 
-  uint16_t saved_checksum = *(uint16_t *)(payload + 10);
-  *(uint16_t *)(payload + 10) = 0;
-  uint16_t calc_checksum = ip_checksum((uint8_t *)payload, 20);
-  *(uint16_t *)(payload + 10) = saved_checksum;
+  u16 saved_checksum = *(u16 *)(payload + 10);
+  *(u16 *)(payload + 10) = 0;
+  u16 calc_checksum = ip_checksum((u8 *)payload, 20);
+  *(u16 *)(payload + 10) = saved_checksum;
   assert(calc_checksum == saved_checksum);
 
-  uint8_t version = (*payload & 0xF0) >> 4;
-  uint8_t IHL = (*payload & 0xF);
+  u8 version = (*payload & 0xF0) >> 4;
+  u8 IHL = (*payload & 0xF);
   kprintf("version: %x\n", version);
   assert(4 == version);
   assert(5 == IHL);
-  uint16_t ipv4_total_length = ntohs(*(uint16_t *)(payload + 2));
+  u16 ipv4_total_length = ntohs(*(u16 *)(payload + 2));
   assert(ipv4_total_length >= 20);
   // Make sure the ipv4 header is not trying to get uninitalized memory
   assert(ipv4_total_length <= packet_length);
 
-  uint8_t src_ip[4];
-  memcpy(src_ip, payload + 12, sizeof(uint8_t[4]));
+  u8 src_ip[4];
+  memcpy(src_ip, payload + 12, sizeof(u8[4]));
 
-  uint8_t protocol = *(payload + 9);
+  u8 protocol = *(payload + 9);
   switch (protocol) {
   case 0x6:
     handle_tcp(src_ip, payload + 20, ipv4_total_length - 20);
diff --git a/kernel/network/ipv4.h b/kernel/network/ipv4.h
index f578202..cd15fce 100644
--- a/kernel/network/ipv4.h
+++ b/kernel/network/ipv4.h
@@ -1,5 +1,5 @@
-#include <stdint.h>
+#include <typedefs.h>
 
-void handle_ipv4(const uint8_t *payload, uint32_t packet_length);
-void send_ipv4_packet(uint32_t ip, uint8_t protocol, const uint8_t *payload,
-                      uint16_t length);
+void handle_ipv4(const u8 *payload, u32 packet_length);
+void send_ipv4_packet(u32 ip, u8 protocol, const u8 *payload,
+                      u16 length);
diff --git a/kernel/network/tcp.c b/kernel/network/tcp.c
index c20f046..6c693cf 100644
--- a/kernel/network/tcp.c
+++ b/kernel/network/tcp.c
@@ -4,7 +4,7 @@
 #include <network/ipv4.h>
 #include <network/udp.h>
 #include <socket.h>
-extern uint8_t ip_address[4];
+extern u8 ip_address[4];
 
 #define CWR (1 << 7)
 #define ECE (1 << 6)
@@ -16,56 +16,56 @@ extern uint8_t ip_address[4];
 #define FIN (1 << 0)
 
 struct __attribute__((__packed__)) TCP_HEADER {
-  uint16_t src_port;
-  uint16_t dst_port;
-  uint32_t seq_num;
-  uint32_t ack_num;
-  uint8_t reserved : 4;
-  uint8_t data_offset : 4;
-  uint8_t flags;
-  uint16_t window_size;
-  uint16_t checksum;
-  uint16_t urgent_pointer;
+  u16 src_port;
+  u16 dst_port;
+  u32 seq_num;
+  u32 ack_num;
+  u8 reserved : 4;
+  u8 data_offset : 4;
+  u8 flags;
+  u16 window_size;
+  u16 checksum;
+  u16 urgent_pointer;
 };
 
 struct __attribute__((__packed__)) PSEUDO_TCP_HEADER {
-  uint32_t src_addr;
-  uint32_t dst_addr;
-  uint8_t zero;
-  uint8_t protocol;
-  uint16_t tcp_length;
-  uint16_t src_port;
-  uint16_t dst_port;
-  uint32_t seq_num;
-  uint32_t ack_num;
-  uint8_t reserved : 4;
-  uint8_t data_offset : 4;
-  uint8_t flags;
-  uint16_t window_size;
-  uint16_t checksum_zero; // ?????
-  uint16_t urgent_pointer;
+  u32 src_addr;
+  u32 dst_addr;
+  u8 zero;
+  u8 protocol;
+  u16 tcp_length;
+  u16 src_port;
+  u16 dst_port;
+  u32 seq_num;
+  u32 ack_num;
+  u8 reserved : 4;
+  u8 data_offset : 4;
+  u8 flags;
+  u16 window_size;
+  u16 checksum_zero; // ?????
+  u16 urgent_pointer;
 };
 
-uint16_t tcp_checksum(uint16_t *buffer, int size) {
+u16 tcp_checksum(u16 *buffer, int size) {
   unsigned long cksum = 0;
   while (size > 1) {
     cksum += *buffer++;
-    size -= sizeof(uint16_t);
+    size -= sizeof(u16);
   }
   if (size)
-    cksum += *(uint8_t *)buffer;
+    cksum += *(u8 *)buffer;
 
   cksum = (cksum >> 16) + (cksum & 0xffff);
   cksum += (cksum >> 16);
-  return (uint16_t)(~cksum);
+  return (u16)(~cksum);
 }
 
-void tcp_calculate_checksum(uint8_t src_ip[4], uint8_t dst_ip[4],
-                            const uint8_t *payload, uint16_t payload_length,
+void tcp_calculate_checksum(u8 src_ip[4], u8 dst_ip[4],
+                            const u8 *payload, u16 payload_length,
                             struct TCP_HEADER *header) {
   struct PSEUDO_TCP_HEADER ps = {0};
-  memcpy(&ps.src_addr, src_ip, sizeof(uint32_t));
-  memcpy(&ps.dst_addr, dst_ip, sizeof(uint32_t));
+  memcpy(&ps.src_addr, src_ip, sizeof(u32));
+  memcpy(&ps.dst_addr, dst_ip, sizeof(u32));
   ps.protocol = 6;
   ps.tcp_length = htons(20 + payload_length);
   ps.src_port = header->src_port;
@@ -79,10 +79,10 @@ void tcp_calculate_checksum(uint8_t src_ip[4], uint8_t dst_ip[4],
   ps.urgent_pointer = header->urgent_pointer;
   //  ps.options = 0;
   int buffer_length = sizeof(ps) + payload_length;
-  uint8_t buffer[buffer_length];
+  u8 buffer[buffer_length];
   memcpy(buffer, &ps, sizeof(ps));
   memcpy(buffer + sizeof(ps), payload, payload_length);
-  header->checksum = tcp_checksum((uint16_t *)buffer, buffer_length);
+  header->checksum = tcp_checksum((u16 *)buffer, buffer_length);
 }
 
 void tcp_close_connection(struct INCOMING_TCP_CONNECTION *inc) {
@@ -96,21 +96,21 @@ void tcp_close_connection(struct INCOMING_TCP_CONNECTION *inc) {
   header.flags = FIN | ACK;
   header.window_size = htons(512);
   header.urgent_pointer = 0;
-  uint32_t dst_ip;
+  u32 dst_ip;
   memcpy(&dst_ip, inc->ip, sizeof(dst_ip));
-  uint8_t payload[0];
-  uint16_t payload_length = 0;
-  tcp_calculate_checksum(ip_address, inc->ip, (const uint8_t *)payload,
+  u8 payload[0];
+  u16 payload_length = 0;
+  tcp_calculate_checksum(ip_address, inc->ip, (const u8 *)payload,
                          payload_length, &header);
   int send_len = sizeof(header) + payload_length;
-  uint8_t send_buffer[send_len];
+  u8 send_buffer[send_len];
   memcpy(send_buffer, &header, sizeof(header));
   memcpy(send_buffer + sizeof(header), payload, payload_length);
   send_ipv4_packet(dst_ip, 6, send_buffer, send_len);
 }
 
-void send_tcp_packet(struct INCOMING_TCP_CONNECTION *inc, uint8_t *payload,
-                     uint16_t payload_length) {
+void send_tcp_packet(struct INCOMING_TCP_CONNECTION *inc, u8 *payload,
+                     u16 payload_length) {
   struct TCP_HEADER header = {0};
   header.src_port = htons(inc->dst_port);
   header.dst_port = inc->n_port;
@@ -121,12 +121,12 @@ void send_tcp_packet(struct INCOMING_TCP_CONNECTION *inc, uint8_t *payload,
   header.flags = PSH | ACK;
   header.window_size = htons(512);
   header.urgent_pointer = 0;
-  uint32_t dst_ip;
+  u32 dst_ip;
   memcpy(&dst_ip, inc->ip, sizeof(dst_ip));
-  tcp_calculate_checksum(ip_address, inc->ip, (const uint8_t *)payload,
+  tcp_calculate_checksum(ip_address, inc->ip, (const u8 *)payload,
                          payload_length, &header);
   int send_len = sizeof(header) + payload_length;
-  uint8_t send_buffer[send_len];
+  u8 send_buffer[send_len];
   memcpy(send_buffer, &header, sizeof(header));
   memcpy(send_buffer + sizeof(header), payload, payload_length);
   send_ipv4_packet(dst_ip, 6, send_buffer, send_len);
@@ -134,9 +134,9 @@ void send_tcp_packet(struct INCOMING_TCP_CONNECTION *inc, uint8_t *payload,
   inc->seq_num += payload_length;
 }
 
-void send_empty_tcp_message(struct INCOMING_TCP_CONNECTION *inc, uint8_t flags,
-                            uint32_t inc_seq_num, uint16_t n_dst_port,
-                            uint16_t n_src_port) {
+void send_empty_tcp_message(struct INCOMING_TCP_CONNECTION *inc, u8 flags,
+                            u32 inc_seq_num, u16 n_dst_port,
+                            u16 n_src_port) {
   struct TCP_HEADER header = {0};
   header.src_port = n_dst_port;
   header.dst_port = n_src_port;
@@ -148,28 +148,28 @@ void send_empty_tcp_message(struct INCOMING_TCP_CONNECTION *inc, uint8_t flags,
   header.window_size = htons(512); // TODO: What does this actually mean?
   header.urgent_pointer = 0;
   char payload[0];
-  tcp_calculate_checksum(ip_address, inc->ip, (const uint8_t *)payload, 0,
+  tcp_calculate_checksum(ip_address, inc->ip, (const u8 *)payload, 0,
                          &header);
-  uint32_t dst_ip;
+  u32 dst_ip;
   memcpy(&dst_ip, inc->ip, sizeof(dst_ip));
-  send_ipv4_packet(dst_ip, 6, (const uint8_t *)&header, sizeof(header));
+  send_ipv4_packet(dst_ip, 6, (const u8 *)&header, sizeof(header));
 }
 
-void handle_tcp(uint8_t src_ip[4], const uint8_t *payload,
-                uint32_t payload_length) {
+void handle_tcp(u8 src_ip[4], const u8 *payload,
+                u32 payload_length) {
   const struct TCP_HEADER *inc_header = (const struct TCP_HEADER *)payload;
-  uint16_t n_src_port = *(uint16_t *)(payload);
-  uint16_t n_dst_port = *(uint16_t *)(payload + 2);
-  uint32_t n_seq_num = *(uint32_t *)(payload + 4);
-  uint32_t n_ack_num = *(uint32_t *)(payload + 8);
+  u16 n_src_port = *(u16 *)(payload);
+  u16 n_dst_port = *(u16 *)(payload + 2);
+  u32 n_seq_num = *(u32 *)(payload + 4);
+  u32 n_ack_num = *(u32 *)(payload + 8);
 
-  uint8_t flags = *(payload + 13);
+  u8 flags = *(payload + 13);
 
-  uint16_t src_port = htons(n_src_port);
+  u16 src_port = htons(n_src_port);
   (void)src_port;
-  uint16_t dst_port = htons(n_dst_port);
-  uint32_t seq_num = htonl(n_seq_num);
-  uint32_t ack_num = htonl(n_ack_num);
+  u16 dst_port = htons(n_dst_port);
+  u32 seq_num = htonl(n_seq_num);
+  u32 ack_num = htonl(n_ack_num);
   (void)ack_num;
 
   if (SYN == flags) {
@@ -177,7 +177,7 @@ void handle_tcp(uint8_t src_ip[4], const uint8_t *payload,
     struct INCOMING_TCP_CONNECTION *inc;
     if (!(inc = handle_incoming_tcp_connection(src_ip, n_src_port, dst_port)))
       return;
-    memcpy(inc->ip, src_ip, sizeof(uint8_t[4]));
+    memcpy(inc->ip, src_ip, sizeof(u8[4]));
     inc->seq_num = 0;
     inc->ack_num = seq_num + 1;
     inc->connection_closed = 0;
@@ -206,10 +206,10 @@ void handle_tcp(uint8_t src_ip[4], const uint8_t *payload,
   }
   if (flags & PSH) {
     kprintf("send ipv4 packet: %x\n", pit_num_ms());
-    uint16_t tcp_payload_length =
-        payload_length - inc_header->data_offset * sizeof(uint32_t);
+    u16 tcp_payload_length =
+        payload_length - inc_header->data_offset * sizeof(u32);
     fifo_object_write(
-        (uint8_t *)(payload + inc_header->data_offset * sizeof(uint32_t)), 0,
+        (u8 *)(payload + inc_header->data_offset * sizeof(u32)), 0,
         tcp_payload_length, inc->data_file);
 
     // Send back a ACK
@@ -225,11 +225,11 @@ void handle_tcp(uint8_t src_ip[4], const uint8_t *payload,
     header.window_size = htons(512); // TODO: What does this actually mean?
     header.urgent_pointer = 0;
     char payload[0];
-    tcp_calculate_checksum(ip_address, src_ip, (const uint8_t *)payload, 0,
+    tcp_calculate_checksum(ip_address, src_ip, (const u8 *)payload, 0,
                            &header);
-    uint32_t dst_ip;
+    u32 dst_ip;
     memcpy(&dst_ip, src_ip, sizeof(dst_ip));
-    send_ipv4_packet(dst_ip, 6, (const uint8_t *)&header, sizeof(header));
+    send_ipv4_packet(dst_ip, 6, (const u8 *)&header, sizeof(header));
     kprintf("after ipv4 packet: %x\n", pit_num_ms());
     return;
   }
diff --git a/kernel/network/tcp.h b/kernel/network/tcp.h
index fbd6065..7143e4d 100644
--- a/kernel/network/tcp.h
+++ b/kernel/network/tcp.h
@@ -1,5 +1,5 @@
-void handle_tcp(uint8_t src_ip[4], const uint8_t *payload,
-                uint32_t payload_length);
-void send_tcp_packet(struct INCOMING_TCP_CONNECTION *inc, uint8_t *payload,
-                     uint16_t payload_length);
+void handle_tcp(u8 src_ip[4], const u8 *payload,
+                u32 payload_length);
+void send_tcp_packet(struct INCOMING_TCP_CONNECTION *inc, u8 *payload,
+                     u16 payload_length);
 void tcp_close_connection(struct INCOMING_TCP_CONNECTION *s);
diff --git a/kernel/network/udp.c b/kernel/network/udp.c
index 23411da..8c28610 100644
--- a/kernel/network/udp.c
+++ b/kernel/network/udp.c
@@ -5,33 +5,33 @@
 #include <socket.h>
 
 void send_udp_packet(struct sockaddr_in *src, const struct sockaddr_in *dst,
-                     const uint8_t *payload, uint16_t payload_length) {
-  uint16_t header[4] = {0};
+                     const u8 *payload, u16 payload_length) {
+  u16 header[4] = {0};
   header[0] = src->sin_port;
   header[1] = dst->sin_port;
   header[2] = htons(payload_length + 8);
 
-  uint16_t packet_length = sizeof(header) + payload_length;
-  uint8_t *packet = kmalloc(packet_length);
+  u16 packet_length = sizeof(header) + payload_length;
+  u8 *packet = kmalloc(packet_length);
   memcpy(packet, header, sizeof(header));
   memcpy(packet + sizeof(header), payload, payload_length);
   send_ipv4_packet(dst->sin_addr.s_addr, 0x11, packet, packet_length);
   kfree(packet);
 }
 
-void handle_udp(uint8_t src_ip[4], const uint8_t *payload,
-                uint32_t packet_length) {
+void handle_udp(u8 src_ip[4], const u8 *payload,
+                u32 packet_length) {
   assert(packet_length >= 8);
   // n_.* means network format(big endian)
   // h_.* means host format((probably) little endian)
-  uint16_t n_source_port = *(uint16_t *)payload;
-  uint16_t h_source_port = ntohs(n_source_port);
+  u16 n_source_port = *(u16 *)payload;
+  u16 h_source_port = ntohs(n_source_port);
   (void)h_source_port;
-  uint16_t h_dst_port = ntohs(*(uint16_t *)(payload + 2));
-  uint16_t h_length = ntohs(*(uint16_t *)(payload + 4));
+  u16 h_dst_port = ntohs(*(u16 *)(payload + 2));
+  u16 h_length = ntohs(*(u16 *)(payload + 4));
   assert(h_length == packet_length);
-  uint16_t data_length = h_length - 8;
-  const uint8_t *data = payload + 8;
+  u16 data_length = h_length - 8;
+  const u8 *data = payload + 8;
 
   // Find the open port
   OPEN_INET_SOCKET *in_s = find_open_udp_port(htons(h_dst_port));
@@ -44,12 +44,12 @@ void handle_udp(uint8_t src_ip[4], const uint8_t *payload,
   struct sockaddr_in /*{
     sa_family_t sin_family;
     union {
-      uint32_t s_addr;
+      u32 s_addr;
     } sin_addr;
-    uint16_t sin_port;
+    u16 sin_port;
   }*/ in;
   in.sin_family = AF_INET;
-  memcpy(&in.sin_addr.s_addr, src_ip, sizeof(uint32_t));
+  memcpy(&in.sin_addr.s_addr, src_ip, sizeof(u32));
   in.sin_port = n_source_port;
   socklen_t sock_length = sizeof(struct sockaddr_in);
 
@@ -57,7 +57,7 @@ void handle_udp(uint8_t src_ip[4], const uint8_t *payload,
   raw_vfs_pwrite(fifo_file, &in, sizeof(in), 0);
 
   // Write the UDP payload length(not including header)
-  raw_vfs_pwrite(fifo_file, &data_length, sizeof(uint16_t), 0);
+  raw_vfs_pwrite(fifo_file, &data_length, sizeof(u16), 0);
 
   // Write the UDP payload
   raw_vfs_pwrite(fifo_file, (char *)data, data_length, 0);
diff --git a/kernel/network/udp.h b/kernel/network/udp.h
index c30b8c8..ea1aafc 100644
--- a/kernel/network/udp.h
+++ b/kernel/network/udp.h
@@ -1,7 +1,7 @@
 #include <socket.h>
-#include <stdint.h>
+#include <typedefs.h>
 
-void handle_udp(uint8_t src_ip[4], const uint8_t *payload,
-                uint32_t packet_length);
+void handle_udp(u8 src_ip[4], const u8 *payload,
+                u32 packet_length);
 void send_udp_packet(struct sockaddr_in *src, const struct sockaddr_in *dst,
-                     const uint8_t *payload, uint16_t payload_length);
+                     const u8 *payload, u16 payload_length);
diff --git a/kernel/poll.h b/kernel/poll.h
index 19698dd..554d2d6 100644
--- a/kernel/poll.h
+++ b/kernel/poll.h
@@ -1,4 +1,4 @@
-#include <stdint.h>
+#include <typedefs.h>
 #include <stddef.h>
 
 #define POLLIN (1 << 0)
diff --git a/kernel/random.c b/kernel/random.c
index 0e1b760..c043cdf 100644
--- a/kernel/random.c
+++ b/kernel/random.c
@@ -10,7 +10,7 @@
 #define HASH_CTX SHA1_CTX
 #define HASH_LEN SHA1_LEN
 
-uint32_t internal_chacha_block[16] = {
+u32 internal_chacha_block[16] = {
     // Constant ascii values of "expand 32-byte k"
     0x61707865,
     0x3320646e,
@@ -33,15 +33,15 @@ uint32_t internal_chacha_block[16] = {
 };
 
 void mix_chacha(void) {
-  uint8_t rand_data[BLOCK_SIZE];
+  u8 rand_data[BLOCK_SIZE];
   get_random((BYTEPTR)rand_data, BLOCK_SIZE);
   memcpy(internal_chacha_block + KEY, rand_data, KEY_SIZE);
   memcpy(internal_chacha_block + NONCE, rand_data + KEY_SIZE, NONCE_SIZE);
   internal_chacha_block[COUNT] = 0;
 }
 
-void get_random(BYTEPTR buffer, uint64_t len) {
-  uint8_t rand_data[BLOCK_SIZE];
+void get_random(BYTEPTR buffer, u64 len) {
+  u8 rand_data[BLOCK_SIZE];
   for (; len > 0;) {
     if (COUNT_MAX - 1 == internal_chacha_block[COUNT]) {
       // The current block has used up all the 2^32 counts. If the
@@ -53,8 +53,8 @@ void get_random(BYTEPTR buffer, uint64_t len) {
       internal_chacha_block[COUNT]++;
       mix_chacha();
     }
-    uint32_t read_len = (BLOCK_SIZE < len) ? (BLOCK_SIZE) : len;
-    chacha_block((uint32_t *)rand_data, internal_chacha_block);
+    u32 read_len = (BLOCK_SIZE < len) ? (BLOCK_SIZE) : len;
+    chacha_block((u32 *)rand_data, internal_chacha_block);
     internal_chacha_block[COUNT]++;
     memcpy(buffer, rand_data, read_len);
     buffer += read_len;
@@ -63,13 +63,13 @@ void get_random(BYTEPTR buffer, uint64_t len) {
 }
 
 HASH_CTX hash_pool;
-uint32_t hash_pool_size = 0;
+u32 hash_pool_size = 0;
 
 void add_hash_pool(void) {
-  uint8_t new_chacha_key[KEY_SIZE];
+  u8 new_chacha_key[KEY_SIZE];
   get_random(new_chacha_key, KEY_SIZE);
 
-  uint8_t hash_buffer[HASH_LEN];
+  u8 hash_buffer[HASH_LEN];
   SHA1_Final(&hash_pool, hash_buffer);
   for (size_t i = 0; i < HASH_LEN; i++)
     new_chacha_key[i % KEY_SIZE] ^= hash_buffer[i];
@@ -77,7 +77,7 @@ void add_hash_pool(void) {
   SHA1_Init(&hash_pool);
   SHA1_Update(&hash_pool, hash_buffer, HASH_LEN);
 
-  uint8_t block[BLOCK_SIZE];
+  u8 block[BLOCK_SIZE];
   get_random(block, BLOCK_SIZE);
   SHA1_Update(&hash_pool, block, BLOCK_SIZE);
 
@@ -86,7 +86,7 @@ void add_hash_pool(void) {
   mix_chacha();
 }
 
-void add_entropy(uint8_t *buffer, size_t size) {
+void add_entropy(u8 *buffer, size_t size) {
   SHA1_Update(&hash_pool, buffer, size);
   hash_pool_size += size;
   if (hash_pool_size >= HASH_LEN * 2)
@@ -120,14 +120,14 @@ void setup_random(void) {
   vfs_close(rand_fd);
 }
 
-int random_write(BYTEPTR buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int random_write(BYTEPTR buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)offset;
   (void)fd;
   add_entropy(buffer, len);
   return len; // add_entropy() never fails to recieve (len) amount of data.
 }
 
-int random_read(BYTEPTR buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int random_read(BYTEPTR buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)offset;
   (void)fd;
   get_random(buffer, len);
diff --git a/kernel/random.h b/kernel/random.h
index 437927f..c81bfc6 100644
--- a/kernel/random.h
+++ b/kernel/random.h
@@ -1,7 +1,7 @@
-#include <stdint.h>
+#include <typedefs.h>
 #include <fs/vfs.h>
 #include <defs.h>
 
 void setup_random(void);
 void add_random_devices(void);
-void get_random(uint8_t* buffer, uint64_t len);
+void get_random(u8* buffer, u64 len);
diff --git a/kernel/scalls/mmap.h b/kernel/scalls/mmap.h
index f5e121e..6b27005 100644
--- a/kernel/scalls/mmap.h
+++ b/kernel/scalls/mmap.h
@@ -1,5 +1,5 @@
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 typedef struct SYS_MMAP_PARAMS {
   void *addr;
diff --git a/kernel/scalls/msleep.c b/kernel/scalls/msleep.c
index 0120f08..77c4272 100644
--- a/kernel/scalls/msleep.c
+++ b/kernel/scalls/msleep.c
@@ -3,7 +3,7 @@
 #include <sched/scheduler.h>
 #include <stdio.h>
 
-void syscall_msleep(uint32_t ms) {
+void syscall_msleep(u32 ms) {
   get_current_task()->sleep_until = pit_num_ms() + ms;
   switch_task();
 }
diff --git a/kernel/scalls/msleep.h b/kernel/scalls/msleep.h
index 71bf269..03be904 100644
--- a/kernel/scalls/msleep.h
+++ b/kernel/scalls/msleep.h
@@ -1,5 +1,5 @@
 #ifndef MSLEEP_H
 #define MSLEEP_H
-#include <stdint.h>
-void syscall_msleep(uint32_t ms);
+#include <typedefs.h>
+void syscall_msleep(u32 ms);
 #endif
diff --git a/kernel/scalls/recvfrom.c b/kernel/scalls/recvfrom.c
index 1770fa1..af4e809 100644
--- a/kernel/scalls/recvfrom.c
+++ b/kernel/scalls/recvfrom.c
@@ -21,7 +21,7 @@ size_t syscall_recvfrom(
     poll(fds, 1, 0);
   }
 
-  uint16_t data_length;
+  u16 data_length;
   socklen_t tmp_socklen;
   vfs_pread(socket, &tmp_socklen, sizeof(socklen_t), 0);
   if (address_len)
diff --git a/kernel/scalls/recvfrom.h b/kernel/scalls/recvfrom.h
index d81a1e0..72e4712 100644
--- a/kernel/scalls/recvfrom.h
+++ b/kernel/scalls/recvfrom.h
@@ -1,8 +1,8 @@
 #include <socket.h>
 
 struct two_args {
-  uint32_t a;
-  uint32_t b;
+  u32 a;
+  u32 b;
 };
 
 size_t syscall_recvfrom(
diff --git a/kernel/scalls/sendto.h b/kernel/scalls/sendto.h
index 0f852de..40c32ee 100644
--- a/kernel/scalls/sendto.h
+++ b/kernel/scalls/sendto.h
@@ -1,9 +1,9 @@
 #include <socket.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 struct t_two_args {
-  uint32_t a;
-  uint32_t b;
+  u32 a;
+  u32 b;
 };
 size_t syscall_sendto(int socket, const void *message, size_t length,
            int flags, struct t_two_args *extra_args /*
diff --git a/kernel/scalls/shm.h b/kernel/scalls/shm.h
index 80e4366..61a30b0 100644
--- a/kernel/scalls/shm.h
+++ b/kernel/scalls/shm.h
@@ -1,7 +1,7 @@
 #ifndef SYS_SHM_H
 #define SYS_SHM_H
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 typedef int mode_t;
 
 typedef struct SYS_SHM_OPEN_PARAMS {
diff --git a/kernel/scalls/uptime.c b/kernel/scalls/uptime.c
index 866c7e5..748915e 100644
--- a/kernel/scalls/uptime.c
+++ b/kernel/scalls/uptime.c
@@ -1,4 +1,4 @@
 #include <scalls/uptime.h>
 #include <drivers/pit.h>
 
-uint32_t syscall_uptime(void) { return (uint32_t)pit_num_ms(); }
+u32 syscall_uptime(void) { return (u32)pit_num_ms(); }
diff --git a/kernel/scalls/uptime.h b/kernel/scalls/uptime.h
index 2b5b0c9..b432454 100644
--- a/kernel/scalls/uptime.h
+++ b/kernel/scalls/uptime.h
@@ -1,2 +1,2 @@
-#include <stdint.h>
-uint32_t syscall_uptime(void);
+#include <typedefs.h>
+u32 syscall_uptime(void);
diff --git a/kernel/sched/scheduler.c b/kernel/sched/scheduler.c
index 36e8b8d..e81320b 100644
--- a/kernel/sched/scheduler.c
+++ b/kernel/sched/scheduler.c
@@ -13,9 +13,9 @@
 
 process_t *ready_queue;
 process_t *current_task = NULL;
-uint32_t next_pid = 0;
+u32 next_pid = 0;
 
-extern uint32_t read_eip(void);
+extern u32 read_eip(void);
 
 process_t *get_current_task(void) { return current_task; }
 
@@ -56,7 +56,7 @@ process_t *create_process(process_t *p) {
 
   strcpy(r->current_working_directory, "/");
   r->data_segment_end = (p) ? p->data_segment_end : NULL;
-  memset((void *)r->halts, 0, 2 * sizeof(uint32_t));
+  memset((void *)r->halts, 0, 2 * sizeof(u32));
   for (int i = 0; i < 100; i++) {
     if (p) {
       r->file_descriptors[i] = p->file_descriptors[i];
@@ -149,12 +149,12 @@ void exit(int status) {
   switch_task();
 }
 
-uint32_t setup_stack(uint32_t stack_pointer, int argc, char **argv) {
+u32 setup_stack(u32 stack_pointer, int argc, char **argv) {
   mmu_allocate_region(STACK_LOCATION - STACK_SIZE, STACK_SIZE, MMU_FLAG_RW,
                       NULL);
   flush_tlb();
 
-  uint32_t ptr = stack_pointer;
+  u32 ptr = stack_pointer;
 
   char *argv_ptrs[argc + 1];
   for (int i = 0; i < argc; i++) {
@@ -196,7 +196,7 @@ int exec(const char *filename, char **argv) {
     argc++;
   }
 
-  uint32_t end_of_code;
+  u32 end_of_code;
   void *entry = load_elf_file(filename, &end_of_code);
   if (!entry) {
     return 0;
@@ -207,7 +207,7 @@ int exec(const char *filename, char **argv) {
 
   current_task->data_segment_end = align_page((void *)end_of_code);
 
-  uint32_t ptr = setup_stack(0x90000000, argc, argv);
+  u32 ptr = setup_stack(0x90000000, argc, argv);
 
   jump_usermode((void (*)())(entry), ptr);
   ASSERT_NOT_REACHED;
@@ -225,7 +225,7 @@ int fork(void) {
 
   tmp_task->next = new_task;
 
-  uint32_t eip = read_eip();
+  u32 eip = read_eip();
 
   if (current_task != parent_task) {
     return 0;
@@ -278,7 +278,7 @@ int task_save_state(void) {
   asm("mov %%esp, %0" : "=r"(current_task->esp));
   asm("mov %%ebp, %0" : "=r"(current_task->ebp));
 
-  uint32_t eip = read_eip();
+  u32 eip = read_eip();
 
   if (0x1 == eip) {
     // Should the returned value from read_eip be equal to one it
@@ -310,7 +310,7 @@ int kill(pid_t pid, int sig) {
   return 0;
 }
 
-void jump_signal_handler(void *func, uint32_t esp);
+void jump_signal_handler(void *func, u32 esp);
 void switch_task() {
   if (!current_task)
     return;
@@ -324,7 +324,7 @@ void switch_task() {
   active_directory = current_task->cr3;
 
   if (current_task->incoming_signal) {
-    uint8_t sig = current_task->incoming_signal;
+    u8 sig = current_task->incoming_signal;
     current_task->incoming_signal = 0;
     asm("mov %0, %%cr3" ::"r"(current_task->cr3->physical_address));
 
diff --git a/kernel/sched/scheduler.h b/kernel/sched/scheduler.h
index fc92ff3..f57a319 100644
--- a/kernel/sched/scheduler.h
+++ b/kernel/sched/scheduler.h
@@ -26,26 +26,26 @@ void set_signal_handler(int sig, void (*handler)(int));
 typedef struct {
   void *u_address;
   void *k_address;
-  uint32_t length;
+  u32 length;
   int fd;
 } MemoryMap;
 
 typedef struct Process process_t;
 
 struct Process {
-  uint32_t pid;
+  u32 pid;
   char program_name[100];
   char current_working_directory[MAX_PATH];
-  uint32_t eip, esp, ebp;
-  uint8_t incoming_signal;
-  uint32_t signal_handler_stack;
+  u32 eip, esp, ebp;
+  u8 incoming_signal;
+  u32 signal_handler_stack;
   void *signal_handlers[20];
   PageDirectory *cr3;
   vfs_fd_t *file_descriptors[100];
   vfs_inode_t *read_halt_inode[100];
   vfs_inode_t *write_halt_inode[100];
   vfs_inode_t *disconnect_halt_inode[100];
-  uint32_t halts[2];
+  u32 halts[2];
   struct Halt *halt_list;
   void *data_segment_end;
   process_t *next;
@@ -54,7 +54,7 @@ struct Process {
   // can do stuff such as reap zombies and get status.
   process_t *child;
   MemoryMap *maps[100];
-  uint32_t sleep_until;
+  u32 sleep_until;
   int child_rc;
   int dead;
 };
diff --git a/kernel/socket.c b/kernel/socket.c
index 2e43c44..3f78720 100644
--- a/kernel/socket.c
+++ b/kernel/socket.c
@@ -14,7 +14,7 @@ OPEN_INET_SOCKET *inet_sockets[100] = {0};
 
 struct INCOMING_TCP_CONNECTION tcp_connections[100] = {0};
 
-int tcp_socket_write(uint8_t *buffer, uint64_t offset, uint64_t len,
+int tcp_socket_write(u8 *buffer, u64 offset, u64 len,
                      vfs_fd_t *fd) {
   struct INCOMING_TCP_CONNECTION *s =
       (struct INCOMING_TCP_CONNECTION *)fd->inode->internal_object;
@@ -24,7 +24,7 @@ int tcp_socket_write(uint8_t *buffer, uint64_t offset, uint64_t len,
   return len;
 }
 
-int tcp_socket_read(uint8_t *buffer, uint64_t offset, uint64_t len,
+int tcp_socket_read(u8 *buffer, u64 offset, u64 len,
                     vfs_fd_t *fd) {
   struct INCOMING_TCP_CONNECTION *s =
       (struct INCOMING_TCP_CONNECTION *)fd->inode->internal_object;
@@ -47,10 +47,10 @@ void tcp_socket_close(vfs_fd_t *fd) {
   s->is_used = 0;
 }
 
-struct INCOMING_TCP_CONNECTION *get_incoming_tcp_connection(uint8_t ip[4],
-                                                            uint16_t n_port) {
+struct INCOMING_TCP_CONNECTION *get_incoming_tcp_connection(u8 ip[4],
+                                                            u16 n_port) {
   for (int i = 0; i < 100; i++) {
-    if (0 != memcmp(tcp_connections[i].ip, ip, sizeof(uint8_t[4])))
+    if (0 != memcmp(tcp_connections[i].ip, ip, sizeof(u8[4])))
       continue;
     if (n_port != tcp_connections[i].n_port)
       continue;
@@ -60,8 +60,8 @@ struct INCOMING_TCP_CONNECTION *get_incoming_tcp_connection(uint8_t ip[4],
 }
 
 struct INCOMING_TCP_CONNECTION *
-handle_incoming_tcp_connection(uint8_t ip[4], uint16_t n_port,
-                               uint16_t dst_port) {
+handle_incoming_tcp_connection(u8 ip[4], u16 n_port,
+                               u16 dst_port) {
   OPEN_INET_SOCKET *in = find_open_tcp_port(htons(dst_port));
   if (!in) {
     kprintf("TCP SYN to unopened port: %d\n", dst_port);
@@ -75,7 +75,7 @@ handle_incoming_tcp_connection(uint8_t ip[4], uint16_t n_port,
   }
 
   tcp_connections[i].is_used = 1;
-  memcpy(tcp_connections[i].ip, ip, sizeof(uint8_t[4]));
+  memcpy(tcp_connections[i].ip, ip, sizeof(u8[4]));
   tcp_connections[i].n_port = n_port;
   tcp_connections[i].dst_port = dst_port;
   tcp_connections[i].data_file = create_fifo_object();
@@ -97,7 +97,7 @@ handle_incoming_tcp_connection(uint8_t ip[4], uint16_t n_port,
   // Shitty way of telling the accepting socket we have a incoming
   // connection.
   char c = 'i';
-  fifo_object_write((uint8_t *)&c, 1, 0, s->fifo_file);
+  fifo_object_write((u8 *)&c, 1, 0, s->fifo_file);
   s->ptr_socket_fd->inode->has_data = 1;
 
   vfs_close(n); // Closes the file descriptor in the current process.
@@ -108,7 +108,7 @@ handle_incoming_tcp_connection(uint8_t ip[4], uint16_t n_port,
   return &tcp_connections[i];
 }
 
-OPEN_INET_SOCKET *find_open_tcp_port(uint16_t port) {
+OPEN_INET_SOCKET *find_open_tcp_port(u16 port) {
   for (int i = 0; i < 100; i++) {
     if (!inet_sockets[i])
       continue;
@@ -123,7 +123,7 @@ OPEN_INET_SOCKET *find_open_tcp_port(uint16_t port) {
   return NULL;
 }
 
-OPEN_INET_SOCKET *find_open_udp_port(uint16_t port) {
+OPEN_INET_SOCKET *find_open_udp_port(u16 port) {
   for (int i = 0; i < 100; i++) {
     if (!inet_sockets[i])
       continue;
@@ -164,7 +164,7 @@ int uds_open(const char *path) {
   dual_pipe(fd);
 
   char c = 'i';
-  fifo_object_write((uint8_t *)&c, 1, 0, s->fifo_file);
+  fifo_object_write((u8 *)&c, 1, 0, s->fifo_file);
   s->ptr_socket_fd->inode->has_data = 1;
 
   s->incoming_fd = get_current_task()->file_descriptors[fd[1]];
@@ -250,7 +250,7 @@ int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
   return 0;
 }
 
-int socket_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int socket_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   SOCKET *s = (SOCKET *)fd->inode->internal_object;
   FIFO_FILE *file = s->fifo_file;
   int rc = fifo_object_write(buffer, 0, len, file);
@@ -258,7 +258,7 @@ int socket_write(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
   return rc;
 }
 
-int socket_read(uint8_t *buffer, uint64_t offset, uint64_t len, vfs_fd_t *fd) {
+int socket_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   SOCKET *s = (SOCKET *)fd->inode->internal_object;
   FIFO_FILE *file = s->fifo_file;
   int rc = fifo_object_read(buffer, 0, len, file);
diff --git a/kernel/socket.h b/kernel/socket.h
index e318257..7be5571 100644
--- a/kernel/socket.h
+++ b/kernel/socket.h
@@ -3,7 +3,7 @@
 #include <fs/fifo.h>
 #include <fs/vfs.h>
 #include <stddef.h>
-#include <stdint.h>
+#include <typedefs.h>
 
 #define AF_UNIX 0
 #define AF_INET 1
@@ -36,25 +36,25 @@ typedef struct {
 } OPEN_UNIX_SOCKET;
 
 typedef struct {
-  uint32_t address;
-  uint16_t port;
+  u32 address;
+  u16 port;
   SOCKET *s;
 } OPEN_INET_SOCKET;
 
 struct INCOMING_TCP_CONNECTION {
-  uint8_t ip[4];
-  uint16_t n_port;
-  uint16_t dst_port;
+  u8 ip[4];
+  u16 n_port;
+  u16 dst_port;
   FIFO_FILE *data_file;
-  uint8_t is_used;
-  uint32_t ack_num;
-  uint32_t seq_num;
-  uint8_t connection_closed;
-  uint8_t requesting_connection_close;
+  u8 is_used;
+  u32 ack_num;
+  u32 seq_num;
+  u8 connection_closed;
+  u8 requesting_connection_close;
 };
 
-typedef uint32_t in_addr_t;
-typedef uint16_t in_port_t;
+typedef u32 in_addr_t;
+typedef u16 in_port_t;
 typedef unsigned int sa_family_t;
 typedef int socklen_t;
 
@@ -66,10 +66,10 @@ struct sockaddr {
 struct sockaddr_in {
   sa_family_t sin_family;
   union {
-    uint32_t s_addr;
-    uint8_t a[4];
+    u32 s_addr;
+    u8 a[4];
   } sin_addr;
-  uint16_t sin_port;
+  u16 sin_port;
 };
 
 struct sockaddr_un {
@@ -77,16 +77,16 @@ struct sockaddr_un {
   char *sun_path;         /* Socket pathname */
 };
 
-OPEN_INET_SOCKET *find_open_udp_port(uint16_t port);
-OPEN_INET_SOCKET *find_open_tcp_port(uint16_t port);
+OPEN_INET_SOCKET *find_open_udp_port(u16 port);
+OPEN_INET_SOCKET *find_open_tcp_port(u16 port);
 
 int uds_open(const char *path);
 int socket(int domain, int type, int protocol);
 int accept(int socket, struct sockaddr *address, socklen_t *address_len);
 int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
 struct INCOMING_TCP_CONNECTION *
-handle_incoming_tcp_connection(uint8_t ip[4], uint16_t n_port,
-                               uint16_t dst_port);
-struct INCOMING_TCP_CONNECTION *get_incoming_tcp_connection(uint8_t ip[4],
-                                                            uint16_t n_port);
+handle_incoming_tcp_connection(u8 ip[4], u16 n_port,
+                               u16 dst_port);
+struct INCOMING_TCP_CONNECTION *get_incoming_tcp_connection(u8 ip[4],
+                                                            u16 n_port);
 #endif