Applied official linux kernel code style guidelines

Due to my change to vim and the clang-format plugin this was needed!

19 files changed, 743 insertions, 701 deletions

diff --git a/src/kernel/fs/ata_pio.c b/src/kernel/fs/ata_pio.c
index ef9a23e..1786e66 100644
--- a/src/kernel/fs/ata_pio.c
+++ b/src/kernel/fs/ata_pio.c
@@ -4,122 +4,139 @@
 
 struct ata_interface *new_ata(uint8_t master, uint16_t port_base)
 {
-    struct ata_interface *ret = (struct ata_interface *) kmalloc(sizeof(struct ata_interface));
-
-    ret->master = master;
-    ret->data_port = port_base;
-    ret->error_port = (uint16_t) (port_base + 0x1);
-    ret->sector_count_port = (uint16_t) (port_base + 0x2);
-    ret->lba_low_port = (uint16_t) (port_base + 0x3);
-    ret->lba_mid_port = (uint16_t) (port_base + 0x4);
-    ret->lba_high_port = (uint16_t) (port_base + 0x5);
-    ret->device_port = (uint16_t) (port_base + 0x6);
-    ret->command_port = (uint16_t) (port_base + 0x7);
-    ret->control_port = (uint16_t) (port_base + 0x206);
-
-    return ret;
+	struct ata_interface *ret = (struct ata_interface *)kmalloc(sizeof(struct ata_interface));
+
+	ret->master = master;
+	ret->data_port = port_base;
+	ret->error_port = (uint16_t)(port_base + 0x1);
+	ret->sector_count_port = (uint16_t)(port_base + 0x2);
+	ret->lba_low_port = (uint16_t)(port_base + 0x3);
+	ret->lba_mid_port = (uint16_t)(port_base + 0x4);
+	ret->lba_high_port = (uint16_t)(port_base + 0x5);
+	ret->device_port = (uint16_t)(port_base + 0x6);
+	ret->command_port = (uint16_t)(port_base + 0x7);
+	ret->control_port = (uint16_t)(port_base + 0x206);
+
+	return ret;
 }
 
 uint8_t ata_identify(struct ata_interface *interface, uint16_t *ret_data)
 {
-    outb(interface->device_port, (uint8_t) (interface->master ? 0xA0 : 0xB0));
-    outb(interface->control_port, 0);
-
-    outb(interface->device_port, 0xA0);
-    uint8_t status = inb(interface->command_port);
-    if (status == 0xFF) return 1;
-
-    outb(interface->device_port, (uint8_t) (interface->master ? 0xA0 : 0xB0));
-    outb(interface->sector_count_port, 0);
-    outb(interface->lba_low_port, 0);
-    outb(interface->lba_mid_port, 0);
-    outb(interface->lba_high_port, 0);
-    outb(interface->command_port, 0xEC); // Identify command
-
-    status = inb(interface->command_port);
-    if (!status) return 1;
-
-    while (((status & 0x80) == 0x80) && ((status & 0x01) != 0x01)) {
-        status = inb(interface->command_port);
-    }
-
-    if (status & 0x01) return 1;
-
-    for (int i = 0; i < 256; i++) ret_data[i] = inw(interface->data_port);
-    return 0;
+	outb(interface->device_port, (uint8_t)(interface->master ? 0xA0 : 0xB0));
+	outb(interface->control_port, 0);
+
+	outb(interface->device_port, 0xA0);
+	uint8_t status = inb(interface->command_port);
+	if (status == 0xFF)
+		return 1;
+
+	outb(interface->device_port, (uint8_t)(interface->master ? 0xA0 : 0xB0));
+	outb(interface->sector_count_port, 0);
+	outb(interface->lba_low_port, 0);
+	outb(interface->lba_mid_port, 0);
+	outb(interface->lba_high_port, 0);
+	outb(interface->command_port, 0xEC); // Identify command
+
+	status = inb(interface->command_port);
+	if (!status)
+		return 1;
+
+	while (((status & 0x80) == 0x80) && ((status & 0x01) != 0x01)) {
+		status = inb(interface->command_port);
+	}
+
+	if (status & 0x01)
+		return 1;
+
+	for (int i = 0; i < 256; i++)
+		ret_data[i] = inw(interface->data_port);
+	return 0;
 }
 
 uint8_t *ata_read28(struct ata_interface *interface, uint32_t sector)
 {
-    if (sector > 0x0FFFFFFF) return 0;
-
-    outb(interface->device_port, (uint8_t) ((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24)));
-
-    uint8_t status = 0;
-    for (int i = 0; i < 5; i++) status = inb(interface->command_port);
-    if (status == 0xFF) return 0;
-
-    outb(interface->error_port, 0);
-    outb(interface->sector_count_port, 1);
-    outb(interface->lba_low_port, (uint8_t) (sector & 0x000000FF));
-    outb(interface->lba_mid_port, (uint8_t) ((sector & 0x0000FF00) >> 8));
-    outb(interface->lba_high_port, (uint8_t) ((sector & 0x00FF0000) >> 16));
-    outb(interface->command_port, 0x20); // Read command
-
-    status = inb(interface->command_port);
-    while ((status & 0x80) && !(status & 0x01)) status = inb(interface->command_port);
-
-    uint8_t *ret = (uint8_t *) kmalloc(BYTES_PER_SECTOR);
-    for (int i = 0; i < BYTES_PER_SECTOR; i += 2) {
-        uint16_t data = inw(interface->data_port);
-        ret[i] = (uint8_t) (data & 0xFF);
-        ret[i + 1] = (uint8_t) ((data >> 8) & 0xFF);
-    }
-    return ret;
+	if (sector > 0x0FFFFFFF)
+		return 0;
+
+	outb(interface->device_port,
+	     (uint8_t)((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24)));
+
+	uint8_t status = 0;
+	for (int i = 0; i < 5; i++)
+		status = inb(interface->command_port);
+	if (status == 0xFF)
+		return 0;
+
+	outb(interface->error_port, 0);
+	outb(interface->sector_count_port, 1);
+	outb(interface->lba_low_port, (uint8_t)(sector & 0x000000FF));
+	outb(interface->lba_mid_port, (uint8_t)((sector & 0x0000FF00) >> 8));
+	outb(interface->lba_high_port, (uint8_t)((sector & 0x00FF0000) >> 16));
+	outb(interface->command_port, 0x20); // Read command
+
+	status = inb(interface->command_port);
+	while ((status & 0x80) && !(status & 0x01))
+		status = inb(interface->command_port);
+
+	uint8_t *ret = (uint8_t *)kmalloc(BYTES_PER_SECTOR);
+	for (int i = 0; i < BYTES_PER_SECTOR; i += 2) {
+		uint16_t data = inw(interface->data_port);
+		ret[i] = (uint8_t)(data & 0xFF);
+		ret[i + 1] = (uint8_t)((data >> 8) & 0xFF);
+	}
+	return ret;
 }
 
 uint8_t ata_write28(struct ata_interface *interface, uint32_t sector, const uint8_t *contents)
 {
-    if (sector > 0x0FFFFFFF) return 1;
-    cli();
-
-    outb(interface->device_port, (uint8_t) ((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24)));
-
-    uint8_t status = 0;
-    for (int i = 0; i < 5; i++) status = inb(interface->command_port);
-    if (status == 0xFF) return 1;
-
-    outb(interface->error_port, 0);
-    outb(interface->sector_count_port, 1);
-    outb(interface->lba_low_port, (uint8_t) (sector & 0x000000FF));
-    outb(interface->lba_mid_port, (uint8_t) ((sector & 0x0000FF00) >> 8));
-    outb(interface->lba_high_port, (uint8_t) ((sector & 0x00FF0000) >> 16));
-    outb(interface->command_port, 0x30); // Write command
-
-    while ((status & 0x80) || !(status & 0x08)) status = inb(interface->command_port);
-
-    if (status & (0x01 || 0x20)) return 2;
-
-    for (int i = 0; i < BYTES_PER_SECTOR; i += 2) {
-        uint16_t data = contents[i];
-        data |= ((uint16_t) contents[i + 1]) << 8;
-        outw(interface->data_port, data);
-    }
-
-    outb(interface->command_port, 0xE7); // Flush command
-
-    for (int i = 0; i < 5; i++) status = inb(interface->command_port);
-    if (!status) return 3;
-
-    while ((status & 0x80) && !(status & 0x01)) {
-        status = inb(interface->command_port);
-    }
-
-    return 0;
+	if (sector > 0x0FFFFFFF)
+		return 1;
+	cli();
+
+	outb(interface->device_port,
+	     (uint8_t)((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24)));
+
+	uint8_t status = 0;
+	for (int i = 0; i < 5; i++)
+		status = inb(interface->command_port);
+	if (status == 0xFF)
+		return 1;
+
+	outb(interface->error_port, 0);
+	outb(interface->sector_count_port, 1);
+	outb(interface->lba_low_port, (uint8_t)(sector & 0x000000FF));
+	outb(interface->lba_mid_port, (uint8_t)((sector & 0x0000FF00) >> 8));
+	outb(interface->lba_high_port, (uint8_t)((sector & 0x00FF0000) >> 16));
+	outb(interface->command_port, 0x30); // Write command
+
+	while ((status & 0x80) || !(status & 0x08))
+		status = inb(interface->command_port);
+
+	if (status & (0x01 || 0x20))
+		return 2;
+
+	for (int i = 0; i < BYTES_PER_SECTOR; i += 2) {
+		uint16_t data = contents[i];
+		data |= ((uint16_t)contents[i + 1]) << 8;
+		outw(interface->data_port, data);
+	}
+
+	outb(interface->command_port, 0xE7); // Flush command
+
+	for (int i = 0; i < 5; i++)
+		status = inb(interface->command_port);
+	if (!status)
+		return 3;
+
+	while ((status & 0x80) && !(status & 0x01)) {
+		status = inb(interface->command_port);
+	}
+
+	return 0;
 }
 
 uint8_t ata_clear28(struct ata_interface *interface, uint32_t sector)
 {
-    uint8_t empty_sector[512] = {0};
-    return ata_write28(interface, sector, empty_sector);
+	uint8_t empty_sector[512] = { 0 };
+	return ata_write28(interface, sector, empty_sector);
 }
diff --git a/src/kernel/fs/ata_pio.h b/src/kernel/fs/ata_pio.h
index fa08a0c..bb62805 100644
--- a/src/kernel/fs/ata_pio.h
+++ b/src/kernel/fs/ata_pio.h
@@ -6,16 +6,16 @@
 #define BYTES_PER_SECTOR 512
 
 struct ata_interface {
-    uint8_t master;
-    uint16_t data_port;
-    uint16_t error_port;
-    uint16_t sector_count_port;
-    uint16_t lba_low_port;
-    uint16_t lba_mid_port;
-    uint16_t lba_high_port;
-    uint16_t device_port;
-    uint16_t command_port;
-    uint16_t control_port;
+	uint8_t master;
+	uint16_t data_port;
+	uint16_t error_port;
+	uint16_t sector_count_port;
+	uint16_t lba_low_port;
+	uint16_t lba_mid_port;
+	uint16_t lba_high_port;
+	uint16_t device_port;
+	uint16_t command_port;
+	uint16_t control_port;
 };
 
 struct ata_interface *new_ata(uint8_t master, uint16_t port_base);
diff --git a/src/kernel/fs/atapi_pio.c b/src/kernel/fs/atapi_pio.c
index 39f32b6..6f0e3a6 100644
--- a/src/kernel/fs/atapi_pio.c
+++ b/src/kernel/fs/atapi_pio.c
@@ -4,29 +4,29 @@
 
 void ATAPI_read(uint16_t nblocks, uint32_t lba)
 {
-    struct dapack *d = (struct dapack *) ATAPI_PIO_DAPACK;
-    d->size = 0x10;
-    d->null = 0x00;
-    d->blk_count = nblocks;
-    d->b_offset = ATAPI_PIO_BUFFER;
-    d->b_segment = 0x0000;
-    d->start = lba;
-    d->upper_lba_bits = 0x00000000;
+	struct dapack *d = (struct dapack *)ATAPI_PIO_DAPACK;
+	d->size = 0x10;
+	d->null = 0x00;
+	d->blk_count = nblocks;
+	d->b_offset = ATAPI_PIO_BUFFER;
+	d->b_segment = 0x0000;
+	d->start = lba;
+	d->upper_lba_bits = 0x00000000;
 
-    regs16_t regs;
-    regs.ax = 0x4200;
-    regs.dx = ATAPI_PIO_DRIVE;
-    regs.ds = 0;
-    regs.si = ATAPI_PIO_DAPACK;
+	regs16_t regs;
+	regs.ax = 0x4200;
+	regs.dx = ATAPI_PIO_DRIVE;
+	regs.ds = 0;
+	regs.si = ATAPI_PIO_DAPACK;
 
-    v86(LBA_READ_INT, &regs);
+	v86(LBA_READ_INT, &regs);
 }
 
 void ATAPI_granular_read(uint32_t nblocks, uint32_t lba, uint8_t *output)
 {
-    for (uint32_t i = 0; i < nblocks; i++) {
-        ATAPI_read(1, lba + i);
-        for (uint16_t j = 0; j < ATAPI_SECTOR_SIZE; j++)
-            output[j + (2048 * i)] = ((uint8_t *) ATAPI_PIO_BUFFER)[j];
-    }
+	for (uint32_t i = 0; i < nblocks; i++) {
+		ATAPI_read(1, lba + i);
+		for (uint16_t j = 0; j < ATAPI_SECTOR_SIZE; j++)
+			output[j + (2048 * i)] = ((uint8_t *)ATAPI_PIO_BUFFER)[j];
+	}
 }
\ No newline at end of file
diff --git a/src/kernel/fs/atapi_pio.h b/src/kernel/fs/atapi_pio.h
index 20bef43..b7ddee8 100644
--- a/src/kernel/fs/atapi_pio.h
+++ b/src/kernel/fs/atapi_pio.h
@@ -10,13 +10,13 @@
 #define ATAPI_SECTOR_SIZE 2048
 
 struct dapack {
-    uint8_t size;
-    uint8_t null;
-    uint16_t blk_count;
-    uint16_t b_offset;
-    uint16_t b_segment;
-    uint32_t start;
-    uint32_t upper_lba_bits;
+	uint8_t size;
+	uint8_t null;
+	uint16_t blk_count;
+	uint16_t b_offset;
+	uint16_t b_segment;
+	uint32_t start;
+	uint32_t upper_lba_bits;
 } __attribute__((packed));
 
 void ATAPI_read(uint16_t nblocks, uint32_t lba);
diff --git a/src/kernel/fs/elf.h b/src/kernel/fs/elf.h
index 9be6b4d..5a412fb 100644
--- a/src/kernel/fs/elf.h
+++ b/src/kernel/fs/elf.h
@@ -4,48 +4,48 @@
 #include <stdint.h>
 
 typedef struct {
-    uint32_t sig;
+	uint32_t sig;
 } elf_priv_data;
 
 typedef struct {
-    unsigned char e_ident[16];
-    uint16_t e_type;
-    uint16_t e_machine;
-    uint32_t e_version;
-    uint32_t e_entry;
-    uint32_t e_phoff;
-    uint32_t e_shoff;
-    uint32_t e_flags;
-    uint16_t e_ehsize;
-    uint16_t e_phentsize;
-    uint16_t e_phnum;
-    uint16_t e_shentsize;
-    uint16_t e_shnum;
-    uint16_t e_shstrndx;
+	unsigned char e_ident[16];
+	uint16_t e_type;
+	uint16_t e_machine;
+	uint32_t e_version;
+	uint32_t e_entry;
+	uint32_t e_phoff;
+	uint32_t e_shoff;
+	uint32_t e_flags;
+	uint16_t e_ehsize;
+	uint16_t e_phentsize;
+	uint16_t e_phnum;
+	uint16_t e_shentsize;
+	uint16_t e_shnum;
+	uint16_t e_shstrndx;
 } elf_header_t;
 
 typedef struct {
-    uint32_t sh_name;
-    uint32_t sh_type;
-    uint32_t sh_flags;
-    uint32_t sh_addr;
-    uint32_t sh_offset;
-    uint32_t sh_size;
-    uint32_t sh_link;
-    uint32_t sh_info;
-    uint32_t sh_addralign;
-    uint32_t sh_entsize;
+	uint32_t sh_name;
+	uint32_t sh_type;
+	uint32_t sh_flags;
+	uint32_t sh_addr;
+	uint32_t sh_offset;
+	uint32_t sh_size;
+	uint32_t sh_link;
+	uint32_t sh_info;
+	uint32_t sh_addralign;
+	uint32_t sh_entsize;
 } elf_section_header_t;
 
 typedef struct {
-    uint32_t p_type;
-    uint32_t p_offset;
-    uint32_t p_vaddr;
-    uint32_t p_paddr;
-    uint32_t p_filesz;
-    uint32_t p_memsz;
-    uint32_t p_flags;
-    uint32_t p_align;
+	uint32_t p_type;
+	uint32_t p_offset;
+	uint32_t p_vaddr;
+	uint32_t p_paddr;
+	uint32_t p_filesz;
+	uint32_t p_memsz;
+	uint32_t p_flags;
+	uint32_t p_align;
 } elf_program_header_t;
 
 void elf_init();
diff --git a/src/kernel/fs/elfloader.c b/src/kernel/fs/elfloader.c
index 5b81a5e..8b80553 100644
--- a/src/kernel/fs/elfloader.c
+++ b/src/kernel/fs/elfloader.c
@@ -7,58 +7,58 @@
 
 elf_priv_data *elf_probe(uint8_t *buf)
 {
-    elf_header_t *header = (elf_header_t *) buf;
-    /* The first four bytes are 0x7f and 'ELF' */
-    if (header->e_ident[0] == 0x7f &&
-        header->e_ident[1] == 'E' && header->e_ident[2] == 'L' && header->e_ident[3] == 'F') {
-        /* Valid ELF! */
-        serial_printf("Buffer is valid ELF file!");
-        return (void *) 1;
-    }
-    return 0;
+	elf_header_t *header = (elf_header_t *)buf;
+	/* The first four bytes are 0x7f and 'ELF' */
+	if (header->e_ident[0] == 0x7f && header->e_ident[1] == 'E' && header->e_ident[2] == 'L' &&
+	    header->e_ident[3] == 'F') {
+		/* Valid ELF! */
+		serial_printf("Buffer is valid ELF file!");
+		return (void *)1;
+	}
+	return 0;
 }
 
 uint8_t elf_start(uint8_t *buf)
 {
-    elf_header_t *header = (elf_header_t *) buf;
-    serial_printf("Type: %s%s%s",
-                  header->e_ident[4] == 1 ? "32bit " : "64 bit",
-                  header->e_ident[5] == 1 ? "Little Endian " : "Big endian ",
-                  header->e_ident[6] == 1 ? "True ELF " : "buggy ELF ");
-    if (header->e_type != 2) {
-        serial_printf("File is not executable!");
-        return 0;
-    }
-    /* Map the virtual space */
-    uint32_t phys_loc = loader_get_unused_load_location();
-    uint32_t cr3 = kmalloc(4096);
-    /* Find first program header and loop through them */
-    elf_program_header_t *ph = (elf_program_header_t *) (buf + header->e_phoff);
-    for (int i = 0; i < header->e_phnum; i++, ph++) {
-        switch (ph->p_type) {
-            case 0: /* NULL */
-                break;
-            case 1: /* LOAD */
-                serial_printf("LOAD: offset 0x%x vaddr 0x%x paddr 0x%x filesz 0x%x memsz 0x%x",
-                              ph->p_offset, ph->p_vaddr, ph->p_paddr, ph->p_filesz, ph->p_memsz);
-                paging_map(phys_loc, ph->p_vaddr, PT_PRESENT | PT_RW | PT_USED);
-                memcpy(ph->p_vaddr, buf + ph->p_offset, ph->p_filesz);
-                break;
-            default: /* @TODO add more */
-                serial_printf("Unsupported p_type! Bail out!");
-                return 0;
-        }
-    }
+	elf_header_t *header = (elf_header_t *)buf;
+	serial_printf("Type: %s%s%s", header->e_ident[4] == 1 ? "32bit " : "64 bit",
+		      header->e_ident[5] == 1 ? "Little Endian " : "Big endian ",
+		      header->e_ident[6] == 1 ? "True ELF " : "buggy ELF ");
+	if (header->e_type != 2) {
+		serial_printf("File is not executable!");
+		return 0;
+	}
+	/* Map the virtual space */
+	uint32_t phys_loc = loader_get_unused_load_location();
+	uint32_t cr3 = kmalloc(4096);
+	/* Find first program header and loop through them */
+	elf_program_header_t *ph = (elf_program_header_t *)(buf + header->e_phoff);
+	for (int i = 0; i < header->e_phnum; i++, ph++) {
+		switch (ph->p_type) {
+		case 0: /* NULL */
+			break;
+		case 1: /* LOAD */
+			serial_printf(
+				"LOAD: offset 0x%x vaddr 0x%x paddr 0x%x filesz 0x%x memsz 0x%x",
+				ph->p_offset, ph->p_vaddr, ph->p_paddr, ph->p_filesz, ph->p_memsz);
+			paging_map(phys_loc, ph->p_vaddr, PT_PRESENT | PT_RW | PT_USED);
+			memcpy(ph->p_vaddr, buf + ph->p_offset, ph->p_filesz);
+			break;
+		default: /* @TODO add more */
+			serial_printf("Unsupported p_type! Bail out!");
+			return 0;
+		}
+	}
 
-    return 0;//START("elf32", header->e_entry);
+	return 0; //START("elf32", header->e_entry);
 }
 
 void elf_init()
 {
-    loader_t *elfloader = (loader_t *) kmalloc(sizeof(loader_t));
-    elfloader->name = "ELF32";
-    elfloader->probe = (void *) elf_probe;
-    elfloader->start = (void *) elf_start;
-    register_loader(elfloader);
-    // _kill();
+	loader_t *elfloader = (loader_t *)kmalloc(sizeof(loader_t));
+	elfloader->name = "ELF32";
+	elfloader->probe = (void *)elf_probe;
+	elfloader->start = (void *)elf_start;
+	register_loader(elfloader);
+	// _kill();
 }
\ No newline at end of file
diff --git a/src/kernel/fs/install.c b/src/kernel/fs/install.c
index 0c3d824..b4f5275 100644
--- a/src/kernel/fs/install.c
+++ b/src/kernel/fs/install.c
@@ -12,83 +12,83 @@
 
 void install_melvix()
 {
-    info("You're booting from a CD, Melvix will only run after an installation");
-    cli();
-    struct ata_interface *primary_master = new_ata(1, 0x1F0);
-    if (marfs_init(primary_master) != 0) {
-        panic("No HDD found!");
-    }
+	info("You're booting from a CD, Melvix will only run after an installation");
+	cli();
+	struct ata_interface *primary_master = new_ata(1, 0x1F0);
+	if (marfs_init(primary_master) != 0) {
+		panic("No HDD found!");
+	}
 
-    struct marfs_superblock *currentSB = marfs_read_superblock();
-    if (currentSB->signature == 0x1083B99F34B59645) { // WEEEOOOWEEEOOO
-        panic("Melvix seems to be already installed!");
-    }
-    kfree(currentSB);
+	struct marfs_superblock *currentSB = marfs_read_superblock();
+	if (currentSB->signature == 0x1083B99F34B59645) { // WEEEOOOWEEEOOO
+		panic("Melvix seems to be already installed!");
+	}
+	kfree(currentSB);
 
-    info("Installing...\n");
+	info("Installing...\n");
 
-    // Copy MBR
-    info("Copying MBR... ");
-    serial_printf("Copying MBR... ");
-    char *stage1_p[] = {"BOOT", "HDD1.BIN"};
-    struct iso9660_entity *stage1_e = ISO9660_get(stage1_p, 2);
-    if (!stage1_e)
-        panic("Couldn't find the first HDD bootloader!");
-    uint8_t *stage1 = ISO9660_read(stage1_e);
-    kfree(stage1_e);
-    marfs_write_mbr(stage1);
+	// Copy MBR
+	info("Copying MBR... ");
+	serial_printf("Copying MBR... ");
+	char *stage1_p[] = { "BOOT", "HDD1.BIN" };
+	struct iso9660_entity *stage1_e = ISO9660_get(stage1_p, 2);
+	if (!stage1_e)
+		panic("Couldn't find the first HDD bootloader!");
+	uint8_t *stage1 = ISO9660_read(stage1_e);
+	kfree(stage1_e);
+	marfs_write_mbr(stage1);
 
-    // Format disk
-    info("Formatting disk...");
-    serial_printf("Formatting disk...");
-    marfs_format();
+	// Format disk
+	info("Formatting disk...");
+	serial_printf("Formatting disk...");
+	marfs_format();
 
-    // Copy second stage
-    info("Copying second stage...");
-    serial_printf("Copying second stage...");
-    char *stage2_p[] = {"BOOT", "HDD2.BIN"};
-    struct iso9660_entity *stage2_e = ISO9660_get(stage2_p, 2);
-    if (!stage2_e)
-        panic("Couldn't find the second HDD bootloader!");
-    uint8_t *stage2 = ISO9660_read(stage2_e);
-    marfs_new_file(stage2_e->length, stage2, 0, 0, 0);
-    kfree(stage2_e);
+	// Copy second stage
+	info("Copying second stage...");
+	serial_printf("Copying second stage...");
+	char *stage2_p[] = { "BOOT", "HDD2.BIN" };
+	struct iso9660_entity *stage2_e = ISO9660_get(stage2_p, 2);
+	if (!stage2_e)
+		panic("Couldn't find the second HDD bootloader!");
+	uint8_t *stage2 = ISO9660_read(stage2_e);
+	marfs_new_file(stage2_e->length, stage2, 0, 0, 0);
+	kfree(stage2_e);
 
-    // Copy the kernel
-    info("Copying the kernel...");
-    serial_printf("Copying the kernel...");
-    char *kernel_p[] = {"BOOT", "KERNEL.BIN"};
-    struct iso9660_entity *kernel_e = ISO9660_get(kernel_p, 2);
-    if (!kernel_e)
-        panic("WTH Kernel not found!?");
-    uint8_t *kernel = (uint8_t *) kmalloc(kernel_e->length + 2048);
-    ATAPI_granular_read(1 + (kernel_e->length / 2048), kernel_e->lba, kernel);
-    marfs_new_file(kernel_e->length, kernel, 0, 0, 0);
-    kfree(kernel);
-    kfree(kernel_e);
+	// Copy the kernel
+	info("Copying the kernel...");
+	serial_printf("Copying the kernel...");
+	char *kernel_p[] = { "BOOT", "KERNEL.BIN" };
+	struct iso9660_entity *kernel_e = ISO9660_get(kernel_p, 2);
+	if (!kernel_e)
+		panic("WTH Kernel not found!?");
+	uint8_t *kernel = (uint8_t *)kmalloc(kernel_e->length + 2048);
+	ATAPI_granular_read(1 + (kernel_e->length / 2048), kernel_e->lba, kernel);
+	marfs_new_file(kernel_e->length, kernel, 0, 0, 0);
+	kfree(kernel);
+	kfree(kernel_e);
 
-    // Copy the userspace binary
-    info("Copying userspace... ");
-    serial_printf("Copying userspace... ");
-    char *userspace_p[] = {"USER.BIN"};
-    struct iso9660_entity *userspace_e = ISO9660_get(userspace_p, 1);
-    if (!userspace_e)
-        panic("Userspace not found!");
-    uint8_t *userspace = ISO9660_read(userspace_e);
-    marfs_new_file(userspace_e->length, userspace, 0, 0, 0);
-    kfree(userspace_e);
+	// Copy the userspace binary
+	info("Copying userspace... ");
+	serial_printf("Copying userspace... ");
+	char *userspace_p[] = { "USER.BIN" };
+	struct iso9660_entity *userspace_e = ISO9660_get(userspace_p, 1);
+	if (!userspace_e)
+		panic("Userspace not found!");
+	uint8_t *userspace = ISO9660_read(userspace_e);
+	marfs_new_file(userspace_e->length, userspace, 0, 0, 0);
+	kfree(userspace_e);
 
-    // Copy the global font binary
-    info("Copying font... ");
-    serial_printf("Copying font... ");
-    char *font_p[] = {"FONT.BIN"};
-    struct iso9660_entity *font_e = ISO9660_get(font_p, 1);
-    marfs_new_file(font_e->length, (uint8_t *) font, 0, 0, 0);
-    kfree(font_e);
+	// Copy the global font binary
+	info("Copying font... ");
+	serial_printf("Copying font... ");
+	char *font_p[] = { "FONT.BIN" };
+	struct iso9660_entity *font_e = ISO9660_get(font_p, 1);
+	marfs_new_file(font_e->length, (uint8_t *)font, 0, 0, 0);
+	kfree(font_e);
 
-    info("Installation successful!");
-    serial_printf("Installation successful! (in %d ticks)", get_time());
-    // timer_wait(200);
-    acpi_poweroff();
-    halt_loop();
+	info("Installation successful!");
+	serial_printf("Installation successful! (in %d ticks)", get_time());
+	// timer_wait(200);
+	acpi_poweroff();
+	halt_loop();
 }
diff --git a/src/kernel/fs/iso9660/iso9660.c b/src/kernel/fs/iso9660/iso9660.c
index 81ef18a..ab00c31 100644
--- a/src/kernel/fs/iso9660/iso9660.c
+++ b/src/kernel/fs/iso9660/iso9660.c
@@ -6,57 +6,54 @@
 
 struct iso9660_entity *ISO9660_get(char **dirs, uint8_t dirs_sz)
 {
-    ATAPI_read(1, 0x10);
-    uint32_t last_len = *(uint32_t *) (
-            ATAPI_PIO_BUFFER +
-            ISO9660_ROOT_RECORD_OFFSET +
-            ISO9660_DIR_EAR_LENGTH
-    );
-    uint32_t last_lba = *(uint32_t *) (
-            ATAPI_PIO_BUFFER +
-            ISO9660_ROOT_RECORD_OFFSET +
-            ISO9660_DIR_EAR_LBA
-    );
-
-    for (uint8_t dirs_i = 0; dirs_i < dirs_sz; dirs_i++) {
-        ATAPI_read((last_len % 2048 != 0) + (last_len / 2048), last_lba);
-
-        uint8_t found = 0;
-        for (uint32_t i = 0; i < last_len && !found;) {
-            if (!*(uint8_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH))
-                break;
-
-            char *filename = (char *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_FILENAME);
-
-            for (uint32_t j = 0; j < ISO9660_DIR_FILENAME_LENGTH; j++) {
-                if (filename[j] == ';') {
-                    filename[j] = 0;
-                    break;
-                }
-            }
-
-            if (strcmp(dirs[dirs_i], filename) == 0) {
-                found = 1;
-                last_lba = *(uint32_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_EAR_LBA);
-                last_len = *(uint32_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_EAR_LENGTH);
-            } else {
-                i += *(uint8_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH);
-            }
-        }
-
-        if (!found) {
-            return (struct iso9660_entity *) 0;
-        }
-    }
-
-    struct iso9660_entity *ret = (struct iso9660_entity *) kmalloc(sizeof(struct iso9660_entity));
-    ret->lba = last_lba;
-    ret->length = last_len;
-    return ret;
+	ATAPI_read(1, 0x10);
+	uint32_t last_len = *(uint32_t *)(ATAPI_PIO_BUFFER + ISO9660_ROOT_RECORD_OFFSET +
+					  ISO9660_DIR_EAR_LENGTH);
+	uint32_t last_lba =
+		*(uint32_t *)(ATAPI_PIO_BUFFER + ISO9660_ROOT_RECORD_OFFSET + ISO9660_DIR_EAR_LBA);
+
+	for (uint8_t dirs_i = 0; dirs_i < dirs_sz; dirs_i++) {
+		ATAPI_read((last_len % 2048 != 0) + (last_len / 2048), last_lba);
+
+		uint8_t found = 0;
+		for (uint32_t i = 0; i < last_len && !found;) {
+			if (!*(uint8_t *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH))
+				break;
+
+			char *filename = (char *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_FILENAME);
+
+			for (uint32_t j = 0; j < ISO9660_DIR_FILENAME_LENGTH; j++) {
+				if (filename[j] == ';') {
+					filename[j] = 0;
+					break;
+				}
+			}
+
+			if (strcmp(dirs[dirs_i], filename) == 0) {
+				found = 1;
+				last_lba =
+					*(uint32_t *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_EAR_LBA);
+				last_len = *(uint32_t *)(ATAPI_PIO_BUFFER + i +
+							 ISO9660_DIR_EAR_LENGTH);
+			} else {
+				i += *(uint8_t *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH);
+			}
+		}
+
+		if (!found) {
+			return (struct iso9660_entity *)0;
+		}
+	}
+
+	struct iso9660_entity *ret =
+		(struct iso9660_entity *)kmalloc(sizeof(struct iso9660_entity));
+	ret->lba = last_lba;
+	ret->length = last_len;
+	return ret;
 }
 
 uint8_t *ISO9660_read(struct iso9660_entity *entity)
 {
-    ATAPI_read((entity->length % 2048 != 0) + (entity->length / 2048), entity->lba);
-    return (uint8_t *) ATAPI_PIO_BUFFER;
+	ATAPI_read((entity->length % 2048 != 0) + (entity->length / 2048), entity->lba);
+	return (uint8_t *)ATAPI_PIO_BUFFER;
 }
\ No newline at end of file
diff --git a/src/kernel/fs/iso9660/iso9660.h b/src/kernel/fs/iso9660/iso9660.h
index 86629e4..9ba9cfa 100644
--- a/src/kernel/fs/iso9660/iso9660.h
+++ b/src/kernel/fs/iso9660/iso9660.h
@@ -11,8 +11,8 @@
 #include <stdint.h>
 
 struct iso9660_entity {
-    uint32_t lba;
-    uint32_t length;
+	uint32_t lba;
+	uint32_t length;
 };
 
 struct iso9660_entity *ISO9660_get(char **dirs, uint8_t dirs_sz);
diff --git a/src/kernel/fs/load.c b/src/kernel/fs/load.c
index 5a476b5..7227f9b 100644
--- a/src/kernel/fs/load.c
+++ b/src/kernel/fs/load.c
@@ -10,29 +10,32 @@
 
 void load_binaries()
 {
-    userspace = (uint32_t) kmalloc(10000);
-    font = (struct font *) kmalloc(100000);; // High quality shit
+	userspace = (uint32_t)kmalloc(10000);
+	font = (struct font *)kmalloc(100000);
+	; // High quality shit
 
-    uint8_t boot_drive_id = (uint8_t) (*((uint8_t *) 0x9000));
-    if (boot_drive_id != 0xE0) {
-        struct ata_interface *primary_master = new_ata(1, 0x1F0);
-        marfs_init(primary_master);
-        marfs_read_whole_file(4, (uint8_t *) userspace);
-        marfs_read_whole_file(5, (uint8_t *) font);
-    } else {
-        char *font_p[] = {"FONT.BIN"};
-        struct iso9660_entity *font_e = ISO9660_get(font_p, 1);
-        if (!font_e) panic("Font not found!");
-        ATAPI_granular_read(1 + (font_e->length / 2048), font_e->lba, (uint8_t *) font);
-        kfree(font_e);
+	uint8_t boot_drive_id = (uint8_t)(*((uint8_t *)0x9000));
+	if (boot_drive_id != 0xE0) {
+		struct ata_interface *primary_master = new_ata(1, 0x1F0);
+		marfs_init(primary_master);
+		marfs_read_whole_file(4, (uint8_t *)userspace);
+		marfs_read_whole_file(5, (uint8_t *)font);
+	} else {
+		char *font_p[] = { "FONT.BIN" };
+		struct iso9660_entity *font_e = ISO9660_get(font_p, 1);
+		if (!font_e)
+			panic("Font not found!");
+		ATAPI_granular_read(1 + (font_e->length / 2048), font_e->lba, (uint8_t *)font);
+		kfree(font_e);
 
-        char *user_p[] = {"USER.BIN"};
-        struct iso9660_entity *user_e = ISO9660_get(user_p, 1);
-        if (!user_e) panic("Userspace binary not found!");
-        ATAPI_granular_read(1 + (user_e->length / 2048), user_e->lba, (uint8_t *) userspace);
-        kfree(user_e);
-    }
-    vga_log("Successfully loaded binaries");
+		char *user_p[] = { "USER.BIN" };
+		struct iso9660_entity *user_e = ISO9660_get(user_p, 1);
+		if (!user_e)
+			panic("Userspace binary not found!");
+		ATAPI_granular_read(1 + (user_e->length / 2048), user_e->lba, (uint8_t *)userspace);
+		kfree(user_e);
+	}
+	vga_log("Successfully loaded binaries");
 }
 
 #define MAX_LOADERS 16
@@ -44,35 +47,38 @@ uint32_t last_load_loc = 0x400000;
 
 void loader_init()
 {
-    serial_printf("Setting up loader");
-    loaders = (loader_t **) kmalloc(MAX_LOADERS * sizeof(uint32_t));
-    memset(loaders, 0, MAX_LOADERS * sizeof(uint32_t));
-    // _kill();
+	serial_printf("Setting up loader");
+	loaders = (loader_t **)kmalloc(MAX_LOADERS * sizeof(uint32_t));
+	memset(loaders, 0, MAX_LOADERS * sizeof(uint32_t));
+	// _kill();
 }
 
 void register_loader(loader_t *load)
 {
-    if (last_loader + 1 > MAX_LOADERS) return;
-    if (!load) return;
-    loaders[last_loader] = load;
-    last_loader++;
-    serial_printf("Registered %s loader as id %d", load->name, last_loader - 1);
+	if (last_loader + 1 > MAX_LOADERS)
+		return;
+	if (!load)
+		return;
+	loaders[last_loader] = load;
+	last_loader++;
+	serial_printf("Registered %s loader as id %d", load->name, last_loader - 1);
 }
 
 uint32_t loader_get_unused_load_location()
 {
-    last_load_loc += 0x400000;
-    return last_load_loc;
+	last_load_loc += 0x400000;
+	return last_load_loc;
 }
 
 uint8_t exec_start(uint8_t *buf)
 {
-    for (int i = 0; i < MAX_LOADERS; i++) {
-        if (!loaders[i]) break;
-        void *priv = loaders[i]->probe(buf);
-        if (priv) {
-            return loaders[i]->start(buf, priv);
-        }
-    }
-    return 0;
+	for (int i = 0; i < MAX_LOADERS; i++) {
+		if (!loaders[i])
+			break;
+		void *priv = loaders[i]->probe(buf);
+		if (priv) {
+			return loaders[i]->start(buf, priv);
+		}
+	}
+	return 0;
 }
\ No newline at end of file
diff --git a/src/kernel/fs/load.h b/src/kernel/fs/load.h
index 4ba545f..468501c 100644
--- a/src/kernel/fs/load.h
+++ b/src/kernel/fs/load.h
@@ -8,20 +8,20 @@ uint32_t userspace;
 struct font *font;
 
 struct font {
-    uint16_t font_32[758][32];
-    uint16_t font_24[758][24];
-    uint8_t font_16[758][16];
-    uint16_t cursor[19];
+	uint16_t font_32[758][32];
+	uint16_t font_24[758][24];
+	uint8_t font_16[758][16];
+	uint16_t cursor[19];
 };
 
 void load_binaries();
 
 typedef struct {
-    char *name;
+	char *name;
 
-    void *(*probe)(uint8_t *buf);
+	void *(*probe)(uint8_t *buf);
 
-    uint8_t (*start)(uint8_t *buf, void *priv);
+	uint8_t (*start)(uint8_t *buf, void *priv);
 } loader_t;
 
 void loader_init();
diff --git a/src/kernel/fs/marfs/directory.c b/src/kernel/fs/marfs/directory.c
index fd8ecd6..f4a5b04 100644
--- a/src/kernel/fs/marfs/directory.c
+++ b/src/kernel/fs/marfs/directory.c
@@ -6,54 +6,58 @@
 
 uint32_t marfs_new_dir(uint32_t uid)
 {
-    return marfs_new_file(0, 0, uid, 0, 1);
+	return marfs_new_file(0, 0, uid, 0, 1);
 }
 
-
 void marfs_add_to_dir(uint32_t lba_inode, char *filename, uint32_t lba)
 {
-    struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_inode);
-
-    // Read the content
-    uint8_t *old = marfs_allocate_and_read_whole_file(lba_inode);
-
-    // Allocate memory
-    uint8_t *contents = (uint8_t *) kmalloc((uint32_t) (inode->size + strlen(filename) + 1 + 4));
-
-    // Copy the content
-    uint8_t last_was_null = 0;
-    uint64_t new_size = 0;
-    for (uint64_t i = 0; i < inode->size; i++) {
-        if (old[i] == 0 && last_was_null) continue;
-
-        contents[new_size++] = old[i];
-        last_was_null = (uint8_t) (old[i] == 0);
-    }
-    kfree(old);
-
-    // Append new file
-    for (size_t i = 0; i <= strlen(filename); i++) contents[new_size++] = (uint8_t) filename[i];
-    for (signed char j = 24; j > 0; j -= 8) contents[new_size++] = (uint8_t) ((lba >> j) & 0xFF);
-
-    // Free the blocks
-    uint32_t new_size_in_blocks = (uint32_t) (new_size / 512);
-    if (new_size % 512) new_size_in_blocks++;
-    for (uint32_t i = 0; i < new_size_in_blocks; i++)
-        marfs_mark_block_as_free(marfs_get_block(inode, i));
-
-    // Overwrite
-    uint32_t aux_inode = marfs_new_file(new_size, contents, 0xDEADBEEF, 0, 0);
-    struct marfs_inode *real_aux_inode = (struct marfs_inode *) ata_read28(interface, aux_inode);
-    for (uint8_t i = 0; i < 10; i++) inode->DBPs[i] = real_aux_inode->DBPs[i];
-    inode->ext_1 = real_aux_inode->ext_1;
-    inode->ext_2 = real_aux_inode->ext_2;
-    inode->ext_3 = real_aux_inode->ext_3;
-    inode->ext_4 = real_aux_inode->ext_4;
-    real_aux_inode->is_used = 0;
-    ata_write28(interface, aux_inode, (uint8_t *) real_aux_inode);
-    kfree(real_aux_inode);
-
-    inode->size = new_size;
-    ata_write28(interface, lba_inode, (uint8_t *) inode);
-    kfree(inode);
+	struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_inode);
+
+	// Read the content
+	uint8_t *old = marfs_allocate_and_read_whole_file(lba_inode);
+
+	// Allocate memory
+	uint8_t *contents = (uint8_t *)kmalloc((uint32_t)(inode->size + strlen(filename) + 1 + 4));
+
+	// Copy the content
+	uint8_t last_was_null = 0;
+	uint64_t new_size = 0;
+	for (uint64_t i = 0; i < inode->size; i++) {
+		if (old[i] == 0 && last_was_null)
+			continue;
+
+		contents[new_size++] = old[i];
+		last_was_null = (uint8_t)(old[i] == 0);
+	}
+	kfree(old);
+
+	// Append new file
+	for (size_t i = 0; i <= strlen(filename); i++)
+		contents[new_size++] = (uint8_t)filename[i];
+	for (signed char j = 24; j > 0; j -= 8)
+		contents[new_size++] = (uint8_t)((lba >> j) & 0xFF);
+
+	// Free the blocks
+	uint32_t new_size_in_blocks = (uint32_t)(new_size / 512);
+	if (new_size % 512)
+		new_size_in_blocks++;
+	for (uint32_t i = 0; i < new_size_in_blocks; i++)
+		marfs_mark_block_as_free(marfs_get_block(inode, i));
+
+	// Overwrite
+	uint32_t aux_inode = marfs_new_file(new_size, contents, 0xDEADBEEF, 0, 0);
+	struct marfs_inode *real_aux_inode = (struct marfs_inode *)ata_read28(interface, aux_inode);
+	for (uint8_t i = 0; i < 10; i++)
+		inode->DBPs[i] = real_aux_inode->DBPs[i];
+	inode->ext_1 = real_aux_inode->ext_1;
+	inode->ext_2 = real_aux_inode->ext_2;
+	inode->ext_3 = real_aux_inode->ext_3;
+	inode->ext_4 = real_aux_inode->ext_4;
+	real_aux_inode->is_used = 0;
+	ata_write28(interface, aux_inode, (uint8_t *)real_aux_inode);
+	kfree(real_aux_inode);
+
+	inode->size = new_size;
+	ata_write28(interface, lba_inode, (uint8_t *)inode);
+	kfree(inode);
 }
diff --git a/src/kernel/fs/marfs/disklevel.c b/src/kernel/fs/marfs/disklevel.c
index 106540e..f814f80 100644
--- a/src/kernel/fs/marfs/disklevel.c
+++ b/src/kernel/fs/marfs/disklevel.c
@@ -4,21 +4,23 @@
 
 void marfs_format(void)
 {
-    // Create superblock
-    struct marfs_superblock sb;
-    sb.signature = 0x1083B99F34B59645; // Huh, magic?!
-    sb.n_inodes = (marfs_get_max_lba() - 2) >> 5;
-    sb.n_chunks = (marfs_get_max_lba() - (2 + sb.n_inodes)) >> 9;
-    sb.n_first_unallocated_inode = 0;
-    sb.s_first_inode = 2;
-    sb.s_first_chunk = 2 + sb.n_inodes;
+	// Create superblock
+	struct marfs_superblock sb;
+	sb.signature = 0x1083B99F34B59645; // Huh, magic?!
+	sb.n_inodes = (marfs_get_max_lba() - 2) >> 5;
+	sb.n_chunks = (marfs_get_max_lba() - (2 + sb.n_inodes)) >> 9;
+	sb.n_first_unallocated_inode = 0;
+	sb.s_first_inode = 2;
+	sb.s_first_chunk = 2 + sb.n_inodes;
 
-    // Write to disk
-    marfs_write_superblock(&sb);
+	// Write to disk
+	marfs_write_superblock(&sb);
 
-    // Initialize the inodes
-    for (uint32_t i = 0; i < sb.n_inodes; i++) ata_clear28(interface, 2 + i);
+	// Initialize the inodes
+	for (uint32_t i = 0; i < sb.n_inodes; i++)
+		ata_clear28(interface, 2 + i);
 
-    // Initialize the chunks
-    for (uint32_t i = 0; i < sb.n_chunks; i++) ata_clear28(interface, sb.s_first_chunk + i * 512);
+	// Initialize the chunks
+	for (uint32_t i = 0; i < sb.n_chunks; i++)
+		ata_clear28(interface, sb.s_first_chunk + i * 512);
 }
diff --git a/src/kernel/fs/marfs/marfs.h b/src/kernel/fs/marfs/marfs.h
index 67b693c..f2dfa1c 100644
--- a/src/kernel/fs/marfs/marfs.h
+++ b/src/kernel/fs/marfs/marfs.h
@@ -4,29 +4,29 @@
 #include <stdint.h>
 
 struct marfs_superblock {
-    uint64_t signature;
-    uint32_t n_inodes;
-    uint32_t n_chunks;
-    uint32_t n_first_unallocated_inode;
-    uint32_t s_first_inode;
-    uint32_t s_first_chunk;
+	uint64_t signature;
+	uint32_t n_inodes;
+	uint32_t n_chunks;
+	uint32_t n_first_unallocated_inode;
+	uint32_t s_first_inode;
+	uint32_t s_first_chunk;
 } __attribute__((packed));
 
 struct marfs_inode {
-    uint64_t size;
-    uint32_t creation_time;
-    uint32_t last_mod_time;
-    uint32_t last_access_time;
-    uint32_t n_blocks;
-    uint32_t DBPs[10];
-    uint32_t ext_1;
-    uint32_t ext_2;
-    uint32_t ext_3;
-    uint32_t ext_4;
-    uint32_t uid;
-    uint8_t is_app;
-    uint8_t is_dir;
-    uint8_t is_used;
+	uint64_t size;
+	uint32_t creation_time;
+	uint32_t last_mod_time;
+	uint32_t last_access_time;
+	uint32_t n_blocks;
+	uint32_t DBPs[10];
+	uint32_t ext_1;
+	uint32_t ext_2;
+	uint32_t ext_3;
+	uint32_t ext_4;
+	uint32_t uid;
+	uint8_t is_app;
+	uint8_t is_dir;
+	uint8_t is_used;
 } __attribute__((packed));
 
 struct ata_interface *interface;
diff --git a/src/kernel/fs/marfs/new_file.c b/src/kernel/fs/marfs/new_file.c
index 8f85ffa..d278ad2 100644
--- a/src/kernel/fs/marfs/new_file.c
+++ b/src/kernel/fs/marfs/new_file.c
@@ -7,98 +7,105 @@ static uint8_t last_max_level = 0;
 
 void marfs_update_recursive(uint8_t level, uint32_t i, uint32_t rec_lba, uint32_t real_lba)
 {
-    if (level > last_max_level) last_max_level = level;
-    uint32_t *contents = (uint32_t *) ata_read28(interface, rec_lba);
+	if (level > last_max_level)
+		last_max_level = level;
+	uint32_t *contents = (uint32_t *)ata_read28(interface, rec_lba);
 
-    uint32_t idx = i - 10;
-    if (last_max_level > 1) idx -= 1 << 7;
-    if (last_max_level > 2) idx -= 1 << (7 * 2);
-    if (last_max_level > 3) idx -= 1 << (7 * 3);
-    idx >>= 7 * (level - 1);
+	uint32_t idx = i - 10;
+	if (last_max_level > 1)
+		idx -= 1 << 7;
+	if (last_max_level > 2)
+		idx -= 1 << (7 * 2);
+	if (last_max_level > 3)
+		idx -= 1 << (7 * 3);
+	idx >>= 7 * (level - 1);
 
-    if (level > 1) {
-        if (!contents[idx]) {
-            contents[idx] = marfs_get_free_lba_block();
-            marfs_mark_block_as_used(contents[idx]);
-        }
-    } else {
-        contents[idx] = real_lba;
-    }
+	if (level > 1) {
+		if (!contents[idx]) {
+			contents[idx] = marfs_get_free_lba_block();
+			marfs_mark_block_as_used(contents[idx]);
+		}
+	} else {
+		contents[idx] = real_lba;
+	}
 
-    ata_write28(interface, rec_lba, (uint8_t *) contents);
+	ata_write28(interface, rec_lba, (uint8_t *)contents);
 
-    uint32_t contents_idx = contents[idx];
-    kfree(contents);
-    if (level != 1) {
-        marfs_update_recursive((uint8_t) (level - 1), i, contents_idx, real_lba);
-    }
-    last_max_level = 0;
+	uint32_t contents_idx = contents[idx];
+	kfree(contents);
+	if (level != 1) {
+		marfs_update_recursive((uint8_t)(level - 1), i, contents_idx, real_lba);
+	}
+	last_max_level = 0;
 }
 
 uint32_t marfs_new_file(uint64_t size, uint8_t *data, uint32_t uid, uint8_t exec, uint8_t dir)
 {
-    struct marfs_inode *inode = (struct marfs_inode *) kmalloc(512);
-    inode->size = size;
-    inode->creation_time = inode->last_mod_time = inode->last_access_time = 0; // TODO: POSIX time
-    inode->n_blocks = (uint32_t) (size / 512);
-    if (size % 512) inode->n_blocks++;
-    inode->uid = uid;
-    inode->is_app = exec;
-    inode->is_dir = dir;
-    inode->is_used = 1;
+	struct marfs_inode *inode = (struct marfs_inode *)kmalloc(512);
+	inode->size = size;
+	inode->creation_time = inode->last_mod_time = inode->last_access_time =
+		0; // TODO: POSIX time
+	inode->n_blocks = (uint32_t)(size / 512);
+	if (size % 512)
+		inode->n_blocks++;
+	inode->uid = uid;
+	inode->is_app = exec;
+	inode->is_dir = dir;
+	inode->is_used = 1;
 
-    uint32_t size_in_blocks = inode->n_blocks;
+	uint32_t size_in_blocks = inode->n_blocks;
 
-    uint32_t lba_singly, lba_doubly, lba_triply, lba_quadruply;
-    lba_singly = lba_doubly = lba_triply = lba_quadruply = 0;
-    for (uint32_t i = 0; i < size_in_blocks; i++) {
-        uint32_t this_block = marfs_get_free_lba_block();
-        if (i != size_in_blocks - 1) {
-            ata_write28(interface, this_block, data);
-        } else if (size % 512) {
-            uint8_t contents[512] = {0};
-            for (uint16_t i = 0; i < size % 512; i++) contents[i] = data[i];
-            ata_write28(interface, this_block, contents);
-        }
-        data += 512;
-        marfs_mark_block_as_used(this_block);
+	uint32_t lba_singly, lba_doubly, lba_triply, lba_quadruply;
+	lba_singly = lba_doubly = lba_triply = lba_quadruply = 0;
+	for (uint32_t i = 0; i < size_in_blocks; i++) {
+		uint32_t this_block = marfs_get_free_lba_block();
+		if (i != size_in_blocks - 1) {
+			ata_write28(interface, this_block, data);
+		} else if (size % 512) {
+			uint8_t contents[512] = { 0 };
+			for (uint16_t i = 0; i < size % 512; i++)
+				contents[i] = data[i];
+			ata_write28(interface, this_block, contents);
+		}
+		data += 512;
+		marfs_mark_block_as_used(this_block);
 
-        if (i > 9 + (128 * 128 * 128)) {
-            if (!lba_quadruply) {
-                lba_quadruply = marfs_get_free_lba_block();
-                marfs_mark_block_as_used(lba_quadruply);
-                inode->ext_4 = lba_quadruply;
-            }
-            marfs_update_recursive(4, i, lba_quadruply, this_block);
-        } else if (i > 9 + (128 * 128)) {
-            if (!lba_triply) {
-                lba_triply = marfs_get_free_lba_block();
-                marfs_mark_block_as_used(lba_triply);
-                inode->ext_3 = lba_triply;
-            }
-            marfs_update_recursive(3, i, lba_triply, this_block);
-        } else if (i > 9 + 128) {
-            if (!lba_doubly) {
-                lba_doubly = marfs_get_free_lba_block();
-                marfs_mark_block_as_used(lba_doubly);
-                inode->ext_2 = lba_doubly;
-            }
-            marfs_update_recursive(2, i, lba_doubly, this_block);
-        } else if (i > 9) {
-            if (!lba_singly) {
-                lba_singly = marfs_get_free_lba_block();
-                marfs_mark_block_as_used(lba_singly);
-                inode->ext_1 = lba_singly;
-            }
-            marfs_update_recursive(1, i, lba_singly, this_block);
-        } else {
-            inode->DBPs[i] = this_block;
-        }
-    }
+		if (i > 9 + (128 * 128 * 128)) {
+			if (!lba_quadruply) {
+				lba_quadruply = marfs_get_free_lba_block();
+				marfs_mark_block_as_used(lba_quadruply);
+				inode->ext_4 = lba_quadruply;
+			}
+			marfs_update_recursive(4, i, lba_quadruply, this_block);
+		} else if (i > 9 + (128 * 128)) {
+			if (!lba_triply) {
+				lba_triply = marfs_get_free_lba_block();
+				marfs_mark_block_as_used(lba_triply);
+				inode->ext_3 = lba_triply;
+			}
+			marfs_update_recursive(3, i, lba_triply, this_block);
+		} else if (i > 9 + 128) {
+			if (!lba_doubly) {
+				lba_doubly = marfs_get_free_lba_block();
+				marfs_mark_block_as_used(lba_doubly);
+				inode->ext_2 = lba_doubly;
+			}
+			marfs_update_recursive(2, i, lba_doubly, this_block);
+		} else if (i > 9) {
+			if (!lba_singly) {
+				lba_singly = marfs_get_free_lba_block();
+				marfs_mark_block_as_used(lba_singly);
+				inode->ext_1 = lba_singly;
+			}
+			marfs_update_recursive(1, i, lba_singly, this_block);
+		} else {
+			inode->DBPs[i] = this_block;
+		}
+	}
 
-    // Write the inode
-    uint32_t inode_lba = marfs_get_free_lba_inode();
-    ata_write28(interface, inode_lba, (uint8_t *) inode);
+	// Write the inode
+	uint32_t inode_lba = marfs_get_free_lba_inode();
+	ata_write28(interface, inode_lba, (uint8_t *)inode);
 
-    return inode_lba;
+	return inode_lba;
 }
\ No newline at end of file
diff --git a/src/kernel/fs/marfs/read_whole_file.c b/src/kernel/fs/marfs/read_whole_file.c
index f530441..eb49dfe 100644
--- a/src/kernel/fs/marfs/read_whole_file.c
+++ b/src/kernel/fs/marfs/read_whole_file.c
@@ -7,63 +7,71 @@ static uint8_t last_max_level = 0;
 
 uint32_t marfs_get_recursive(uint8_t level, uint32_t i, uint32_t rec_lba)
 {
-    if (level > last_max_level) last_max_level = level;
-    uint32_t *contents = (uint32_t *) ata_read28(interface, rec_lba);
-    uint32_t idx = i - 10;
-    if (last_max_level > 1) idx -= 1 << 7;
-    if (last_max_level > 2) idx -= 1 << (7 * 2);
-    if (last_max_level > 3) idx -= 1 << (7 * 3);
-    idx >>= 7 * (level - 1);
+	if (level > last_max_level)
+		last_max_level = level;
+	uint32_t *contents = (uint32_t *)ata_read28(interface, rec_lba);
+	uint32_t idx = i - 10;
+	if (last_max_level > 1)
+		idx -= 1 << 7;
+	if (last_max_level > 2)
+		idx -= 1 << (7 * 2);
+	if (last_max_level > 3)
+		idx -= 1 << (7 * 3);
+	idx >>= 7 * (level - 1);
 
-    uint32_t next_rec_lba = contents[idx];
-    kfree(contents);
+	uint32_t next_rec_lba = contents[idx];
+	kfree(contents);
 
-    uint32_t toRet;
-    if (level > 1) toRet = marfs_get_recursive((uint8_t) (level - 1), i, next_rec_lba);
-    else toRet = next_rec_lba;
-    last_max_level = 0;
-    return toRet;
+	uint32_t toRet;
+	if (level > 1)
+		toRet = marfs_get_recursive((uint8_t)(level - 1), i, next_rec_lba);
+	else
+		toRet = next_rec_lba;
+	last_max_level = 0;
+	return toRet;
 }
 
 uint32_t marfs_get_block(struct marfs_inode *inode, uint32_t i)
 {
-    if (i > 9 + (128 * 128 * 128)) {
-        return marfs_get_recursive(4, i, inode->ext_4);
-    } else if (i > 9 + (128 * 128)) {
-        return marfs_get_recursive(3, i, inode->ext_3);
-    } else if (i > 9 + 128) {
-        return marfs_get_recursive(2, i, inode->ext_2);
-    } else if (i > 9) {
-        return marfs_get_recursive(1, i, inode->ext_1);
-    } else {
-        return inode->DBPs[i];
-    }
+	if (i > 9 + (128 * 128 * 128)) {
+		return marfs_get_recursive(4, i, inode->ext_4);
+	} else if (i > 9 + (128 * 128)) {
+		return marfs_get_recursive(3, i, inode->ext_3);
+	} else if (i > 9 + 128) {
+		return marfs_get_recursive(2, i, inode->ext_2);
+	} else if (i > 9) {
+		return marfs_get_recursive(1, i, inode->ext_1);
+	} else {
+		return inode->DBPs[i];
+	}
 }
 
 void marfs_read_whole_file(uint32_t lba_inode, uint8_t *buffer)
 {
-    struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_inode);
+	struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_inode);
 
-    uint32_t size_in_blocks = inode->n_blocks;
-    for (uint32_t i = 0; i < size_in_blocks; i++) {
-        uint32_t this_block = marfs_get_block(inode, i);
-        uint8_t *this_block_contents = ata_read28(interface, this_block);
-        uint16_t upper_bound = (uint16_t) ((i != size_in_blocks - 1) ? 512 : (inode->size % 512));
-        for (uint16_t j = 0; j < upper_bound; j++) buffer[(i * 512) + j] = this_block_contents[j];
-        kfree(this_block_contents);
-    }
+	uint32_t size_in_blocks = inode->n_blocks;
+	for (uint32_t i = 0; i < size_in_blocks; i++) {
+		uint32_t this_block = marfs_get_block(inode, i);
+		uint8_t *this_block_contents = ata_read28(interface, this_block);
+		uint16_t upper_bound =
+			(uint16_t)((i != size_in_blocks - 1) ? 512 : (inode->size % 512));
+		for (uint16_t j = 0; j < upper_bound; j++)
+			buffer[(i * 512) + j] = this_block_contents[j];
+		kfree(this_block_contents);
+	}
 
-    kfree(inode);
+	kfree(inode);
 }
 
 // TODO: Beautify
 uint8_t *marfs_allocate_and_read_whole_file(uint32_t lba_inode)
 {
-    struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_inode);
-    uint64_t size = inode->size;
-    kfree(inode);
+	struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_inode);
+	uint64_t size = inode->size;
+	kfree(inode);
 
-    uint8_t *buffer = (uint8_t *) kmalloc((uint32_t) size);
-    marfs_read_whole_file(lba_inode, buffer);
-    return buffer;
+	uint8_t *buffer = (uint8_t *)kmalloc((uint32_t)size);
+	marfs_read_whole_file(lba_inode, buffer);
+	return buffer;
 }
\ No newline at end of file
diff --git a/src/kernel/fs/marfs/sectorlevel.c b/src/kernel/fs/marfs/sectorlevel.c
index 96a24ba..e84e1f2 100644
--- a/src/kernel/fs/marfs/sectorlevel.c
+++ b/src/kernel/fs/marfs/sectorlevel.c
@@ -5,114 +5,117 @@
 
 uint8_t marfs_init(struct ata_interface *_interface)
 {
-    interface = _interface;
-    uint16_t identify_data[256 * 2];
-    uint8_t ret = ata_identify(interface, identify_data);
-    max_lba = (identify_data[61] << 16) + identify_data[60];
-    return ret;
+	interface = _interface;
+	uint16_t identify_data[256 * 2];
+	uint8_t ret = ata_identify(interface, identify_data);
+	max_lba = (identify_data[61] << 16) + identify_data[60];
+	return ret;
 }
 
 uint32_t marfs_get_max_lba(void)
 {
-    return max_lba;
+	return max_lba;
 }
 
 uint8_t marfs_write_mbr(uint8_t *mbr)
 {
-    return ata_write28(interface, 0, mbr);
+	return ata_write28(interface, 0, mbr);
 }
 
 struct marfs_superblock *marfs_read_superblock()
 {
-    struct marfs_superblock *p = (struct marfs_superblock *) ata_read28(interface, 1);
-    sb_cache = *p;
-    return p;
+	struct marfs_superblock *p = (struct marfs_superblock *)ata_read28(interface, 1);
+	sb_cache = *p;
+	return p;
 }
 
 uint8_t marfs_write_superblock(struct marfs_superblock *sb)
 {
-    sb_cache = *sb;
-    return ata_write28(interface, 1, (uint8_t *) sb);
+	sb_cache = *sb;
+	return ata_write28(interface, 1, (uint8_t *)sb);
 }
 
 uint32_t marfs_get_free_lba_block(void)
 {
-    uint32_t offset = 2 + sb_cache.s_first_chunk;
-    uint8_t *p = 0;
-    for (uint32_t i = 0; i < sb_cache.n_chunks; i++) {
-        p = ata_read28(interface, offset);
-        if (!(*p & 0x80)) break;
-        kfree(p);
-        offset += 512;
-    }
-
-    offset++;
-    for (uint16_t i = 1; i < 512; i++) {
-        if (!p[i]) break;
-        offset++;
-    }
-    kfree(p);
-
-    ata_clear28(interface, offset);
-
-    return offset;
+	uint32_t offset = 2 + sb_cache.s_first_chunk;
+	uint8_t *p = 0;
+	for (uint32_t i = 0; i < sb_cache.n_chunks; i++) {
+		p = ata_read28(interface, offset);
+		if (!(*p & 0x80))
+			break;
+		kfree(p);
+		offset += 512;
+	}
+
+	offset++;
+	for (uint16_t i = 1; i < 512; i++) {
+		if (!p[i])
+			break;
+		offset++;
+	}
+	kfree(p);
+
+	ata_clear28(interface, offset);
+
+	return offset;
 }
 
 static uint8_t marfs_mark_block(uint32_t lba_sector, uint8_t mode)
 {
-    lba_sector -= 2;
-    lba_sector -= sb_cache.s_first_chunk;
-    uint16_t block_in_chunk = (uint16_t) (lba_sector % 512);
-    lba_sector /= 512;
-    lba_sector = 2 + sb_cache.s_first_chunk + (512 * lba_sector);
-
-    uint8_t *p = ata_read28(interface, lba_sector);
-    p[block_in_chunk] = mode;
-
-    if (mode == 0) {
-        p[0] = 0;
-    } else {
-        uint8_t full_chunk = 1;
-        for (uint16_t i = 1; i < 512; i++) {
-            if (!p[i]) {
-                full_chunk = 0;
-                break;
-            }
-        }
-        p[0] = full_chunk;
-    }
-
-    uint8_t ret = ata_write28(interface, lba_sector, p);
-    kfree(p);
-    return ret;
+	lba_sector -= 2;
+	lba_sector -= sb_cache.s_first_chunk;
+	uint16_t block_in_chunk = (uint16_t)(lba_sector % 512);
+	lba_sector /= 512;
+	lba_sector = 2 + sb_cache.s_first_chunk + (512 * lba_sector);
+
+	uint8_t *p = ata_read28(interface, lba_sector);
+	p[block_in_chunk] = mode;
+
+	if (mode == 0) {
+		p[0] = 0;
+	} else {
+		uint8_t full_chunk = 1;
+		for (uint16_t i = 1; i < 512; i++) {
+			if (!p[i]) {
+				full_chunk = 0;
+				break;
+			}
+		}
+		p[0] = full_chunk;
+	}
+
+	uint8_t ret = ata_write28(interface, lba_sector, p);
+	kfree(p);
+	return ret;
 }
 
 uint8_t marfs_mark_block_as_free(uint32_t lba_sector)
 {
-    return marfs_mark_block(lba_sector, 0);
+	return marfs_mark_block(lba_sector, 0);
 }
 
 uint8_t marfs_mark_block_as_used(uint32_t lba_sector)
 {
-    return marfs_mark_block(lba_sector, 1);
+	return marfs_mark_block(lba_sector, 1);
 }
 
 uint32_t marfs_get_free_lba_inode(void)
 {
-    uint32_t offset;
-    for (offset = 2; offset < 2 + sb_cache.n_inodes; offset++) {
-        struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, offset);
-        uint8_t used = inode->is_used;
-        kfree(inode);
-        if (!used) break;
-    }
-    return offset;
+	uint32_t offset;
+	for (offset = 2; offset < 2 + sb_cache.n_inodes; offset++) {
+		struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, offset);
+		uint8_t used = inode->is_used;
+		kfree(inode);
+		if (!used)
+			break;
+	}
+	return offset;
 }
 
 void marfs_mark_inode_as_free(uint32_t lba_sector)
 {
-    struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_sector);
-    inode->is_used = 0;
-    ata_write28(interface, lba_sector, (uint8_t *) inode);
-    kfree(inode);
+	struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_sector);
+	inode->is_used = 0;
+	ata_write28(interface, lba_sector, (uint8_t *)inode);
+	kfree(inode);
 }
\ No newline at end of file
diff --git a/src/kernel/fs/vfs.c b/src/kernel/fs/vfs.c
index 702851e..9aeadf0 100644
--- a/src/kernel/fs/vfs.c
+++ b/src/kernel/fs/vfs.c
@@ -4,46 +4,44 @@ fs_node_t *fs_root = 0;
 
 uint32_t read_fs(fs_node_t *node, uint32_t offset, uint32_t size, uint8_t *buffer)
 {
-    if (node->read != 0)
-        return node->read(node, offset, size, buffer);
-    else
-        return 0;
+	if (node->read != 0)
+		return node->read(node, offset, size, buffer);
+	else
+		return 0;
 }
 
 uint32_t write_fs(fs_node_t *node, uint32_t offset, uint32_t size, uint8_t *buffer)
 {
-    if (node->write != 0)
-        return node->write(node, offset, size, buffer);
-    else
-        return 0;
+	if (node->write != 0)
+		return node->write(node, offset, size, buffer);
+	else
+		return 0;
 }
 
 void open_fs(fs_node_t *node, uint8_t read, uint8_t write)
 {
-    if (node->open != 0)
-        return node->open(node);
+	if (node->open != 0)
+		return node->open(node);
 }
 
 void close_fs(fs_node_t *node)
 {
-    if (node->close != 0)
-        return node->close(node);
+	if (node->close != 0)
+		return node->close(node);
 }
 
 struct dirent *readdir_fs(fs_node_t *node, uint32_t index)
 {
-    if ((node->flags & 0x7) == FS_DIRECTORY &&
-        node->readdir != 0)
-        return node->readdir(node, index);
-    else
-        return 0;
+	if ((node->flags & 0x7) == FS_DIRECTORY && node->readdir != 0)
+		return node->readdir(node, index);
+	else
+		return 0;
 }
 
 fs_node_t *finddir_fs(fs_node_t *node, char *name)
 {
-    if ((node->flags & 0x7) == FS_DIRECTORY &&
-        node->finddir != 0)
-        return node->finddir(node, name);
-    else
-        return 0;
+	if ((node->flags & 0x7) == FS_DIRECTORY && node->finddir != 0)
+		return node->finddir(node, name);
+	else
+		return 0;
 }
diff --git a/src/kernel/fs/vfs.h b/src/kernel/fs/vfs.h
index 5a72861..80b854a 100644
--- a/src/kernel/fs/vfs.h
+++ b/src/kernel/fs/vfs.h
@@ -3,13 +3,13 @@
 
 #include <stdint.h>
 
-#define FS_FILE        0x01
-#define FS_DIRECTORY   0x02
-#define FS_CHARDEVICE  0x03
+#define FS_FILE 0x01
+#define FS_DIRECTORY 0x02
+#define FS_CHARDEVICE 0x03
 #define FS_BLOCKDEVICE 0x04
-#define FS_PIPE        0x05
-#define FS_SYMLINK     0x06
-#define FS_MOUNTPOINT  0x08
+#define FS_PIPE 0x05
+#define FS_SYMLINK 0x06
+#define FS_MOUNTPOINT 0x08
 
 struct fs_node;
 
@@ -26,26 +26,26 @@ typedef struct dirent *(*readdir_type_t)(struct fs_node *, uint32_t);
 typedef struct fs_node *(*finddir_type_t)(struct fs_node *, char *name);
 
 typedef struct fs_node {
-    char name[128];
-    uint32_t mask;
-    uint32_t uid;
-    uint32_t gid;
-    uint32_t flags;
-    uint32_t inode;
-    uint32_t length;
-    uint32_t impl;
-    read_type_t read;
-    write_type_t write;
-    open_type_t open;
-    close_type_t close;
-    readdir_type_t readdir;
-    finddir_type_t finddir;
-    struct fs_node *ptr;
+	char name[128];
+	uint32_t mask;
+	uint32_t uid;
+	uint32_t gid;
+	uint32_t flags;
+	uint32_t inode;
+	uint32_t length;
+	uint32_t impl;
+	read_type_t read;
+	write_type_t write;
+	open_type_t open;
+	close_type_t close;
+	readdir_type_t readdir;
+	finddir_type_t finddir;
+	struct fs_node *ptr;
 } fs_node_t;
 
 struct dirent {
-    char name[128];
-    uint32_t ino;
+	char name[128];
+	uint32_t ino;
 };
 
 extern fs_node_t *fs_root;