Kernel Style: Change uint*_t -> u*

12 files changed, 166 insertions, 167 deletions

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