From c0c930e5a93f0afa204f4bd89d7888019a68bc91 Mon Sep 17 00:00:00 2001 From: Max Wash Date: Sun, 29 Jan 2023 20:10:15 +0000 Subject: [PATCH] sandbox: vm: fix incorrect region/zone limit addresses --- sandbox/vm/include/socks/vm.h | 19 ++++++++--- sandbox/vm/vm_bootstrap.c | 11 +++++- sandbox/vm/vm_zone.c | 64 ++++++++++++++++++++++++++++------- 3 files changed, 75 insertions(+), 19 deletions(-) diff --git a/sandbox/vm/include/socks/vm.h b/sandbox/vm/include/socks/vm.h index 96ad17e..03ba261 100644 --- a/sandbox/vm/include/socks/vm.h +++ b/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 diff --git a/sandbox/vm/vm_bootstrap.c b/sandbox/vm/vm_bootstrap.c index 51495b2..c9c133d 100644 --- a/sandbox/vm/vm_bootstrap.c +++ b/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; +} diff --git a/sandbox/vm/vm_zone.c b/sandbox/vm/vm_zone.c index 13dbf86..e28a86a 100644 --- a/sandbox/vm/vm_zone.c +++ b/sandbox/vm/vm_zone.c @@ -1,14 +1,39 @@ +#include "socks/queue.h" #include #include #include #include #include +#include #include +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); - printf("adding region %08zx-%08zx (%zu frames) to zone %s\n", base, limit, block_frames, zone->z_name); + 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_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) { - printf("too many pages created!\n"); + if (base > limit + 1) { + 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); } }