sandbox: vm: fix incorrect region/zone limit addresses

sandbox/vm/include/socks/vm.h

@@ -55,15 +55,16 @@ typedef enum vm_memory_region_status {
 
 typedef struct vm_zone_descriptor {
 	vm_zone_id_t zd_id;
-	const char *zd_name;
+	unsigned int zd_node;
+	const char zd_name[32];
 	phys_addr_t zd_base;
 	phys_addr_t zd_limit;
 } vm_zone_descriptor_t;
 
 typedef struct vm_zone {
-	queue_t z_free_pages[VM_PAGE_MAX_ORDER + 1];
+	vm_zone_descriptor_t z_info;
 
-	const char *z_name;
+	queue_t z_free_pages[VM_PAGE_MAX_ORDER + 1];
 	unsigned long z_size;
 } vm_zone_t;
 
@@ -88,17 +89,25 @@ typedef enum vm_page_flags {
 } vm_page_flags_t;
 
 typedef struct vm_page {
-	uint32_t p_flags; /* vm_page_flags_t bitfield */
+	/* vm_page_flags_t bitfields.
+	   the 2 most significant bits of this field encode the ID of the vm_zone that
+	   the page belongs to */
+	uint32_t p_flags;
 
 	/* buddy allocator free page list head (vm_zone_t->z_free_pages[p_order]) */
 	queue_entry_t p_free_list;
 
+	/* temporary */
+	vm_zone_t *p_zone;
+
 	/* order of the page block that this page belongs too */
 	unsigned char p_order;
 } __attribute__((aligned(2 * sizeof(unsigned long)))) vm_page_t;
 
 extern kern_status_t vm_bootstrap(const vm_zone_descriptor_t *zones, size_t nr_zones);
 
+extern vm_pg_data_t *vm_pg_data_get(int node);
+
 extern void vm_page_init_array();
 extern vm_page_t *vm_page_get(phys_addr_t addr);
 extern phys_addr_t vm_page_get_paddr(vm_page_t *pg);
@@ -111,6 +120,6 @@ extern vm_alignment_t vm_page_order_to_alignment(vm_page_order_t order);
 
 extern size_t vm_bytes_to_pages(size_t bytes);
 
-extern void vm_zone_init(vm_zone_t *z, const char *name, uintptr_t base, uintptr_t limit);
+extern void vm_zone_init(vm_zone_t *z, const vm_zone_descriptor_t *zone_info);
 
 #endif

sandbox/vm/vm_bootstrap.c

@@ -20,8 +20,17 @@ kern_status_t vm_bootstrap(const vm_zone_descriptor_t *zones, size_t nr_zones)
 	vm_page_init_array();
 
 	for (size_t i = 0; i < nr_zones; i++) {
-		vm_zone_init(&node_data->pg_zones[zones[i].zd_id], zones[i].zd_name, zones[i].zd_base, zones[i].zd_limit);
+		vm_zone_init(&node_data->pg_zones[zones[i].zd_id],  &zones[i]);
 	}
 
 	return KERN_OK;
 }
+
+vm_pg_data_t *vm_pg_data_get(int node)
+{
+	if (node == 0) {
+		return node_data;
+	}
+
+	return NULL;
+}

sandbox/vm/vm_zone.c

@@ -1,14 +1,39 @@
+#include "socks/queue.h"
 #include <socks/types.h>
 #include <socks/vm.h>
 #include <string.h>
 #include <stdio.h>
 #include <inttypes.h>
+#include <assert.h>
 #include <stdlib.h>
 
+static vm_page_t *group_pages_into_block(vm_zone_t *z, phys_addr_t base, phys_addr_t limit, int order)
+{
+	vm_page_t *first_page = NULL;
+	for (phys_addr_t i = base; i < limit; i += VM_PAGE_SIZE) {
+		vm_page_t *pg = vm_page_get(i);
+
+		if (order != VM_PAGE_MIN_ORDER) {
+			pg->p_flags |= VM_PAGE_HUGE;
+		}
+
+		if (i == base) {
+			pg->p_flags |= VM_PAGE_HEAD;
+			first_page = pg;
+		}
+
+		pg->p_order = order;
+		pg->p_zone = z;
+	}
+
+	return first_page;
+}
+
 static void convert_region_to_blocks(vm_zone_t *zone, phys_addr_t base, phys_addr_t limit, int reserved)
 {
-	size_t block_frames = vm_bytes_to_pages(limit - base);
+	size_t block_frames = vm_bytes_to_pages(limit - base + 1);
-	printf("adding region %08zx-%08zx (%zu frames) to zone %s\n", base, limit, block_frames, zone->z_name);
+	printf("adding region %08zx-%08zx (%zu frames) to zone %s\n",
+	       base, limit, block_frames, zone->z_info.zd_name);
 	int reset_order = 0;
 
 	for (int order = VM_PAGE_MAX_ORDER; order >= VM_PAGE_MIN_ORDER; ) {
@@ -27,12 +52,19 @@ static void convert_region_to_blocks(vm_zone_t *zone, phys_addr_t base, phys_add
 		}
 		
 		printf("%s: %zu %s pages at %08" PRIxPTR "\n",
-		       zone->z_name,
+		       zone->z_info.zd_name,
 		       order_frames,
 		       reserved == 1 ? "reserved" : "free",
 		       base);
 		
-		base += order_frames * VM_PAGE_SIZE;
+		phys_addr_t block_limit = base + (order_frames * VM_PAGE_SIZE) - 1;
+		vm_page_t *block_page = group_pages_into_block(zone, base, block_limit, order);
+
+		if (reserved == 0) {
+			queue_push_back(&zone->z_free_pages[order], &block_page->p_free_list);
+		}
+
+		base = block_limit + 1;
 		block_frames -= order_frames;
 
 		if (reset_order) {
@@ -42,8 +74,8 @@ static void convert_region_to_blocks(vm_zone_t *zone, phys_addr_t base, phys_add
 			order--;
 		}
 
-		if (base > limit) {
+		if (base > limit + 1) {
-			printf("too many pages created!\n");
+			printf("too many pages created! %zx > %zx\n", base, limit);
 			abort();
 		} 
 
@@ -53,15 +85,21 @@ static void convert_region_to_blocks(vm_zone_t *zone, phys_addr_t base, phys_add
 	}
 }
 
-void vm_zone_init(vm_zone_t *z, const char *name, uintptr_t base, uintptr_t limit)
+void vm_zone_init(vm_zone_t *z, const vm_zone_descriptor_t *zone_info)
 {
-	printf("initialising zone %s (%08zx-%08zx)\n", name, base, limit);
+	if (!vm_page_get(zone_info->zd_base)) {
+		return;
+	}
+	
+	printf("initialising zone %s (%08zx-%08zx)\n",
+	       zone_info->zd_name, zone_info->zd_base, zone_info->zd_limit);
 	memset(z, 0x0, sizeof *z);
-	z->z_name = name;
+	memcpy(&z->z_info, zone_info, sizeof *zone_info);
 
-	phys_addr_t block_start = base, block_end = base;
+	phys_addr_t block_start = zone_info->zd_base, block_end = zone_info->zd_limit;
 	int this_page_reserved = 0, last_page_reserved = -1;
-	for (uintptr_t i = base; i < limit; i += VM_PAGE_SIZE) {
+
+	for (uintptr_t i = zone_info->zd_base; i < zone_info->zd_limit; i += VM_PAGE_SIZE) {
 		vm_page_t *pg = vm_page_get(i);
 		if (!pg) {
 			break;
@@ -78,13 +116,13 @@ void vm_zone_init(vm_zone_t *z, const char *name, uintptr_t base, uintptr_t limi
 			continue;
 		}
 
-		convert_region_to_blocks(z, block_start, i, last_page_reserved);
+		convert_region_to_blocks(z, block_start, block_end + VM_PAGE_SIZE - 1, last_page_reserved);
 
 		block_start = i;
 		last_page_reserved = this_page_reserved;
 	}
 
 	if (block_start != block_end) {
-		convert_region_to_blocks(z, block_start, block_end, this_page_reserved);
+		convert_region_to_blocks(z, block_start, block_end + VM_PAGE_SIZE - 1, this_page_reserved);
 	}
 }