Implemented more memory manager and btree tests in sandbox

sandbox/Makefile

@@ -6,7 +6,7 @@ BUILD_DIR := $(SANDBOX_BASE_DIR)/../build/sandbox
 
 include $(SANDBOX_BASE_DIR)/../tools/make/gcc-host.mk
 EXEC_NAME := sandbox
-DIR_LIST := memblock vm base
+DIR_LIST := memblock vm base queue btree
 INCLUDE_DIRS := $(foreach dir,$(DIR_LIST),-I$(dir)/include)
 SRC := $(foreach dir,$(DIR_LIST),$(wildcard $(dir)/*.c))
 OBJ := $(addprefix $(BUILD_DIR)/,$(SRC:.c=.o))

sandbox/base/main.c

@@ -5,14 +5,24 @@
 #include <time.h>
 #include <sys/mman.h>
 #include <socks/types.h>
+#include <socks/btree.h>
 #include <socks/memblock.h>
+#include <socks/vm.h>
 
-/* we're working with 4MiB of simulated system RAM */
-#define MEMORY_SIZE_MB 128
+#define NR_BTREE_NODES 3
+
+/* we're working with 512MiB of simulated system RAM */
+#define MEMORY_SIZE_MB 512
 
 #define ALLOC_START_MB 16
 #define ALLOC_END_MB 18
 
+#define MEMPTR(offset) ((uintptr_t)system_memory + (offset))
+#define MB_TO_BYTES(v) ((size_t)(v) * 0x100000)
+
+#define PHYS_TO_VIRT(p) ((void *)((uintptr_t)system_memory + (p)))
+#define VIRT_TO_PHYS(p) ((void *)((p) - (uintptr_t)system_memory))
+
 struct mem_map_region {
 	phys_addr_t base;
 	phys_addr_t limit;
@@ -23,19 +33,17 @@ static struct mem_map_region mem_map[] = {
 	{ .base = 0x00000000, .limit = 0x0000ffff, .status = REGION_RESERVED },
 	{ .base = 0x00010000, .limit = 0x0004ffff, .status = REGION_FREE },
 	{ .base = 0x00050000, .limit = 0x0005ffff, .status = REGION_RESERVED },
-	{ .base = 0x00060000, .limit = 0x000affff, .status = REGION_FREE },
+	{ .base = 0x00060000, .limit = 0x000fffff, .status = REGION_FREE },
+	{ .base = 0x00100000, .limit = 0x001fffff, .status = REGION_RESERVED },
+	{ .base = 0x00200000, .limit = 0x005fffff, .status = REGION_FREE },
+	{ .base = 0x00600000, .limit = 0x007fffff, .status = REGION_RESERVED },
+	{ .base = 0x00800000, .limit = MB_TO_BYTES(MEMORY_SIZE_MB) - 1, .status = REGION_FREE },
 };
 
 /* virtual address of where system memory is mapped */
 static void *system_memory = NULL;
 
-#define MEMPTR(offset) ((uintptr_t)system_memory + (offset))
-#define MB_TO_BYTES(v) ((size_t)(v) * 0x100000)
-
-#define PHYS_TO_VIRT(p) ((void *)((uintptr_t)system_memory + (p)))
-#define VIRT_TO_PHYS(p) ((void *)((p) - (uintptr_t)system_memory))
-
-int main(int argc, const char **argv)
+static int memory_test(void)
 {
 	srand(time(NULL));
 	system_memory = mmap(
@@ -64,31 +72,32 @@ int main(int argc, const char **argv)
 		}
 	}
 
-	memblock_add(pmem_base, pmem_limit);
-	
+	memblock_add(pmem_base, pmem_limit + 1);
+
 	for (size_t i = 0; i < nr_mem_map_entries; i++) {
 		if (mem_map[i].status == REGION_RESERVED) {
-			memblock_reserve(mem_map[i].base, mem_map[i].limit);
+			memblock_reserve(mem_map[i].base, mem_map[i].limit - mem_map[i].base + 1);
 		}
 	}
-	
+
 	printf("allocated %u MiB (0x%zx bytes) of memory to act as system RAM at %p\n", MEMORY_SIZE_MB, MB_TO_BYTES(MEMORY_SIZE_MB), system_memory);
 
+	printf("sizeof(vm_page_t) = %zu bytes\n", sizeof(vm_page_t));
+
 	uintptr_t voffset = (uintptr_t)system_memory;
 
 	memblock_init(MB_TO_BYTES(ALLOC_START_MB) + voffset, MB_TO_BYTES(ALLOC_END_MB) + voffset, voffset);
 
 	printf("memblock heap initialised in 0x%zx-0x%zx\n", MB_TO_BYTES(ALLOC_START_MB), MB_TO_BYTES(ALLOC_END_MB));
 
-	memblock_add(0, MB_TO_BYTES(MEMORY_SIZE_MB));
-
-	for (int i = 0; i < 8; i++) {
+	for (int i = 0; i < 4; i++) {
 		int size = 512 + (rand() % 16384);
 
 		phys_addr_t alloc = memblock_alloc_phys(size);
 		printf("allocated %d bytes at 0x%" PRIxPTR "\n", size, alloc);
 	}
-		
+
+	vm_bootstrap();
 
 	printf("memory regions:\n");
 
@@ -117,3 +126,69 @@ int main(int argc, const char **argv)
 	munmap(system_memory, MB_TO_BYTES(MEMORY_SIZE_MB));
 	return 0;
 }
+
+static void btree_print(btree_node_t *node, int depth)
+{
+	if (!node) {
+		return;
+	}
+
+	if (node) {
+	    btree_print(node->b_right, depth + 1);
+	}
+
+	for (int i = 0; i < depth; i++) {
+		fputs("    ", stdout);
+	}
+
+	if (node) {
+		printf("%llu (h:%d)\n", node->b_key, node->b_height);
+	} else {
+		printf("\x1b[1;31mNULL\x1b[0m\n");
+	}
+
+	if (node) {
+		btree_print(node->b_left, depth + 1);
+	}
+}
+
+static int btree_test(void)
+{
+	btree_t tree = {};
+	btree_node_t nodes[] = {
+		{ .b_key = 1 },
+		{ .b_key = 2 },
+		{ .b_key = 3 },
+		{ .b_key = 4 },
+		{ .b_key = 5 },
+		{ .b_key = 6 },
+		{ .b_key = 7 },
+	};
+
+	int nr_nodes = sizeof nodes / sizeof nodes[0];
+	for (int i = 0; i < nr_nodes; i++) {
+		btree_insert(&tree, &nodes[i]);
+	}
+	btree_print(tree.b_root, 0);
+
+	int to_delete[] = { 3, 1, 0 };
+	int nr_to_delete = sizeof to_delete / sizeof to_delete[0];
+
+	for (int i = 0; i < nr_to_delete; i++) {
+		int node_index = to_delete[i];
+
+		printf("#######################\n");
+		printf("deleting node %llu\n", nodes[node_index].b_key);
+		printf("#######################\n");
+
+		btree_delete(&tree, &nodes[node_index]);
+		btree_print(tree.b_root, 0);
+	}
+
+	return 0;
+}
+
+int main(int argc, const char **argv)
+{
+	btree_test();
+}

sandbox/queue/include/socks/queue.h

@@ -0,0 +1,14 @@
+#ifndef SOCKS_QUEUE_H_
+#define SOCKS_QUEUE_H_
+
+typedef struct queue_entry {
+	struct queue_entry *q_next;
+	struct queue_entry *q_prev;
+} queue_entry_t;
+
+typedef struct queue {
+	queue_entry_t *q_first;
+	queue_entry_t *q_last;
+} queue_t;
+
+#endif

sandbox/vm/include/socks/vm.h

@@ -4,6 +4,9 @@
 #include <stddef.h>
 #include <socks/types.h>
 #include <socks/status.h>
+#include <socks/queue.h>
+
+#define VM_PAGE_SIZE 0x1000
 
 typedef enum vm_zone_id {
 	VM_ZONE_DMA		= 1u,
@@ -24,7 +27,7 @@ typedef struct vm_zone_descriptor {
 } vm_zone_descriptor_t;
 
 typedef struct vm_zone {
-	unsigned z_reserved[32];
+	unsigned char z_reserved[32];
 } vm_zone_t;
 
 typedef struct vm_pg_data {
@@ -43,9 +46,15 @@ typedef enum vm_page_flags {
 
 typedef struct vm_page {
 	uint32_t p_flags; /* vm_page_flags_t bitfield */
+
+	/* buddy allocator free page list head */
+	queue_entry_t p_buddy_list;
+
+	/* order of the page block that this page belongs too */
+	unsigned int p_order;
 } __attribute__((packed)) vm_page_t;
 
-extern kern_status_t vm_bootstrap(const vm_region_t *mem_map, size_t nr_mem_map_entries);
+extern kern_status_t vm_bootstrap(void);
 
 extern void vm_page_init(vm_page_t *pg);
 

sandbox/vm/vm_bootstrap.c

@@ -1,33 +1,44 @@
+#include <socks/status.h>
 #include <limits.h>
 #include <socks/vm.h>
 #include <socks/memblock.h>
 #include <stddef.h>
 #include <limits.h>
+#include <stdio.h>
 
-/* One vm_pg_data_t per NUMA node. Right now we're only worrying about a single node */
-static vm_pg_data_t node_data = {};
+/* One vm_pg_data_t per NUMA node. */
+static vm_pg_data_t *node_data = NULL;
 
-kern_status_t vm_bootstrap(const vm_region_t *mem_map, size_t nr_mem_map_entries)
+/* array of pages, one for each physical page frame present in RAM */
+static vm_page_t *page_array = NULL;
+
+kern_status_t vm_bootstrap()
 {
-	uintptr_t pmap_min = UINTPTR_MAX, pmap_max = 0x0;
+	int numa_count = 1;
 
-	for (size_t i = 0; i < nr_mem_map_entries; i++) {
-		if (mem_map[i].r_base < pmap_min) {
-			pmap_min = mem_map[i].r_base;
-		}
+	/* we're only worrying about UMA systems for now */
+	node_data = memblock_alloc(sizeof(vm_pg_data_t) * numa_count);
 
-		if (mem_map[i].r_limit > pmap_max) {
-			pmap_max = mem_map[i].r_limit;
+	size_t pmem_size = 0;
+
+	memblock_iter_t it;
+	for_each_mem_range (&it, 0x0, UINTPTR_MAX) {
+		if (pmem_size < it.it_limit + 1) {
+			pmem_size = it.it_limit + 1;
 		}
 	}
 
-	memblock_add(pmap_min, pmap_max);
+	size_t nr_pages = pmem_size / VM_PAGE_SIZE;
+	if (pmem_size % VM_PAGE_SIZE) {
+		nr_pages++;
+	}
 
+	page_array = memblock_alloc(sizeof(vm_page_t) * nr_pages);
+	printf("page_array covers 0x%zx bytes, %zu page frames\n", pmem_size, pmem_size / 0x1000);
+	printf("page_array is %zu bytes long\n", sizeof(vm_page_t) * nr_pages);
 
-	for (size_t i = 0; i < nr_mem_map_entries; i++) {
-		if (mem_map[i].r_status == VM_REGION_RESERVED) {
-			memblock_reserve(mem_map[i].r_base, mem_map[i].r_limit);
-		}
+	for (size_t i = 0; i < nr_pages; i++) {
+		vm_page_init(&page_array[i]);
 	}
 
 	return KERN_OK;

sandbox/vm/vm_page.c

@@ -0,0 +1,7 @@
+#include <socks/vm.h>
+#include <string.h>
+
+void vm_page_init(vm_page_t *pg)
+{
+	memset(pg, 0x0, sizeof *pg);
+}