wip: user allocator

headers/memory.h

@@ -21,11 +21,16 @@
 #define KERNEL_END      ((uint32_t)&_kernel_end - VIRT_OFFSET)
 #define KERNEL_PT_END   1020
 #define KERNEL_PT_START 769
+#define USER_PT_START   1
+#define USER_PT_END     768
 
 #define PDE_VBE         1021
 #define PDE_FRAME_ZONES 1022
 #define PDE_MULTIBOOT   1020
 
+#define GET_PTE(pd_index, pt_index)                                            \
+	((uint32_t *)(VIRT_PT_BASE + pd_index * 1024 + pt_index))
+
 #define PTE2VA(pd_index, pt_index)                                             \
 	((uint32_t *)((((uint32_t)pd_index * 1024) + (uint32_t)pt_index) *     \
 	              4096))
@@ -69,6 +74,6 @@ void init_memory(void);
 void *alloc_frame(void);
 int free_frame(void *frame_ptr);
 void *kalloc_pages(size_t nb_pages);
-void *valloc_pages(size_t size, void **phys_addr);
+void *valloc_pages(size_t nb_pages);
 int kfree_pages(void *page_ptr, size_t size);
 int vfree_pages(void *page_ptr, size_t size);

src/memory/kern/allocator.c

@@ -3,6 +3,7 @@
 #include "kprintf.h"
 #include "memory.h"
 #include "string.h"
+#include "utils.h"
 
 Zone *kzones[3];
 
@@ -49,7 +50,7 @@ static void new_block(Zone *zone, uint32_t zone_size)
 int new_kzone(block_type_t type, uint32_t size)
 {
 	// assert(current_task->pid);
-	void *heap = kalloc_pages(size);
+	void *heap = kalloc_pages(CEIL(size, PAGE_SIZE));
 	if (heap == NULL) {
 		kprintf(KERN_ERR "error: alloc_frame failed\n");
 		return (-1);

src/memory/kern/page.c

@@ -12,7 +12,8 @@
 static uint32_t *find_next_block(size_t nb_pages)
 {
 	uint32_t count = 0;
-	for (uint32_t *pte = PTE2VA(1023, 0); pte < PTE2VA(1023, 1023); pte++) {
+	for (uint32_t *pte = PTE2VA(1023, KERNEL_PT_START);
+	     pte < PTE2VA(1023, KERNEL_PT_END); pte++) {
 		if (!*pte) {
 			count = 0;
 			continue;
@@ -27,6 +28,8 @@ static uint32_t *find_next_block(size_t nb_pages)
 void *kalloc_pages(size_t nb_pages)
 {
 	uint32_t *start = find_next_block(nb_pages);
+	if (!start)
+		return NULL;
 	for (uint32_t i = 0; i < nb_pages; i++) {
 		void *frame = alloc_frame();
 		if (!frame) {
@@ -35,7 +38,7 @@ void *kalloc_pages(size_t nb_pages)
 				                    PAGE_MASK));
 			return NULL;
 		}
-		assert(!((uint32_t)frame & PAGE_MASK));
+		assert((uint32_t)frame & PAGE_MASK);
 		start[i] = (uint32_t)frame | INIT_FLAGS;
 	}
 	uint32_t page_index = start - PTE2VA(1023, 0);

src/memory/memory.c

@@ -123,7 +123,7 @@ void init_memory()
 		uint32_t frame = (uint32_t)alloc_frame();
 		if (!frame)
 			kpanic("Couldn't initialize kernel PTs\n");
-		PD[i] = frame | RW;
+		PD[i] = frame | INIT_FLAGS;
 	}
 	// kalash kalash kalash sur la mélodie chez nous pas de félonie ça vient
 	// de Sevran les R

src/memory/virt/allocator.c

@@ -4,6 +4,7 @@
 #include "kprintf.h"
 #include "memory.h"
 #include "string.h"
+#include "utils.h"
 
 Zone *vzones[3];
 
@@ -50,7 +51,7 @@ static void new_block(Zone *zone, uint32_t zone_size)
 int new_vzone(block_type_t type, uint32_t size)
 {
 	// assert(current_task->pid);
-	void *heap = valloc_pages(size, NULL);
+	void *heap = valloc_pages(CEIL(size, PAGE_SIZE));
 	if (heap == NULL) {
 		kprintf(KERN_ERR "error: alloc_pages failed\n");
 		return (-1);

src/memory/virt/page.c

@@ -9,82 +9,68 @@
 #include "string.h"
 #include "utils.h"
 
-static int16_t find_next_block(size_t nb_pages, uint16_t *pd_index_ptr,
+static int8_t alloc_pagetable(uint16_t pd_index)
-                               uint32_t **page_table_ptr)
 {
-	for (*pd_index_ptr = 2; *pd_index_ptr < 768; (*pd_index_ptr)++) {
+	uint32_t *pt = alloc_frame();
-		// if (current_pd[(*pd_index_ptr)] == 0x02) {
+	if (!pt)
-		// if (add_page_table(*pd_index_ptr, 1) < 0)
-		// 	return -2;
-		// }
-		*page_table_ptr = (uint32_t *)PTE2VA(1, *pd_index_ptr);
-		for (uint16_t i = 0; i + nb_pages - 1 < 1024; i++) {
-			uint16_t j;
-			for (j = 0; (*page_table_ptr)[i + j] >> 12 == i + j &&
-			            j < nb_pages;
-			     j++)
-				;
-			if (j == nb_pages)
-				return i;
-			i += j;
-		}
-	}
 		return -1;
-}
+	PD[pd_index] = (uint32_t)pt | INIT_FLAGS;
-
+	return 0;
-void *valloc_pages(size_t size, void **phys_addr)
+}
-{
+
-	const uint32_t nb_pages = CEIL(size, PAGE_SIZE);
+static uint32_t *find_next_block(size_t nb_pages)
-	uint16_t pd_index;
+{
-	uint32_t *page_table;
+	size_t count = 0;
-	const int16_t index = find_next_block(nb_pages, &pd_index, &page_table);
+	for (size_t i = USER_PT_START; i < USER_PT_END; i++) {
-
+		if (!PD[i])
-	if (index < 0) {
+			if (alloc_pagetable(i) < 0)
-		kprintf(KERN_CRIT "%d: Not enough pages (max: %d)\n", index,
+				return NULL;
-		        1024);
+		for (size_t j = 0; j < 1024; j++) {
-		return NULL;
+			if (!*GET_PTE(i, j)) {
-	}
+				count = 0;
-	for (size_t i = index; i - (size_t)index < nb_pages; i++) {
+				continue;
-		void *frame = alloc_frame();
+			}
-		if (!frame) {
+			count++;
-			for (size_t j = index; j < i; j++)
+			if (count == nb_pages) {
-				free_frame((void *)(page_table[j] & PAGE_MASK));
+				return GET_PTE(i, j) - count;
-			return NULL;
+			}
-		}
+		}
-		if (phys_addr)
+	}
-			*phys_addr = frame;
+	return NULL;
-		page_table[i] = ((uint32_t)frame & PAGE_MASK) | INIT_FLAGS;
+}
-	}
+
-	return (void *)PTE2VA(pd_index, index);
+void *valloc_pages(size_t nb_pages)
-}
+{
-
+	uint32_t *start = find_next_block(nb_pages);
-int vfree_pages(void *page_ptr, size_t size)
+	if (!start)
-{
+		return NULL;
-	const uint32_t page_addr = (uint32_t)page_ptr;
+	for (uint32_t i = 0; i < nb_pages; i++) {
-	const uint32_t nb_pages = CEIL(size, PAGE_SIZE);
+		void *frame = alloc_frame();
-	const uint32_t page_index = page_addr / PAGE_SIZE;
+		if (!frame) {
-	const uint32_t pd_index = page_index / 1024;
+			for (uint32_t j = 0; j < i; j++)
-	const uint32_t pt_index = page_index % 1024;
+				free_frame((void *)(((uint32_t)(start + j)) &
-
+				                    PAGE_MASK));
-	if ((uint32_t)pd_index > 0x300) {
+			return NULL;
-		kprintf(KERN_WARNING "Address out of range\n");
+		}
-		return -1;
+		assert((uint32_t)frame & PAGE_MASK);
-	} else if (page_addr % PAGE_SIZE) {
+		start[i] = (uint32_t)frame | INIT_FLAGS;
-		kprintf(KERN_WARNING "Invalid address\n");
+	}
-		return -1;
+	uint32_t page_index = start - PTE2VA(1023, 0);
-	} else if (pt_index + nb_pages > 1024) {
+	return PTE2VA(page_index / 1024, page_index % 1024);
-		kprintf(KERN_WARNING "Invalid number of frames\n");
+}
-		return -1;
+
-	}
+int vfree_pages(void *page_ptr, size_t nb_pages)
-	uint32_t *page_table = (uint32_t *)PTE2VA(1, pd_index);
+{
-	for (uint16_t i = pt_index; i < pt_index + nb_pages; i++) {
+	const uint32_t page_addr = (uint32_t)page_ptr;
-		if (page_table[i] >> 12 == i) {
+	if (page_addr % PAGE_SIZE) {
-			kprintf(KERN_WARNING "Page already freed\n");
+		kprintf(KERN_WARNING "Invalid address\n");
-			return -2;
+		return -1;
-		}
+	}
-		free_frame((void *)(page_table[i] & PAGE_MASK));
+
-		page_table[i] = i << 12;
+	for (uint32_t *pte = VA2PTE(page_addr);
-	}
+	     pte < VA2PTE(page_addr) + nb_pages; pte++) {
-
+		free_frame((void *)(*pte & PAGE_MASK));
+		*pte = 0;
+	}
 	return 0;
 }

src/multitasking/thread.c

@@ -7,6 +7,7 @@
 #include "process.h"
 #include "string.h"
 #include "thread.h"
+#include "utils.h"
 
 struct tcb *create_thread(struct pcb *process, void (*entry)(void))
 {
@@ -15,7 +16,7 @@ struct tcb *create_thread(struct pcb *process, void (*entry)(void))
 		return NULL;
 	new_tcb->tid = process->tid++;
 
-	new_tcb->esp0 = valloc_pages(STACK_SIZE, NULL);
+	new_tcb->esp0 = valloc_pages(CEIL(STACK_SIZE, PAGE_SIZE));
 	if (!new_tcb->esp0) {
 		vfree(new_tcb);
 		return NULL;