sandbox: vm: organise pages into zoned blocks

sandbox/base/main.c

@@ -16,6 +16,6 @@ extern int queue_test(void);
 
 int main(int argc, const char **argv)
 {
-	queue_test();
+	memory_test();
 	return 0;
 }

sandbox/base/memory_test.c

@@ -95,7 +95,13 @@ int memory_test(void)
 		printf("allocated %d bytes at 0x%" PRIxPTR "\n", size, alloc);
 	}
 
-	vm_bootstrap();
+	vm_zone_descriptor_t zones[] = {
+		{ .zd_id = VM_ZONE_DMA, .zd_name = "dma", .zd_base = 0x0, .zd_limit = MB_TO_BYTES(16) - 1 },
+		{ .zd_id = VM_ZONE_NORMAL, .zd_name = "normal", .zd_base = MB_TO_BYTES(16), .zd_limit = MB_TO_BYTES(1024) - 1 },
+		{ .zd_id = VM_ZONE_HIGHMEM, .zd_name = "highmem", .zd_base = MB_TO_BYTES(1024), .zd_limit = UINTPTR_MAX },
+	};
+
+	vm_bootstrap(zones, sizeof zones / sizeof zones[0]);
 
 	printf("memory regions:\n");
 

sandbox/vm/include/socks/vm.h

@@ -8,13 +8,40 @@
 
 #define VM_PAGE_SIZE 0x1000
 
+typedef struct vm_object {
+	unsigned int reserved;
+} vm_object_t;
+
 typedef enum vm_zone_id {
-	VM_ZONE_DMA		= 1u,
+	VM_ZONE_DMA             = 1u,
-	VM_ZONE_NORMAL		= 2u,
+	VM_ZONE_NORMAL          = 2u,
-	VM_ZONE_HIGHMEM		= 3u,
+	VM_ZONE_HIGHMEM         = 3u,
-	VM_ZONE_COUNT
+	VM_ZONE_COUNT           = VM_ZONE_HIGHMEM,
 } vm_zone_id_t;
 
+typedef enum vm_page_order {
+	VM_PAGE_4K = 0u,
+	VM_PAGE_8K,
+	VM_PAGE_16K,
+	VM_PAGE_32K,
+	VM_PAGE_64K,
+	VM_PAGE_128K,
+	VM_PAGE_256K,
+	VM_PAGE_512K,
+	VM_PAGE_1M,
+	VM_PAGE_2M,
+	VM_PAGE_4M,
+	VM_PAGE_8M,
+	VM_PAGE_16M,
+	VM_PAGE_32M,
+	VM_PAGE_64M,
+	VM_PAGE_128M,
+	VM_PAGE_256M,
+	VM_PAGE_512M,
+	VM_PAGE_1G,
+	VM_PAGE_MAX_ORDER = VM_PAGE_1G,
+} vm_page_order_t;
+
 typedef enum vm_memory_region_status {
 	VM_REGION_FREE		= 0x01u,
 	VM_REGION_RESERVED	= 0x02u,
@@ -22,12 +49,16 @@ typedef enum vm_memory_region_status {
 
 typedef struct vm_zone_descriptor {
 	vm_zone_id_t zd_id;
+	const char *zd_name;
 	phys_addr_t zd_base;
 	phys_addr_t zd_limit;
 } vm_zone_descriptor_t;
 
 typedef struct vm_zone {
-	unsigned char z_reserved[32];
+	queue_t z_free_pages[VM_PAGE_MAX_ORDER + 1];
+
+	const char *z_name;
+	unsigned long z_size;
 } vm_zone_t;
 
 typedef struct vm_pg_data {
@@ -41,21 +72,31 @@ typedef struct vm_region {
 } vm_region_t;
 
 typedef enum vm_page_flags {
-	VM_PAGE_RESERVED = 0x01u,
+	/* page is reserved (probably by a call to memblock_reserve()) and cannot be
+	   returned by any allocation function */
+	VM_PAGE_RESERVED   = 0x01u,
+	/* page is the first page of a huge-page */
+	VM_PAGE_HEAD       = 0x02u,
+	/* page is part of a huge-page */
+	VM_PAGE_HUGE       = 0x04u,
 } vm_page_flags_t;
 
 typedef struct vm_page {
 	uint32_t p_flags; /* vm_page_flags_t bitfield */
 
-	/* buddy allocator free page list head */
+	/* buddy allocator free page list head (vm_zone_t->z_free_pages[p_order]) */
-	queue_entry_t p_buddy_list;
+	queue_entry_t p_free_list;
 
 	/* order of the page block that this page belongs too */
-	unsigned int p_order;
+	unsigned char p_order;
-} __attribute__((packed)) vm_page_t;
+} __attribute__((aligned(2 * sizeof(unsigned long)))) vm_page_t;
 
-extern kern_status_t vm_bootstrap(void);
+extern kern_status_t vm_bootstrap(const vm_zone_descriptor_t *zones, size_t nr_zones);
 
-extern void vm_page_init(vm_page_t *pg);
+extern void vm_page_init_array();
+extern vm_page_t *vm_page_get(phys_addr_t addr);
+extern size_t vm_page_order_to_bytes(vm_page_order_t order);
+
+extern void vm_zone_init(vm_zone_t *z, const char *name, uintptr_t base, uintptr_t limit);
 
 #endif

sandbox/vm/vm_bootstrap.c

@@ -4,41 +4,23 @@
 #include <socks/memblock.h>
 #include <stddef.h>
 #include <limits.h>
+#include <stdint.h>
 #include <stdio.h>
 
 /* One vm_pg_data_t per NUMA node. */
 static vm_pg_data_t *node_data = NULL;
 
-/* array of pages, one for each physical page frame present in RAM */
+kern_status_t vm_bootstrap(const vm_zone_descriptor_t *zones, size_t nr_zones)
-static vm_page_t *page_array = NULL;
-
-kern_status_t vm_bootstrap()
 {
 	int numa_count = 1;
 
 	/* we're only worrying about UMA systems for now */
 	node_data = memblock_alloc(sizeof(vm_pg_data_t) * numa_count);
 
-	size_t pmem_size = 0;
+	vm_page_init_array();
 
-	memblock_iter_t it;
+	for (size_t i = 0; i < nr_zones; i++) {
-	for_each_mem_range (&it, 0x0, UINTPTR_MAX) {
+		vm_zone_init(&node_data->pg_zones[zones[i].zd_id], zones[i].zd_name, zones[i].zd_base, zones[i].zd_limit);
-		if (pmem_size < it.it_limit + 1) {
-			pmem_size = it.it_limit + 1;
-		}
-	}
-
-	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_pages; i++) {
-		vm_page_init(&page_array[i]);
 	}
 
 	return KERN_OK;

sandbox/vm/vm_page.c

@@ -1,7 +1,87 @@
+#include <socks/types.h>
+#include <socks/memblock.h>
 #include <socks/vm.h>
 #include <string.h>
+#include <stdio.h>
 
-void vm_page_init(vm_page_t *pg)
+/* array of pages, one for each physical page frame present in RAM */
+static vm_page_t *page_array = NULL;
+
+/* number of pages stored in page_array */
+static size_t page_array_count = 0;
+
+/* Pre-calculated page order -> size conversion table */
+static size_t page_order_bytes[] = {
+	[VM_PAGE_4K]   = 0x1000,
+	[VM_PAGE_8K]   = 0x2000,
+	[VM_PAGE_16K]  = 0x4000,
+	[VM_PAGE_32K]  = 0x8000,
+	[VM_PAGE_64K]  = 0x10000,
+	[VM_PAGE_128K] = 0x20000,
+	[VM_PAGE_256K] = 0x40000,
+	[VM_PAGE_512K] = 0x80000,
+	[VM_PAGE_1M]   = 0x100000,
+	[VM_PAGE_2M]   = 0x200000,
+	[VM_PAGE_4M]   = 0x400000,
+	[VM_PAGE_8M]   = 0x800000,
+	[VM_PAGE_16M]  = 0x1000000,
+	[VM_PAGE_32M]  = 0x2000000,
+	[VM_PAGE_64M]  = 0x4000000,
+	[VM_PAGE_128M] = 0x8000000,
+	[VM_PAGE_256M] = 0x10000000,
+	[VM_PAGE_512M] = 0x20000000,
+	[VM_PAGE_1G]   = 0x40000000,
+};
+
+void vm_page_init_array()
 {
-	memset(pg, 0x0, sizeof *pg);
+	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;
+		}
+	}
+
+	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);
+	page_array_count = nr_pages;
+	printf("page_array covers 0x%zx bytes, %zu page frames\n", pmem_size, pmem_size / VM_PAGE_SIZE);
+	printf("page_array is %zu bytes long\n", sizeof(vm_page_t) * nr_pages);
+
+	for (size_t i = 0; i < nr_pages; i++) {
+		memset(&page_array[i], 0x0, sizeof page_array[i]);
+	}
+
+	size_t nr_reserved = 0;
+	for_each_reserved_mem_range(&it, 0x0, UINTPTR_MAX) {
+		for (uintptr_t i = it.it_base; i < it.it_limit; i += VM_PAGE_SIZE) {
+			size_t pfn = i / VM_PAGE_SIZE;
+
+			page_array[pfn].p_flags |= VM_PAGE_RESERVED;
+			nr_reserved++;
+		}
+	}
+
+	printf("%zu reserved page frames\n", nr_reserved);
+}
+
+vm_page_t *vm_page_get(phys_addr_t addr)
+{
+	size_t pfn = addr / VM_PAGE_SIZE;
+	return pfn < page_array_count ? &page_array[pfn] : NULL;
+}
+
+size_t vm_page_order_to_bytes(vm_page_order_t order)
+{
+	if (order < 0 || order > VM_PAGE_MAX_ORDER) {
+		return 0;
+	}
+
+	return page_order_bytes[order];
 }

sandbox/vm/vm_zone.c

@@ -0,0 +1,40 @@
+#include <socks/types.h>
+#include <socks/vm.h>
+#include <string.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+void vm_zone_init(vm_zone_t *z, const char *name, uintptr_t base, uintptr_t limit)
+{
+	memset(z, 0x0, sizeof *z);
+	z->z_name = name;
+
+	phys_addr_t block_start = 0;
+	int last_page_reserved = -1;
+	for (uintptr_t i = base; i < limit; i += VM_PAGE_SIZE) {
+		vm_page_t *pg = vm_page_get(i);
+		if (!pg) {
+			break;
+		}
+		
+		int this_page_reserved = (pg->p_flags & VM_PAGE_RESERVED) ? 1 : 0;
+
+		if (last_page_reserved == -1) {
+			last_page_reserved = this_page_reserved;
+		}
+
+		if (this_page_reserved == last_page_reserved) {
+			continue;
+		}
+
+		printf("%s: %zu %s pages at %" PRIxPTR "\n",
+		       name,
+		       (i - block_start) / VM_PAGE_SIZE,
+		       this_page_reserved == 1 ? "reserved" : "free",
+		       block_start);
+		
+		block_start = i;
+		vm_page_order_t order = VM_PAGE_MAX_ORDER;
+		last_page_reserved = this_page_reserved;
+	}
+}