Meta: Apply new clang-format rules to kernel

70 files changed, 265 insertions, 251 deletions

diff --git a/kernel/arch/i386/mmu.c b/kernel/arch/i386/mmu.c
index 002e2fa..288e12a 100644
--- a/kernel/arch/i386/mmu.c
+++ b/kernel/arch/i386/mmu.c
@@ -70,7 +70,9 @@ void *ksbrk_physical(size_t s, void **physical) {
   return r;
 }
 
-u32 mmu_get_number_of_allocated_frames(void) { return num_allocated_frames; }
+u32 mmu_get_number_of_allocated_frames(void) {
+  return num_allocated_frames;
+}
 
 Page *get_page(void *ptr, PageDirectory *directory, int create_new_page,
                int set_user) {
@@ -158,7 +160,9 @@ void write_to_frame(u32 frame_address, u8 on) {
   frames[INDEX_FROM_BIT(frame)] &= ~((u32)0x1 << OFFSET_FROM_BIT(frame));
 }
 
-PageDirectory *get_active_pagedirectory(void) { return active_directory; }
+PageDirectory *get_active_pagedirectory(void) {
+  return active_directory;
+}
 
 PageTable *clone_table(u32 src_index, PageDirectory *src_directory,
                        u32 *physical_address) {
diff --git a/kernel/cpu/gdt.h b/kernel/cpu/gdt.h
index 7cb2dc9..de8ea09 100644
--- a/kernel/cpu/gdt.h
+++ b/kernel/cpu/gdt.h
@@ -1,7 +1,7 @@
 #ifndef GDT_H
 #define GDT_H
-#include <typedefs.h>
 #include <string.h>
+#include <typedefs.h>
 
 #define GDT_ENTRY_SIZE 0x8
 #define GDT_NULL_SEGMENT 0x0
@@ -11,61 +11,59 @@
 #define GDT_USERMODE_DATA_SEGMENT 0x4
 #define GDT_TSS_SEGMENT 0x5
 
-struct GDT_Entry
-{
-	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));
+struct GDT_Entry {
+  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
-{
-	u16 size;
-	u32 offset;
-}__attribute__((packed)) GDT_Pointer;
+typedef struct GDT_Pointer {
+  u16 size;
+  u32 offset;
+} __attribute__((packed)) GDT_Pointer;
 
-struct tss_entry_struct
-{
-	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.
-	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;
+struct tss_entry_struct {
+  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.
+  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();
diff --git a/kernel/cpu/idt.c b/kernel/cpu/idt.c
index 0a5cc77..46782b5 100644
--- a/kernel/cpu/idt.c
+++ b/kernel/cpu/idt.c
@@ -30,8 +30,8 @@ struct IDT_Pointer idtr;
 
 extern void load_idtr(void *idtr);
 
-void format_descriptor(u32 offset, u16 code_segment,
-                       u8 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;
@@ -39,8 +39,7 @@ void format_descriptor(u32 offset, u16 code_segment,
   descriptor->zero = 0;
 }
 
-void install_handler(void (*handler_function)(), u16 type_attribute,
-                     u8 entry) {
+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]);
 }
@@ -110,7 +109,9 @@ __attribute__((interrupt)) void page_fault(registers_t *regs) {
     ;
 }
 
-static inline void io_wait(void) { outb(0x80, 0); }
+static inline void io_wait(void) {
+  outb(0x80, 0);
+}
 
 #define ICW1_ICW4 0x01      /* ICW4 (not) needed */
 #define ICW1_SINGLE 0x02    /* Single (cascade) mode */
diff --git a/kernel/cpu/idt.h b/kernel/cpu/idt.h
index c68ce81..9341887 100644
--- a/kernel/cpu/idt.h
+++ b/kernel/cpu/idt.h
@@ -5,8 +5,8 @@ typedef struct registers registers_t;
 #include <cpu/gdt.h>
 #include <cpu/io.h>
 #include <log.h>
-#include <typedefs.h>
 #include <stdio.h>
+#include <typedefs.h>
 
 /*
  * the type_attribute in the IDT_Entry struct
@@ -65,6 +65,5 @@ struct registers {
 
 void idt_init(void);
 __attribute__((no_caller_saved_registers)) void EOI(unsigned char irq);
-void install_handler(void (*handler_function)(), u16 type_attribute,
-                     u8 entry);
+void install_handler(void (*handler_function)(), u16 type_attribute, u8 entry);
 #endif
diff --git a/kernel/cpu/syscall.c b/kernel/cpu/syscall.c
index 5fd6828..3a2b1ca 100644
--- a/kernel/cpu/syscall.c
+++ b/kernel/cpu/syscall.c
@@ -80,9 +80,13 @@ void syscall_wait(int *status) {
     *status = get_current_task()->child_rc;
 }
 
-int syscall_fork(void) { return fork(); }
+int syscall_fork(void) {
+  return fork();
+}
 
-int syscall_getpid(void) { return get_current_task()->pid; }
+int syscall_getpid(void) {
+  return get_current_task()->pid;
+}
 
 void *align_page(void *a);
 
@@ -105,7 +109,9 @@ void *syscall_sbrk(uintptr_t increment) {
   return rc;
 }
 
-int syscall_close(int fd) { return vfs_close(fd); }
+int syscall_close(int fd) {
+  return vfs_close(fd);
+}
 
 int syscall_openpty(SYS_OPENPTY_PARAMS *args) {
   assert(is_valid_userpointer(args, sizeof(SYS_OPENPTY_PARAMS)));
diff --git a/kernel/crypto/ChaCha20/chacha20.c b/kernel/crypto/ChaCha20/chacha20.c
index 0f74844..4486d00 100644
--- a/kernel/crypto/ChaCha20/chacha20.c
+++ b/kernel/crypto/ChaCha20/chacha20.c
@@ -2,28 +2,27 @@
 
 #define ROTL(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
 #define QR(a, b, c, d)                                                         \
-	(a += b, d ^= a, d = ROTL(d, 16), c += d, b ^= c, b = ROTL(b, 12),     \
-	 a += b, d ^= a, d = ROTL(d, 8), c += d, b ^= c, b = ROTL(b, 7))
+  (a += b, d ^= a, d = ROTL(d, 16), c += d, b ^= c, b = ROTL(b, 12), a += b,   \
+   d ^= a, d = ROTL(d, 8), c += d, b ^= c, b = ROTL(b, 7))
 #define ROUNDS 20
 
-void chacha_block(u32 out[16], u32 const in[16])
-{
-	int i;
-	u32 x[16];
+void chacha_block(u32 out[16], u32 const in[16]) {
+  int i;
+  u32 x[16];
 
-	for (i = 0; i < 16; ++i)
-		x[i] = in[i];
-	for (i = 0; i < ROUNDS; i += 2) {
-		QR(x[0], x[4], x[8], x[12]);
-		QR(x[1], x[5], x[9], x[13]);
-		QR(x[2], x[6], x[10], x[14]);
-		QR(x[3], x[7], x[11], x[15]);
+  for (i = 0; i < 16; ++i)
+    x[i] = in[i];
+  for (i = 0; i < ROUNDS; i += 2) {
+    QR(x[0], x[4], x[8], x[12]);
+    QR(x[1], x[5], x[9], x[13]);
+    QR(x[2], x[6], x[10], x[14]);
+    QR(x[3], x[7], x[11], x[15]);
 
-		QR(x[0], x[5], x[10], x[15]);
-		QR(x[1], x[6], x[11], x[12]);
-		QR(x[2], x[7], x[8], x[13]);
-		QR(x[3], x[4], x[9], x[14]);
-	}
-	for (i = 0; i < 16; ++i)
-		out[i] = x[i] + in[i];
+    QR(x[0], x[5], x[10], x[15]);
+    QR(x[1], x[6], x[11], x[12]);
+    QR(x[2], x[7], x[8], x[13]);
+    QR(x[3], x[4], x[9], x[14]);
+  }
+  for (i = 0; i < 16; ++i)
+    out[i] = x[i] + in[i];
 }
diff --git a/kernel/crypto/ChaCha20/chacha20.h b/kernel/crypto/ChaCha20/chacha20.h
index 3278783..dd4a639 100644
--- a/kernel/crypto/ChaCha20/chacha20.h
+++ b/kernel/crypto/ChaCha20/chacha20.h
@@ -3,13 +3,13 @@
 #include <typedefs.h>
 
 #define KEY 4
-#define KEY_SIZE 8*sizeof(u32)
+#define KEY_SIZE 8 * sizeof(u32)
 #define COUNT 12
 #define COUNT_SIZE sizeof(u32)
-#define COUNT_MAX (0x100000000-1) // 2^32 - 1
+#define COUNT_MAX (0x100000000 - 1) // 2^32 - 1
 #define NONCE 13
-#define NONCE_SIZE 2*sizeof(u32)
-#define BLOCK_SIZE 16*sizeof(u32)
+#define NONCE_SIZE 2 * sizeof(u32)
+#define BLOCK_SIZE 16 * sizeof(u32)
 
 void chacha_block(u32 out[16], u32 const in[16]);
 #endif
diff --git a/kernel/crypto/xoshiro256plusplus/xoshiro256plusplus.c b/kernel/crypto/xoshiro256plusplus/xoshiro256plusplus.c
index 414a5a4..f4833d6 100644
--- a/kernel/crypto/xoshiro256plusplus/xoshiro256plusplus.c
+++ b/kernel/crypto/xoshiro256plusplus/xoshiro256plusplus.c
@@ -26,7 +26,9 @@ static inline uint64_t rotl(const uint64_t x, int k) {
 
 static uint64_t s[4];
 
-void seed_xoshiro_256_pp(uint64_t input[4]) { memcpy(s, input, sizeof(s)); }
+void seed_xoshiro_256_pp(uint64_t input[4]) {
+  memcpy(s, input, sizeof(s));
+}
 
 uint64_t xoshiro_256_pp(void) {
   const uint64_t result = rotl(s[0] + s[3], 23) + s[0];
diff --git a/kernel/drivers/ata.c b/kernel/drivers/ata.c
index 190cf5a..ee9e81b 100644
--- a/kernel/drivers/ata.c
+++ b/kernel/drivers/ata.c
@@ -105,8 +105,7 @@ int poll_status(void) {
 }
 
 // Instructions from: https://wiki.osdev.org/ATA_PIO_Mode#28_bit_PIO
-void
-setup_drive_for_command(u32 lba, u32 sector_count) {
+void 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
@@ -139,8 +138,7 @@ void delayed_rep_outsw(size_t n, u16 port, volatile u8 *buffer) {
   }
 }
 
-void ata_write_lba28(u32 lba, u32 sector_count,
-                     volatile const u8 *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);
@@ -168,8 +166,7 @@ void ata_write_lba28(u32 lba, u32 sector_count,
 }
 
 // Instructions from: https://wiki.osdev.org/ATA_PIO_Mode#28_bit_PIO
-void ata_read_lba28(u32 lba, u32 sector_count,
-                    volatile void *address) {
+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);
 
@@ -227,8 +224,7 @@ 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 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;
diff --git a/kernel/drivers/ata.h b/kernel/drivers/ata.h
index 6aa4906..0b335be 100644
--- a/kernel/drivers/ata.h
+++ b/kernel/drivers/ata.h
@@ -5,12 +5,10 @@
 
 void ata_init(void);
 
-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_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(u32 lba, u32 sector_count,
-                     volatile const u8 *buffer);
+void write_lba(u32 lba, volatile void *address, size_t size, size_t offset);
+void ata_write_lba28(u32 lba, u32 sector_count, volatile const u8 *buffer);
diff --git a/kernel/drivers/keyboard.h b/kernel/drivers/keyboard.h
index 002b9c2..50fffc5 100644
--- a/kernel/drivers/keyboard.h
+++ b/kernel/drivers/keyboard.h
@@ -1,9 +1,9 @@
 #ifndef KEYBOARD_H
 #define KEYBOARD_H
 
-#include <typedefs.h>
-#include <cpu/io.h>
 #include <cpu/idt.h>
+#include <cpu/io.h>
+#include <typedefs.h>
 
 void install_keyboard(void);
 void add_keyboard(void);
diff --git a/kernel/drivers/mouse.c b/kernel/drivers/mouse.c
index 21cb470..78280c1 100644
--- a/kernel/drivers/mouse.c
+++ b/kernel/drivers/mouse.c
@@ -5,10 +5,10 @@
 #include <fs/vfs.h>
 #include <typedefs.h>
 
-u8 mouse_cycle = 0;  // unsigned char
-u8 mouse_u8[3]; // signed char
-u8 mouse_x = 0;      // signed char
-u8 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;
 
@@ -18,16 +18,14 @@ struct mouse_event {
   u8 y;
 };
 
-int fs_mouse_write(u8 *buffer, u64 offset, u64 len,
-                   vfs_fd_t *fd) {
+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;
   mouse_inode->has_data = f->has_data;
   return rc;
 }
 
-int fs_mouse_read(u8 *buffer, u64 offset, u64 len,
-                  vfs_fd_t *fd) {
+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)
     return 0;
@@ -46,7 +44,9 @@ void add_mouse(void) {
   get_current_task()->file_descriptors[fd] = NULL;
 }
 
-__attribute__((interrupt)) void what(registers_t *r) { EOI(0xe); }
+__attribute__((interrupt)) void what(registers_t *r) {
+  EOI(0xe);
+}
 
 __attribute__((interrupt)) void int_mouse(registers_t *r) {
   (void)r;
@@ -54,9 +54,9 @@ __attribute__((interrupt)) void int_mouse(registers_t *r) {
   switch (mouse_cycle) {
   case 0:
     mouse_u8[0] = inb(0x60);
-    if(!(mouse_u8[0] & (1 << 3))) {
-	mouse_cycle = 0;
-    return;
+    if (!(mouse_u8[0] & (1 << 3))) {
+      mouse_cycle = 0;
+      return;
     }
     mouse_cycle++;
     break;
diff --git a/kernel/drivers/pit.c b/kernel/drivers/pit.c
index f29b3f8..567ac2d 100644
--- a/kernel/drivers/pit.c
+++ b/kernel/drivers/pit.c
@@ -7,7 +7,9 @@ u64 clock_num_ms_ticks = 0;
 u64 pit_counter = 0;
 u16 hertz;
 
-u64 pit_num_ms(void) { return clock_num_ms_ticks; }
+u64 pit_num_ms(void) {
+  return clock_num_ms_ticks;
+}
 
 u16 read_pit_count(void) {
   u16 count = 0;
diff --git a/kernel/drivers/pit.h b/kernel/drivers/pit.h
index 4d221c1..ec48cc3 100644
--- a/kernel/drivers/pit.h
+++ b/kernel/drivers/pit.h
@@ -3,8 +3,8 @@
 #include <cpu/idt.h>
 #include <cpu/io.h>
 #include <sched/scheduler.h>
-#include <typedefs.h>
 #include <stdio.h>
+#include <typedefs.h>
 
 void pit_install(void);
 void set_pit_count(u16 hertz);
diff --git a/kernel/drivers/pst.h b/kernel/drivers/pst.h
index e8fdfaa..c020708 100644
--- a/kernel/drivers/pst.h
+++ b/kernel/drivers/pst.h
@@ -2,6 +2,7 @@
 #define PST_H
 #include "../fs/vfs.h"
 
-int openpty(int *amaster, int *aslave, char *name, /*const struct termios*/ void *termp,
+int openpty(int *amaster, int *aslave, char *name,
+            /*const struct termios*/ void *termp,
             /*const struct winsize*/ void *winp);
 #endif
diff --git a/kernel/drivers/serial.c b/kernel/drivers/serial.c
index 549d852..0972349 100644
--- a/kernel/drivers/serial.c
+++ b/kernel/drivers/serial.c
@@ -25,7 +25,9 @@ int serial_init(void) {
   return 0;
 }
 
-int is_transmit_empty() { return inb(PORT + 5) & 0x20; }
+int is_transmit_empty() {
+  return inb(PORT + 5) & 0x20;
+}
 
 void write_serial(char a) {
   while (is_transmit_empty() == 0)
diff --git a/kernel/drivers/vbe.c b/kernel/drivers/vbe.c
index 0fb0600..9c6fa4a 100644
--- a/kernel/drivers/vbe.c
+++ b/kernel/drivers/vbe.c
@@ -43,8 +43,7 @@ void display_driver_init(multiboot_info_t *mbi) {
   vbe_info.bpp = mbi->framebuffer_bpp;
 }
 
-vfs_vm_object_t *vbe_get_vm_object(u64 length, u64 offset,
-                                   vfs_fd_t *fd) {
+vfs_vm_object_t *vbe_get_vm_object(u64 length, u64 offset, vfs_fd_t *fd) {
   (void)fd;
   (void)length;
   (void)offset;
@@ -57,8 +56,7 @@ vfs_vm_object_t *vbe_get_vm_object(u64 length, u64 offset,
   return &vbe_vm_object;
 }
 
-int display_info_read(u8 *buffer, u64 offset, u64 len,
-                      vfs_fd_t *fd) {
+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);
   memcpy(buffer, &vbe_info, read_len);
diff --git a/kernel/elf.c b/kernel/elf.c
index d6d349c..56ff893 100644
--- a/kernel/elf.c
+++ b/kernel/elf.c
@@ -42,8 +42,7 @@ void *load_elf_file(const char *f, u32 *ds) {
     u32 p_memsz = program_header.p_memsz;
     u32 p_vaddr = program_header.p_vaddr;
 
-    u32 pages_to_allocate =
-        (u32)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 4677d3c..2ad4353 100644
--- a/kernel/elf.h
+++ b/kernel/elf.h
@@ -1,9 +1,9 @@
 #ifndef ELF_H
 #define ELF_H
-#include <typedefs.h>
-#include <mmu.h>
-#include <fs/vfs.h>
 #include <assert.h>
+#include <fs/vfs.h>
+#include <mmu.h>
+#include <typedefs.h>
 
 #define ET_NONE 0        // No file type
 #define ET_REL 1         // Relocatable file
@@ -94,6 +94,5 @@ typedef struct {
   Elf32_Word p_align;
 } __attribute__((packed)) Elf32_Phdr;
 
-
 void *load_elf_file(const char *f, u32 *ds);
 #endif
diff --git a/kernel/fs/devfs.c b/kernel/fs/devfs.c
index 7d880f6..c0ad7ce 100644
--- a/kernel/fs/devfs.c
+++ b/kernel/fs/devfs.c
@@ -8,11 +8,9 @@ devfs_file files[20];
 int num_files = 0;
 
 vfs_inode_t *devfs_add_file(
-    char *path,
-    int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    char *path, 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),
+    vfs_vm_object_t *(get_vm_object)(u64 length, u64 offset, vfs_fd_t *fd),
     u8 has_data, u8 can_write, int type) {
   files[num_files].name = copy_and_allocate_string(path);
 
@@ -46,8 +44,7 @@ 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(u64 length, u64 offset,
-                                     vfs_fd_t *fd) {
+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);
 }
 
diff --git a/kernel/fs/devfs.h b/kernel/fs/devfs.h
index 9de7034..8ebadae 100644
--- a/kernel/fs/devfs.h
+++ b/kernel/fs/devfs.h
@@ -16,11 +16,9 @@ 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)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
+    char *path, 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),
+    vfs_vm_object_t *(*get_vm_object)(u64 length, u64 offset, vfs_fd_t *fd),
     u8 has_data, u8 can_write, int type);
 
 #endif
diff --git a/kernel/fs/fifo.c b/kernel/fs/fifo.c
index 5033717..4ae7c8a 100644
--- a/kernel/fs/fifo.c
+++ b/kernel/fs/fifo.c
@@ -9,8 +9,7 @@ void fifo_close(vfs_fd_t *fd) {
   return;
 }
 
-int fifo_object_write(u8 *buffer, u64 offset, u64 len,
-                      FIFO_FILE *file) {
+int fifo_object_write(u8 *buffer, u64 offset, u64 len, FIFO_FILE *file) {
   (void)offset;
   file->has_data = 1;
   if (file->write_len + len >= file->buffer_len) {
@@ -22,8 +21,7 @@ int fifo_object_write(u8 *buffer, u64 offset, u64 len,
   return len;
 }
 
-int fifo_object_read(u8 *buffer, u64 offset, u64 len,
-                     FIFO_FILE *file) {
+int fifo_object_read(u8 *buffer, u64 offset, u64 len, FIFO_FILE *file) {
   (void)offset;
   if (file->write_len == 0) {
     file->has_data = 0;
diff --git a/kernel/fs/fifo.h b/kernel/fs/fifo.h
index e504c9a..456b85d 100644
--- a/kernel/fs/fifo.h
+++ b/kernel/fs/fifo.h
@@ -16,12 +16,8 @@ struct S_FIFO_FILE {
 
 int create_fifo(void);
 FIFO_FILE *create_fifo_object(void);
-int fifo_object_write(u8 *buffer, u64 offset, u64 len,
-                      FIFO_FILE *file);
-int fifo_object_read(u8 *buffer, u64 offset, u64 len,
-                     FIFO_FILE *file);
-int fifo_write(u8 *buffer, u64 offset, u64 len,
-               vfs_fd_t *fd);
-int fifo_read(u8 *buffer, u64 offset, u64 len,
-              vfs_fd_t *fd);
+int fifo_object_write(u8 *buffer, u64 offset, u64 len, FIFO_FILE *file);
+int fifo_object_read(u8 *buffer, u64 offset, u64 len, FIFO_FILE *file);
+int fifo_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd);
+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 2224cc2..5eb7f23 100644
--- a/kernel/fs/shm.c
+++ b/kernel/fs/shm.c
@@ -9,7 +9,9 @@
 
 HashMap *shared_memory_objects;
 
-void shm_init(void) { shared_memory_objects = hashmap_create(10); }
+void shm_init(void) {
+  shared_memory_objects = hashmap_create(10);
+}
 
 int shm_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   vfs_vm_object_t *p = fd->inode->internal_object;
@@ -39,8 +41,7 @@ int shm_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   return len;
 }
 
-vfs_vm_object_t *shm_get_vm_object(u64 length, u64 offset,
-                                   vfs_fd_t *fd) {
+vfs_vm_object_t *shm_get_vm_object(u64 length, u64 offset, vfs_fd_t *fd) {
   (void)length;
   (void)offset;
   vfs_vm_object_t *p = fd->inode->internal_object;
@@ -81,7 +82,7 @@ int shm_open(const char *name, int oflag, mode_t mode) {
       NULL /*stat*/);
 
   vfs_fd_t *fd_ptr;
-  int fd = vfs_create_fd(oflag, mode, 0/*is_tty*/, inode, &fd_ptr);
+  int fd = vfs_create_fd(oflag, mode, 0 /*is_tty*/, inode, &fd_ptr);
   if (-1 == fd) {
     kfree(inode);
     return -EMFILE;
diff --git a/kernel/fs/shm.h b/kernel/fs/shm.h
index 2a184dd..2cd7f58 100644
--- a/kernel/fs/shm.h
+++ b/kernel/fs/shm.h
@@ -1,8 +1,8 @@
 #ifndef SHM_H
 #define SHM_H
 #include <stddef.h>
-#include <typedefs.h>
 #include <sys/types.h>
+#include <typedefs.h>
 
 void shm_init(void);
 int shm_open(const char *name, int oflag, mode_t mode);
diff --git a/kernel/fs/tmpfs.c b/kernel/fs/tmpfs.c
index d213005..b9f7b7e 100644
--- a/kernel/fs/tmpfs.c
+++ b/kernel/fs/tmpfs.c
@@ -52,7 +52,7 @@ void dual_pipe(int fd[2]) {
     assert(inode);
 
     vfs_fd_t *fd_ptr;
-    fd[i] = vfs_create_fd(O_RDWR | O_NONBLOCK, 0, 0/*is_tty*/, inode, &fd_ptr);
+    fd[i] = vfs_create_fd(O_RDWR | O_NONBLOCK, 0, 0 /*is_tty*/, inode, &fd_ptr);
     assert(-1 != fd[i]);
   }
   vfs_inode_t *f_inode = get_current_task()->file_descriptors[fd[0]]->inode;
diff --git a/kernel/fs/vfs.h b/kernel/fs/vfs.h
index d042acf..77d9efd 100644
--- a/kernel/fs/vfs.h
+++ b/kernel/fs/vfs.h
@@ -4,13 +4,13 @@ typedef struct vfs_vm_object vfs_vm_object_t;
 typedef struct vfs_mounts vfs_mounts_t;
 #ifndef VFS_H
 #define VFS_H
+#include <dirent.h>
 #include <limits.h>
 #include <sched/scheduler.h>
 #include <socket.h>
 #include <stddef.h>
 #include <sys/stat.h>
 #include <typedefs.h>
-#include <dirent.h>
 
 // FIXME: Is there some standard value for this?
 #define O_NONBLOCK (1 << 0)
diff --git a/kernel/halts.c b/kernel/halts.c
index 821299d..b70a4ef 100644
--- a/kernel/halts.c
+++ b/kernel/halts.c
@@ -61,7 +61,9 @@ int create_write_fdhalt(vfs_fd_t *fd) {
   return create_write_inode_halt(fd->inode);
 }
 
-void unset_read_fdhalt(int i) { get_current_task()->read_halt_inode[i] = NULL; }
+void unset_read_fdhalt(int i) {
+  get_current_task()->read_halt_inode[i] = NULL;
+}
 
 void unset_write_fdhalt(int i) {
   get_current_task()->write_halt_inode[i] = NULL;
diff --git a/kernel/hashmap/hashmap.c b/kernel/hashmap/hashmap.c
index 72524e7..8779f0b 100644
--- a/kernel/hashmap/hashmap.c
+++ b/kernel/hashmap/hashmap.c
@@ -28,10 +28,10 @@
  */
 #include "hashmap.h"
 
+#include <kmalloc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <kmalloc.h>
 
 #define CONSTANT 0x031b5515
 
@@ -67,7 +67,9 @@ char *copy_c_string(const char *str) {
   return ret_string;
 }
 
-u32 limit_hash(HashMap *m, u32 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) {
diff --git a/kernel/includes/defs.h b/kernel/includes/defs.h
index 3a373b3..8deae99 100644
--- a/kernel/includes/defs.h
+++ b/kernel/includes/defs.h
@@ -1,5 +1,5 @@
 #ifndef DEFS_H
 #define DEFS_H
 #define BYTE unsigned char
-#define BYTEPTR BYTE*
+#define BYTEPTR BYTE *
 #endif
diff --git a/kernel/includes/syscalls.h b/kernel/includes/syscalls.h
index 46218ce..cdf4f5a 100644
--- a/kernel/includes/syscalls.h
+++ b/kernel/includes/syscalls.h
@@ -1,4 +1,3 @@
-#include <socket.h>
 #include <fs/vfs.h>
 #include <signal.h>
 #include <socket.h>
diff --git a/kernel/kmalloc.c b/kernel/kmalloc.c
index 3871d62..6f8f520 100644
--- a/kernel/kmalloc.c
+++ b/kernel/kmalloc.c
@@ -15,7 +15,9 @@ typedef struct MallocHeader {
   struct MallocHeader *n;
 } MallocHeader;
 
-u64 delta_page(u64 a) { return 0x1000 - (a % 0x1000); }
+u64 delta_page(u64 a) {
+  return 0x1000 - (a % 0x1000);
+}
 
 MallocHeader *head = NULL;
 MallocHeader *final = NULL;
diff --git a/kernel/kmalloc.h b/kernel/kmalloc.h
index 94806f3..8c55cb4 100644
--- a/kernel/kmalloc.h
+++ b/kernel/kmalloc.h
@@ -1,8 +1,8 @@
 #include <log.h>
 #include <mmu.h>
 #include <stddef.h>
-#include <typedefs.h>
 #include <string.h>
+#include <typedefs.h>
 
 void kmalloc_allocate_heap(void);
 
diff --git a/kernel/ksbrk.h b/kernel/ksbrk.h
index a55d985..fba060e 100644
--- a/kernel/ksbrk.h
+++ b/kernel/ksbrk.h
@@ -3,6 +3,6 @@
 #include <stddef.h>
 #include <typedefs.h>
 
-void* ksbrk(size_t s);
+void *ksbrk(size_t s);
 void *ksbrk_physical(size_t s, void **physical);
 #endif
diff --git a/kernel/kubsan.c b/kernel/kubsan.c
index c81b3fc..8c01b87 100644
--- a/kernel/kubsan.c
+++ b/kernel/kubsan.c
@@ -52,7 +52,7 @@ void __ubsan_handle_pointer_overflow(struct OutOfBoundsData *data,
 }
 
 void __ubsan_handle_vla_bound_not_positive(struct OutOfBoundsData *data,
-                                     void *index) {
+                                           void *index) {
   (void)index;
   ubsan_log("handle_vla_bound_not_positive", data->location);
 }
diff --git a/kernel/libc/include/types.h b/kernel/libc/include/types.h
index ffcf281..d9bede0 100644
--- a/kernel/libc/include/types.h
+++ b/kernel/libc/include/types.h
@@ -16,12 +16,12 @@ typedef int dev_t;
 typedef unsigned int fsblkcnt_t;
 typedef unsigned int fsfilcnt_t;
 typedef unsigned int ino_t;
-//typedef unsigned int size_t;
+// typedef unsigned int size_t;
 
 typedef int blksize_t;
 typedef int pid_t;
 typedef int ssize_t;
 
-//typedef int clock_t;
+// typedef int clock_t;
 typedef int time_t;
 #endif
diff --git a/kernel/libc/stdio/print.c b/kernel/libc/stdio/print.c
index f1a4918..fe50f50 100644
--- a/kernel/libc/stdio/print.c
+++ b/kernel/libc/stdio/print.c
@@ -8,7 +8,9 @@
 const char HEX_SET[0x10] = {'0', '1', '2', '3', '4', '5', '6', '7',
                             '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
-inline void putc(const char c) { write_serial(c); }
+inline void putc(const char c) {
+  write_serial(c);
+}
 
 int kprint_hex(u64 num) {
   int c = 2;
@@ -94,4 +96,6 @@ int kprintf(const char *format, ...) {
   return c;
 }
 
-int puts(char *str) { return kprintf("%s\n", str); }
+int puts(char *str) {
+  return kprintf("%s\n", str);
+}
diff --git a/kernel/libc/string/isequal.c b/kernel/libc/string/isequal.c
index 75f7366..90712db 100644
--- a/kernel/libc/string/isequal.c
+++ b/kernel/libc/string/isequal.c
@@ -1,15 +1,15 @@
 #include "../include/string.h"
 
 int isequal(const char *s1, const char *s2) {
-    for(;*s1;s1++,s2++)
-        if(*s1 != *s2)
-            return 0;
-    return 1;
+  for (; *s1; s1++, s2++)
+    if (*s1 != *s2)
+      return 0;
+  return 1;
 }
 
 int isequal_n(const char *s1, const char *s2, u32 n) {
-    for(;*s1 && n;s1++,s2++,n--)
-        if(*s1 != *s2)
-            return 0;
-    return 1;
+  for (; *s1 && n; s1++, s2++, n--)
+    if (*s1 != *s2)
+      return 0;
+  return 1;
 }
diff --git a/kernel/libc/string/memcmp.c b/kernel/libc/string/memcmp.c
index db13ed2..deeb029 100644
--- a/kernel/libc/string/memcmp.c
+++ b/kernel/libc/string/memcmp.c
@@ -1,12 +1,11 @@
 #include "../include/string.h"
 
-int memcmp(const void *s1, const void *s2, u32 n)
-{
-	int return_value = 0;
+int memcmp(const void *s1, const void *s2, u32 n) {
+  int return_value = 0;
 
-	for(u32 i = 0;i < n;i++)
-		if(((unsigned char *)(s1))[i] != ((unsigned char *)(s2))[i])
-			return_value++;
+  for (u32 i = 0; i < n; i++)
+    if (((unsigned char *)(s1))[i] != ((unsigned char *)(s2))[i])
+      return_value++;
 
-	return return_value;
+  return return_value;
 }
diff --git a/kernel/libc/string/memcpy.c b/kernel/libc/string/memcpy.c
index 1313261..8b03536 100644
--- a/kernel/libc/string/memcpy.c
+++ b/kernel/libc/string/memcpy.c
@@ -1,7 +1,6 @@
 #include "../include/string.h"
 
-void *
-memcpy(void *dest, const void *src, u32 n) {
+void *memcpy(void *dest, const void *src, u32 n) {
   unsigned char *d = dest;
   const unsigned char *s = src;
 
diff --git a/kernel/libc/string/strcmp.c b/kernel/libc/string/strcmp.c
index d7039e2..c1b1432 100644
--- a/kernel/libc/string/strcmp.c
+++ b/kernel/libc/string/strcmp.c
@@ -1,8 +1,7 @@
 #include "../include/string.h"
 
-int strcmp(const char *s1, const char *s2)
-{
-	for(;*s1 == *s2 && *s1; s1++, s2++)
-		;
-	return *s1 - *s2;
+int strcmp(const char *s1, const char *s2) {
+  for (; *s1 == *s2 && *s1; s1++, s2++)
+    ;
+  return *s1 - *s2;
 }
diff --git a/kernel/libc/string/strlen.c b/kernel/libc/string/strlen.c
index 4346383..a4a096a 100644
--- a/kernel/libc/string/strlen.c
+++ b/kernel/libc/string/strlen.c
@@ -1,8 +1,8 @@
 #include "../include/string.h"
 
-unsigned long strlen(const char *s)
-{
-	const char * tmp = s;
-	for(;*tmp++;);
-	return (tmp - s)-1;
+unsigned long strlen(const char *s) {
+  const char *tmp = s;
+  for (; *tmp++;)
+    ;
+  return (tmp - s) - 1;
 }
diff --git a/kernel/math.c b/kernel/math.c
index 2d5e30c..7018da0 100644
--- a/kernel/math.c
+++ b/kernel/math.c
@@ -1,3 +1,7 @@
 #include <math.h>
-int min(int a, int b) { return ((a) > (b) ? b : a); }
-int max(int a, int b) { return (a > b) ? a : b; }
+int min(int a, int b) {
+  return ((a) > (b) ? b : a);
+}
+int max(int a, int b) {
+  return (a > b) ? a : b;
+}
diff --git a/kernel/network/arp.c b/kernel/network/arp.c
index baff528..6e589ec 100644
--- a/kernel/network/arp.c
+++ b/kernel/network/arp.c
@@ -14,10 +14,10 @@ struct ARP_DATA {
   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.
+               // If IPv4 can just be a "u32" type.
   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.
+               // above). If IPv4 can just be a "u32" type.
 };
 
 struct ARP_TABLE_ENTRY {
diff --git a/kernel/network/bytes.c b/kernel/network/bytes.c
index f502caf..1d49143 100644
--- a/kernel/network/bytes.c
+++ b/kernel/network/bytes.c
@@ -1,8 +1,12 @@
 #include <network/bytes.h>
 
-u16 ntohs(u16 net) { return (net >> 8) | (net << 8); }
+u16 ntohs(u16 net) {
+  return (net >> 8) | (net << 8);
+}
 
-u16 htons(u16 net) { return (net >> 8) | (net << 8); }
+u16 htons(u16 net) {
+  return (net >> 8) | (net << 8);
+}
 
 u32 htonl(u32 net) {
   return (((net & 0x000000FF) << 24) | ((net & 0x0000FF00) << 8) |
diff --git a/kernel/network/ipv4.c b/kernel/network/ipv4.c
index 9565bb5..6aa03ba 100644
--- a/kernel/network/ipv4.c
+++ b/kernel/network/ipv4.c
@@ -73,8 +73,8 @@ void handle_ipv4(const u8 *payload, u32 packet_length) {
   *(u16 *)(payload + 10) = 0;
   u16 calc_checksum = ip_checksum((u8 *)payload, 20);
   *(u16 *)(payload + 10) = saved_checksum;
-  if(calc_checksum != saved_checksum)
-	  return;
+  if (calc_checksum != saved_checksum)
+    return;
 
   u8 version = (*payload & 0xF0) >> 4;
   u8 IHL = (*payload & 0xF);
diff --git a/kernel/network/ipv4.h b/kernel/network/ipv4.h
index cd15fce..002aaa7 100644
--- a/kernel/network/ipv4.h
+++ b/kernel/network/ipv4.h
@@ -1,5 +1,4 @@
 #include <typedefs.h>
 
 void handle_ipv4(const u8 *payload, u32 packet_length);
-void send_ipv4_packet(u32 ip, u8 protocol, const u8 *payload,
-                      u16 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 e4b0891..86cfdd1 100644
--- a/kernel/network/tcp.c
+++ b/kernel/network/tcp.c
@@ -117,7 +117,7 @@ void send_tcp_packet(struct INCOMING_TCP_CONNECTION *inc, u8 *payload,
     send_tcp_packet(inc, payload, 1500 - 20 - sizeof(struct TCP_HEADER));
     payload_length -= 1500 - 20 - sizeof(struct TCP_HEADER);
     payload += 1500 - 20 - sizeof(struct TCP_HEADER);
-    return  send_tcp_packet(inc, payload, payload_length);
+    return send_tcp_packet(inc, payload, payload_length);
   }
   struct TCP_HEADER header = {0};
   header.src_port = htons(inc->dst_port);
diff --git a/kernel/network/tcp.h b/kernel/network/tcp.h
index 7143e4d..2a836a4 100644
--- a/kernel/network/tcp.h
+++ b/kernel/network/tcp.h
@@ -1,5 +1,4 @@
-void handle_tcp(u8 src_ip[4], const u8 *payload,
-                u32 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 8c28610..5aae050 100644
--- a/kernel/network/udp.c
+++ b/kernel/network/udp.c
@@ -19,8 +19,7 @@ void send_udp_packet(struct sockaddr_in *src, const struct sockaddr_in *dst,
   kfree(packet);
 }
 
-void handle_udp(u8 src_ip[4], const u8 *payload,
-                u32 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)
diff --git a/kernel/network/udp.h b/kernel/network/udp.h
index ea1aafc..fe21b0f 100644
--- a/kernel/network/udp.h
+++ b/kernel/network/udp.h
@@ -1,7 +1,6 @@
 #include <socket.h>
 #include <typedefs.h>
 
-void handle_udp(u8 src_ip[4], const u8 *payload,
-                u32 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 u8 *payload, u16 payload_length);
diff --git a/kernel/poll.h b/kernel/poll.h
index 554d2d6..19359ba 100644
--- a/kernel/poll.h
+++ b/kernel/poll.h
@@ -1,5 +1,5 @@
-#include <typedefs.h>
 #include <stddef.h>
+#include <typedefs.h>
 
 #define POLLIN (1 << 0)
 #define POLLPRI (1 << 1)
@@ -7,9 +7,9 @@
 #define POLLHUP (1 << 3)
 
 struct pollfd {
-    int fd;
-    short events;
-    short revents;
+  int fd;
+  short events;
+  short revents;
 };
 
 int poll(struct pollfd *fds, size_t nfds, int timeout);
diff --git a/kernel/random.c b/kernel/random.c
index 329b7d6..2bfd43b 100644
--- a/kernel/random.c
+++ b/kernel/random.c
@@ -57,7 +57,7 @@ void get_fast_insecure_random(u8 *buffer, u64 len) {
   }
 }
 
-void get_random(u8* buffer, u64 len) {
+void get_random(u8 *buffer, u64 len) {
   u8 rand_data[BLOCK_SIZE];
   for (; len > 0;) {
     if (COUNT_MAX - 1 == internal_chacha_block[COUNT]) {
diff --git a/kernel/random.h b/kernel/random.h
index 5fe91d0..9a44bb3 100644
--- a/kernel/random.h
+++ b/kernel/random.h
@@ -1,8 +1,8 @@
-#include <typedefs.h>
-#include <fs/vfs.h>
 #include <defs.h>
+#include <fs/vfs.h>
+#include <typedefs.h>
 
 void setup_random(void);
 void add_random_devices(void);
-void get_random(u8* buffer, u64 len);
+void get_random(u8 *buffer, u64 len);
 void get_fast_insecure_random(u8 *buffer, u64 len);
diff --git a/kernel/sched/scheduler.c b/kernel/sched/scheduler.c
index ccc5956..ae4a780 100644
--- a/kernel/sched/scheduler.c
+++ b/kernel/sched/scheduler.c
@@ -108,7 +108,9 @@ int get_free_fd(process_t *p, int allocate) {
   return i;
 }
 
-void tasking_init(void) { current_task = ready_queue = create_process(NULL); }
+void tasking_init(void) {
+  current_task = ready_queue = create_process(NULL);
+}
 
 int i = 0;
 void free_process(void) {
diff --git a/kernel/socket.c b/kernel/socket.c
index 27342e0..48b09ea 100644
--- a/kernel/socket.c
+++ b/kernel/socket.c
@@ -265,7 +265,9 @@ int socket_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   return rc;
 }
 
-void socket_close(vfs_fd_t *fd) { fd->inode->is_open = 0; }
+void socket_close(vfs_fd_t *fd) {
+  fd->inode->is_open = 0;
+}
 
 int socket(int domain, int type, int protocol) {
   if (!(AF_UNIX == domain || AF_INET == domain))
diff --git a/kernel/syscalls/getcwd.c b/kernel/syscalls/getcwd.c
index 6f35739..df370fb 100644
--- a/kernel/syscalls/getcwd.c
+++ b/kernel/syscalls/getcwd.c
@@ -1,9 +1,9 @@
 #include <math.h>
-#include <syscalls.h>
 #include <sched/scheduler.h>
+#include <syscalls.h>
 
 char *syscall_getcwd(char *buf, size_t size) {
-	kprintf("syscall_getcwd\n");
+  kprintf("syscall_getcwd\n");
   const char *cwd = get_current_task()->current_working_directory;
   size_t len = min(size, strlen(cwd));
   strlcpy(buf, get_current_task()->current_working_directory, len);
diff --git a/kernel/syscalls/isatty.c b/kernel/syscalls/isatty.c
index 64649e2..883886e 100644
--- a/kernel/syscalls/isatty.c
+++ b/kernel/syscalls/isatty.c
@@ -1,6 +1,6 @@
+#include <errno.h>
 #include <fs/vfs.h>
 #include <syscalls.h>
-#include <errno.h>
 
 int syscall_isatty(int fd) {
   vfs_fd_t *fd_ptr = get_vfs_fd(fd);
diff --git a/kernel/syscalls/kill.c b/kernel/syscalls/kill.c
index 6f8c865..0da229a 100644
--- a/kernel/syscalls/kill.c
+++ b/kernel/syscalls/kill.c
@@ -1,5 +1,7 @@
-#include <syscalls.h>
 #include <sched/scheduler.h>
 #include <signal.h>
+#include <syscalls.h>
 
-int syscall_kill(pid_t pid, int sig) {return kill(pid, sig);}
+int syscall_kill(pid_t pid, int sig) {
+  return kill(pid, sig);
+}
diff --git a/kernel/syscalls/mmap.c b/kernel/syscalls/mmap.c
index 295bc13..85b32a3 100644
--- a/kernel/syscalls/mmap.c
+++ b/kernel/syscalls/mmap.c
@@ -1,5 +1,5 @@
-#include <syscalls.h>
 #include <sched/scheduler.h>
+#include <syscalls.h>
 
 void *syscall_mmap(SYS_MMAP_PARAMS *args) {
   return mmap(args->addr, args->length, args->prot, args->flags, args->fd,
diff --git a/kernel/syscalls/msleep.c b/kernel/syscalls/msleep.c
index 9880b63..a752d94 100644
--- a/kernel/syscalls/msleep.c
+++ b/kernel/syscalls/msleep.c
@@ -1,7 +1,7 @@
 #include <drivers/pit.h>
-#include <syscalls.h>
 #include <sched/scheduler.h>
 #include <stdio.h>
+#include <syscalls.h>
 
 void syscall_msleep(u32 ms) {
   get_current_task()->sleep_until = pit_num_ms() + ms;
diff --git a/kernel/syscalls/open.c b/kernel/syscalls/open.c
index b42a7a8..ef5297b 100644
--- a/kernel/syscalls/open.c
+++ b/kernel/syscalls/open.c
@@ -9,6 +9,6 @@ int syscall_open(const char *file, int flags, mode_t mode) {
   int _flags = flags;
   int _mode = mode;
   int rc = vfs_open(_file, _flags, _mode);
-  kfree((void*)_file);
+  kfree((void *)_file);
   return rc;
 }
diff --git a/kernel/syscalls/ppoll.c b/kernel/syscalls/ppoll.c
index fa85e8c..7c5befa 100644
--- a/kernel/syscalls/ppoll.c
+++ b/kernel/syscalls/ppoll.c
@@ -1,7 +1,7 @@
-#include <syscalls.h>
 #include <fs/vfs.h>
 #include <poll.h>
 #include <sched/scheduler.h>
+#include <syscalls.h>
 
 int syscall_poll(SYS_POLL_PARAMS *args) {
   struct pollfd *fds = args->fds;
diff --git a/kernel/syscalls/pwrite.c b/kernel/syscalls/pwrite.c
index b1e47fe..b251dbb 100644
--- a/kernel/syscalls/pwrite.c
+++ b/kernel/syscalls/pwrite.c
@@ -2,5 +2,5 @@
 #include <syscalls.h>
 
 int syscall_pwrite(int fd, const char *buf, size_t count, size_t offset) {
-  return vfs_pwrite(fd, (char*)buf, count, offset);
+  return vfs_pwrite(fd, (char *)buf, count, offset);
 }
diff --git a/kernel/syscalls/randomfill.c b/kernel/syscalls/randomfill.c
index 41f3ef0..3808009 100644
--- a/kernel/syscalls/randomfill.c
+++ b/kernel/syscalls/randomfill.c
@@ -4,4 +4,6 @@
 // This syscall will never fail. At worst a page fault will occur but if
 // the syscall returns the buffer will have been filled with random
 // data.
-void syscall_randomfill(void *buffer, u32 size) { get_random(buffer, size); }
+void syscall_randomfill(void *buffer, u32 size) {
+  get_random(buffer, size);
+}
diff --git a/kernel/syscalls/shm.c b/kernel/syscalls/shm.c
index 18b672a..39e272e 100644
--- a/kernel/syscalls/shm.c
+++ b/kernel/syscalls/shm.c
@@ -1,5 +1,5 @@
-#include <syscalls.h>
 #include <fs/shm.h>
+#include <syscalls.h>
 
 int syscall_shm_open(SYS_SHM_OPEN_PARAMS *args) {
   return shm_open(args->name, args->oflag, args->mode);
diff --git a/kernel/syscalls/sigaction.c b/kernel/syscalls/sigaction.c
index 98024ea..9882192 100644
--- a/kernel/syscalls/sigaction.c
+++ b/kernel/syscalls/sigaction.c
@@ -1,9 +1,9 @@
-#include <syscalls.h>
-#include <signal.h>
 #include <sched/scheduler.h>
+#include <signal.h>
+#include <syscalls.h>
 
 int syscall_sigaction(int sig, const struct sigaction *restrict act,
-              struct sigaction *restrict oact) {
+                      struct sigaction *restrict oact) {
   set_signal_handler(sig, act->sa_handler);
   return 0;
 }
diff --git a/kernel/syscalls/stat.c b/kernel/syscalls/stat.c
index c430725..0af2121 100644
--- a/kernel/syscalls/stat.c
+++ b/kernel/syscalls/stat.c
@@ -6,8 +6,8 @@ int syscall_stat(SYS_STAT_PARAMS *args) {
   const char *pathname = copy_and_allocate_user_string(args->pathname);
   struct stat *statbuf = args->statbuf;
   int fd = vfs_open(pathname, O_READ, 0);
-  if(0 > fd)
-	  return -ENOENT;
+  if (0 > fd)
+    return -ENOENT;
   int rc = vfs_fstat(fd, statbuf);
   vfs_close(fd);
   return rc;
diff --git a/kernel/syscalls/uptime.c b/kernel/syscalls/uptime.c
index 3de80ba..cb32db5 100644
--- a/kernel/syscalls/uptime.c
+++ b/kernel/syscalls/uptime.c
@@ -1,4 +1,6 @@
-#include <syscalls.h>
 #include <drivers/pit.h>
+#include <syscalls.h>
 
-u32 syscall_uptime(void) { return (u32)pit_num_ms(); }
+u32 syscall_uptime(void) {
+  return (u32)pit_num_ms();
+}
diff --git a/kernel/syscalls/write.c b/kernel/syscalls/write.c
index bdd3927..ef8a46f 100644
--- a/kernel/syscalls/write.c
+++ b/kernel/syscalls/write.c
@@ -1,6 +1,6 @@
+#include <errno.h>
 #include <fs/vfs.h>
 #include <syscalls.h>
-#include <errno.h>
 
 int syscall_write(int fd, const char *buf, size_t count) {
   vfs_fd_t *fd_ptr = get_vfs_fd(fd);