clang-format

3 files changed, 73 insertions, 43 deletions

diff --git a/kernel/src/mem/heap.c b/kernel/src/mem/heap.c
index b49eefb..537a2fe 100644
--- a/kernel/src/mem/heap.c
+++ b/kernel/src/mem/heap.c
@@ -1,6 +1,5 @@
 #include <types.h>
 #include <heap.h>
-
 #include <libk/math.h>
 #include <paging.h>
 #include <libk/serial_stdio.h>
@@ -8,17 +7,18 @@
 
 kheap_t main_kheap;
 
-void kheap_init(kheap_t* kheap)
+void kheap_init(kheap_t *kheap)
 {
 	kheap->fblock = NULL;
 }
 
-void kheap_add_block(kheap_t* kheap, uint64_t addr, uint32_t size, uint32_t bsize)
+void kheap_add_block(kheap_t *kheap, uint64_t addr, uint32_t size,
+		     uint32_t bsize)
 {
 	kheapblock_t *kheapblock;
 
 	// store size & bsize into kheapblock
-	kheapblock = (kheapblock_t*)addr;
+	kheapblock = (kheapblock_t *)addr;
 	kheapblock->size = size - (uint32_t)sizeof(kheapblock_t);
 	kheapblock->bsize = bsize;
 
@@ -28,14 +28,15 @@ void kheap_add_block(kheap_t* kheap, uint64_t addr, uint32_t size, uint32_t bsiz
 
 	// block count & bitmap
 	uint32_t bcnt = kheapblock->size / kheapblock->bsize;
-	uint8_t* bm = (uint8_t*)&kheapblock[1];
+	uint8_t *bm = (uint8_t *)&kheapblock[1];
 
 	// clear bitmap
 	for (size_t i = 0; i < bcnt; i++) {
 		bm[i] = 0;
 	}
 
-	uint32_t bcnt_used = upper_div((bcnt + (uint32_t)sizeof(kheapblock_t)), bsize);
+	uint32_t bcnt_used =
+		upper_div((bcnt + (uint32_t)sizeof(kheapblock_t)), bsize);
 	for (size_t i = 0; i < bcnt_used; i++) {
 		bm[i] = 5;
 	}
@@ -43,13 +44,15 @@ void kheap_add_block(kheap_t* kheap, uint64_t addr, uint32_t size, uint32_t bsiz
 	kheapblock->used = bcnt_used;
 }
 
-void* kheap_alloc(kheap_t* kheap, uint32_t size)
+void *kheap_alloc(kheap_t *kheap, uint32_t size)
 {
-	kheapblock_t* kheapblock;
+	kheapblock_t *kheapblock;
 
 	// find kheapblock that has enough space
-	for (kheapblock = kheap->fblock; kheapblock; kheapblock = kheapblock->next) {
-		if (kheapblock->size - (kheapblock->used * kheapblock->bsize) < size) {
+	for (kheapblock = kheap->fblock; kheapblock;
+	     kheapblock = kheapblock->next) {
+		if (kheapblock->size - (kheapblock->used * kheapblock->bsize) <
+		    size) {
 			continue;
 		}
 
@@ -57,12 +60,12 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size)
 		bool ind1 = ((size % 4096) == 0);
 		bool ind2 = (kheapblock->bsize == 4096);
 		if (ind1 + ind2 == 1) {
-				continue;
+			continue;
 		}
 
 		uint32_t bcnt = kheapblock->size / kheapblock->bsize;
 		uint32_t bneed = upper_div(size, kheapblock->bsize);
-		uint8_t* bm = (uint8_t*)&kheapblock[1];
+		uint8_t *bm = (uint8_t *)&kheapblock[1];
 
 		// find empty block
 		for (size_t i = 0; i < bcnt; i++) {
@@ -72,7 +75,9 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size)
 
 			// find bneed consecutive empty blocks
 			size_t j;
-			for (j = 0; bm[i + j] == 0 && j < bneed && i + j < bcnt; j++);
+			for (j = 0; bm[i + j] == 0 && j < bneed && i + j < bcnt;
+			     j++)
+				;
 			if (j != bneed) {
 				i += j - 1;
 				continue;
@@ -80,7 +85,8 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size)
 
 			// using id for the block that is different from previous or next block
 			uint8_t idp = bm[i - 1], idn = bm[i + j], id;
-			for (id = idp + 1; id == idn || id == 0; id++);
+			for (id = idp + 1; id == idn || id == 0; id++)
+				;
 
 			// mark blocks as used
 			for (j = 0; j < bneed; j++) {
@@ -89,24 +95,31 @@ void* kheap_alloc(kheap_t* kheap, uint32_t size)
 
 			kheapblock->used += bneed;
 
-			return (void*)(i * kheapblock->bsize + (uintptr_t)&kheapblock[0]);
+			return (void *)(i * kheapblock->bsize +
+					(uintptr_t)&kheapblock[0]);
 		}
 	}
 	printf("Error: there is no remaining memory in kheap\n");
 	return NULL;
 }
 
-void kheap_free(kheap_t* kheap, void* pointer)
+void kheap_free(kheap_t *kheap, void *pointer)
 {
-	kheapblock_t* kheapblock;
-	for (kheapblock = kheap->fblock; kheapblock; kheapblock = kheapblock->next) {
-		if ((uintptr_t)(pointer) > (uintptr_t)kheapblock && (uintptr_t)(pointer) < (uintptr_t)kheapblock + sizeof(kheapblock_t) + kheapblock->size) {
+	kheapblock_t *kheapblock;
+	for (kheapblock = kheap->fblock; kheapblock;
+	     kheapblock = kheapblock->next) {
+		if ((uintptr_t)(pointer) > (uintptr_t)kheapblock &&
+		    (uintptr_t)(pointer) < (uintptr_t)kheapblock +
+						   sizeof(kheapblock_t) +
+						   kheapblock->size) {
 			// found block
 
 			// get index of bitmap entry
-			uintptr_t pointer_offset = (uintptr_t)pointer - (uintptr_t)&kheapblock[0];
-			uint32_t bi = (uint32_t)pointer_offset / kheapblock->bsize;
-			uint8_t* bm = (uint8_t*)&kheapblock[1];
+			uintptr_t pointer_offset =
+				(uintptr_t)pointer - (uintptr_t)&kheapblock[0];
+			uint32_t bi =
+				(uint32_t)pointer_offset / kheapblock->bsize;
+			uint8_t *bm = (uint8_t *)&kheapblock[1];
 			uint8_t id = bm[bi];
 			uint32_t max = kheapblock->size / kheapblock->bsize;
 
@@ -126,6 +139,8 @@ void kheap_free(kheap_t* kheap, void* pointer)
 void init_heap()
 {
 	kheap_init(&main_kheap);
-	kheap_add_block(&main_kheap, HEAP1_VMEM_ADDR, HEAP1_SIZE, HEAP1_BLOCK_SIZE);
-	kheap_add_block(&main_kheap, HEAP2_VMEM_ADDR, HEAP2_SIZE, HEAP2_BLOCK_SIZE);
+	kheap_add_block(&main_kheap, HEAP1_VMEM_ADDR, HEAP1_SIZE,
+			HEAP1_BLOCK_SIZE);
+	kheap_add_block(&main_kheap, HEAP2_VMEM_ADDR, HEAP2_SIZE,
+			HEAP2_BLOCK_SIZE);
 }
diff --git a/kernel/src/mem/paging.c b/kernel/src/mem/paging.c
index b8c44c0..aa61c5d 100644
--- a/kernel/src/mem/paging.c
+++ b/kernel/src/mem/paging.c
@@ -1,7 +1,6 @@
 #include <types.h>
 #include <paging.h>
 #include <panic.h>
-
 #include <heap.h>
 #include <libk/serial_stdio.h>
 #include <libk/stdio.h>
@@ -21,24 +20,28 @@ void map_addr(uint64_t virt, uint64_t phys, uint32_t flags)
 	size_t pt_lvl4_i = (virt >> 39) % 0x200; // 512gb entry
 	size_t pt_lvl3_i = (virt >> 30) % 0x200; // 1gb entry
 	size_t pt_lvl2_i = (virt >> 21) % 0x200; // 2mb entry
-//	size_t pt_lvl1_i = (virt >> 12) % 0x200; // 4kb entry
+	//	size_t pt_lvl1_i = (virt >> 12) % 0x200; // 4kb entry
 
-	uint64_t* pt_lvl3 = (uint64_t*)(page_table_lvl4[pt_lvl4_i] + KERNEL_VMA);
+	uint64_t *pt_lvl3 =
+		(uint64_t *)(page_table_lvl4[pt_lvl4_i] + KERNEL_VMA);
 	if (!((uint64_t)pt_lvl3 & FLAG_PRESENT)) {
-		pt_lvl3 = (uint64_t*)kalloc(4096);
+		pt_lvl3 = (uint64_t *)kalloc(4096);
 		memset(pt_lvl3, 0, 4096);
-		page_table_lvl4[pt_lvl4_i] = ((uint64_t)pt_lvl3 - KERNEL_VMA) | flags;
+		page_table_lvl4[pt_lvl4_i] = ((uint64_t)pt_lvl3 - KERNEL_VMA) |
+					     flags;
 	} else {
-		pt_lvl3 = (uint64_t*)((uint64_t)pt_lvl3 - (uint64_t)pt_lvl3 % 4096);
+		pt_lvl3 = (uint64_t *)((uint64_t)pt_lvl3 -
+				       (uint64_t)pt_lvl3 % 4096);
 	}
 
-	uint64_t* pt_lvl2 = (uint64_t*)(pt_lvl3[pt_lvl3_i] + KERNEL_VMA);
+	uint64_t *pt_lvl2 = (uint64_t *)(pt_lvl3[pt_lvl3_i] + KERNEL_VMA);
 	if (!((uint64_t)pt_lvl2 & FLAG_PRESENT)) {
-		pt_lvl2 = (uint64_t*)kalloc(4096);
+		pt_lvl2 = (uint64_t *)kalloc(4096);
 		memset(pt_lvl2, 0, 4096);
 		pt_lvl3[pt_lvl3_i] = ((uint64_t)pt_lvl2 - KERNEL_VMA) | flags;
 	} else {
-		pt_lvl2 = (uint64_t*)((uint64_t)pt_lvl2 - (uint64_t)pt_lvl2 % 4096);
+		pt_lvl2 = (uint64_t *)((uint64_t)pt_lvl2 -
+				       (uint64_t)pt_lvl2 % 4096);
 	}
 
 	pt_lvl2[pt_lvl2_i] = phys | flags | FLAG_HUGE;
@@ -46,11 +49,15 @@ void map_addr(uint64_t virt, uint64_t phys, uint32_t flags)
 
 void init_paging(void)
 {
-	page_table_lvl4[511] = (uint64_t)page_table_lvl3 - KERNEL_VMA + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER);
-	page_table_lvl3[510] = (uint64_t)page_table_lvl2 - KERNEL_VMA + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER);
+	page_table_lvl4[511] = (uint64_t)page_table_lvl3 - KERNEL_VMA +
+			       (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER);
+	page_table_lvl3[510] = (uint64_t)page_table_lvl2 - KERNEL_VMA +
+			       (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER);
 	// 16mb kernel + 32mb heap + 2mb (32kb stack * 64 threads) = first 50mb
 	for (size_t i = 0; i < 25; i++) {
-		page_table_lvl2[i] = (uint64_t)0x0 + PAGE_SIZE * i + (FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER | FLAG_HUGE);
+		page_table_lvl2[i] =
+			(uint64_t)0x0 + PAGE_SIZE * i +
+			(FLAG_PRESENT | FLAG_WRITABLE | FLAG_USER | FLAG_HUGE);
 	}
 
 	load_pt_lvl4(page_table_lvl4);
@@ -59,7 +66,7 @@ void init_paging(void)
 void page_fault(uint64_t error)
 {
 	uint64_t addr;
-	__asm__ __volatile__ ("mov %%cr2, %0;" : "=r"(addr) : : "memory");
+	__asm__ __volatile__("mov %%cr2, %0;" : "=r"(addr) : : "memory");
 
 	printf("address: 0x%x, error code: 0x%x\n", addr, error);
 
diff --git a/kernel/src/mem/pmm.c b/kernel/src/mem/pmm.c
index f0b4884..043043c 100644
--- a/kernel/src/mem/pmm.c
+++ b/kernel/src/mem/pmm.c
@@ -6,7 +6,7 @@
 #include <multiboot2.h>
 #include <pmm.h>
 
-#define MEM_USED_BELOW 50*1024*1024
+#define MEM_USED_BELOW 50 * 1024 * 1024
 
 uint64_t free_mem_cnt;
 uint64_t all_mem_cnt;
@@ -16,17 +16,23 @@ void init_pmm()
 {
 	INIT_LIST(pmm_list);
 
-	mmap_t* pos;
+	mmap_t *pos;
 	list_for_each_entry_prev(pos, (&mmap.list), list) {
 		mb2_tag_mmap_entry entry = pos->mmap_entry;
 		if (entry.type != 1)
 			continue;
-		uint64_t base = entry.base_addr & (PAGE_SIZE - 1) ? (entry.base_addr & (uint64_t)~(PAGE_SIZE - 1)) + PAGE_SIZE : entry.base_addr;
-		for (uint64_t i = base; i + PAGE_SIZE <= entry.base_addr + entry.length; i += PAGE_SIZE) {
+		uint64_t base = entry.base_addr & (PAGE_SIZE - 1) ?
+					(entry.base_addr &
+					 (uint64_t) ~(PAGE_SIZE - 1)) +
+						PAGE_SIZE :
+					entry.base_addr;
+		for (uint64_t i = base;
+		     i + PAGE_SIZE <= entry.base_addr + entry.length;
+		     i += PAGE_SIZE) {
 			if (i >= MEM_USED_BELOW) {
 				free_mem_cnt++;
 				map_addr(i, i, FLAG_PRESENT);
-				list_t* list = (list_t*)i;
+				list_t *list = (list_t *)i;
 				add_to_list(list, &pmm_list, pmm_list.next);
 			}
 		}
@@ -36,6 +42,8 @@ void init_pmm()
 
 void memory_usage()
 {
-	printf("memory used: %dMB\n", (MEM_USED_BELOW + (all_mem_cnt - free_mem_cnt) * PAGE_SIZE) / 1024 / 1024);
+	printf("memory used: %dMB\n",
+	       (MEM_USED_BELOW + (all_mem_cnt - free_mem_cnt) * PAGE_SIZE) /
+		       1024 / 1024);
 	printf("memory free: %dMB\n", free_mem_cnt * PAGE_SIZE / 1024 / 1024);
 }