wash/mango
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sandbox: vm: organise pages into zoned blocks

Browse Source
This commit is contained in:
max 🍓
2023-01-28 19:24:28 +00:00
parent 0227cb822b
commit d0341a5e35
6 changed files with 188 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
sandbox/vm/include/socks/vm.h
View File

@@ -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_NORMAL = 2u,
VM_ZONE_HIGHMEM = 3u,
VM_ZONE_COUNT
VM_ZONE_DMA = 1u,
VM_ZONE_NORMAL = 2u,
VM_ZONE_HIGHMEM = 3u,
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 */
queue_entry_t p_buddy_list;
/* buddy allocator free page list head (vm_zone_t->z_free_pages[p_order]) */
queue_entry_t p_free_list;
/* order of the page block that this page belongs too */
unsigned int p_order;
} __attribute__((packed)) vm_page_t;
unsigned char p_order;
} __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

28
sandbox/vm/vm_bootstrap.c
View File

@@ -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 */
static vm_page_t *page_array = NULL;
kern_status_t vm_bootstrap()
kern_status_t vm_bootstrap(const vm_zone_descriptor_t *zones, size_t nr_zones)
{
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_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);
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]);
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);
}
return KERN_OK;

84
sandbox/vm/vm_page.c
View File

@@ -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];
}

40
sandbox/vm/vm_zone.c Normal file
View File

@@ -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;
}
}