Kernel Style: Change uint*_t -> u*

12 files changed, 255 insertions, 255 deletions

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