memblock can now self re-allocate its internal buffers

memory allocated by memblock_alloc() can now be limited to a certain region.

sandbox/memblock/memblock.c

@@ -1,3 +1,4 @@
+#include "socks/types.h"
 #include <stdio.h>
 #include <stdbool.h>
 #include <limits.h>
@@ -20,6 +21,8 @@
 static memblock_region_t init_memory_regions[MEMBLOCK_INIT_MEMORY_REGION_COUNT];
 static memblock_region_t init_reserved_regions[MEMBLOCK_INIT_RESERVED_REGION_COUNT];
 
+static phys_addr_t do_alloc(size_t size);
+
 memblock_t memblock = {
 	.memory.regions = init_memory_regions,
 	.memory.count = 0,
@@ -32,6 +35,19 @@ memblock_t memblock = {
 	.reserved.name = "reserved",
 };
 
+static void memblock_double_capacity(memblock_type_t *type)
+{
+	size_t new_max = type->max * 2;
+
+	phys_addr_t new_regions_p = do_alloc(new_max * sizeof(memblock_region_t));
+
+	void *new_regions = (void *)(new_regions_p + memblock.m_voffset);
+	memcpy(new_regions, type->regions, type->count * sizeof(memblock_region_t));
+
+	type->regions = new_regions;
+	type->max = new_max;
+}
+
 static int memblock_insert_region(memblock_type_t *type, memblock_region_t *to_add)
 {
 	unsigned int i = 0;
@@ -71,6 +87,15 @@ static int memblock_remove_region(memblock_type_t *type, unsigned int i)
 	return 0;
 }
 
+int memblock_init(uintptr_t alloc_start, uintptr_t alloc_end, uintptr_t voffset)
+{
+	memblock.m_alloc_start = alloc_start;
+	memblock.m_alloc_end =alloc_end;
+	memblock.m_voffset = voffset;
+
+	return 0;
+}
+
 int memblock_add_range(memblock_type_t *type, uintptr_t base, size_t size, memblock_region_status_t status)
 {
 	if (size == 0) {
@@ -163,20 +188,35 @@ int memblock_add_range(memblock_type_t *type, uintptr_t base, size_t size, membl
 
 int memblock_add(uintptr_t base, size_t size)
 {
+	if (memblock.memory.count >= memblock.memory.max - 2) {
+		if (memblock.reserved.count >= memblock.reserved.max - 2) {
+			memblock_double_capacity(&memblock.reserved);
+		}
+		
+		memblock_double_capacity(&memblock.memory);
+	}
+
 	return memblock_add_range(&memblock.memory, base, size, MEMBLOCK_MEMORY);
 }
 
 int memblock_reserve(uintptr_t base, size_t size)
 {
+	if (memblock.reserved.count >= memblock.reserved.max - 2) {
+		memblock_double_capacity(&memblock.reserved);
+	}
+		
 	return memblock_add_range(&memblock.reserved, base, size, MEMBLOCK_RESERVED);
 }
 
-phys_addr_t memblock_alloc(size_t size)
+static phys_addr_t do_alloc(size_t size)
 {
 	phys_addr_t allocated_base = ADDR_MAX;
 
+	phys_addr_t region_start = memblock.m_alloc_start - memblock.m_voffset;
+	phys_addr_t region_end = memblock.m_alloc_end - memblock.m_voffset;
+
 	memblock_iter_t it;
-	for_each_free_mem_range (&it, 0x0, ADDR_MAX) {
+	for_each_free_mem_range (&it, region_start, region_end) {
 		size_t region_size = it.it_limit - it.it_base + 1;
 		if (region_size >= size) {
 			allocated_base = it.it_base;
@@ -196,6 +236,15 @@ phys_addr_t memblock_alloc(size_t size)
 	return allocated_base;
 }
 
+phys_addr_t memblock_alloc(size_t size)
+{
+	if (memblock.reserved.count >= memblock.reserved.max - 2) {
+		memblock_double_capacity(&memblock.reserved);
+	}
+
+	return do_alloc(size);
+}
+
 int memblock_free(phys_addr_t addr, size_t size)
 {
 	return 0;