diff --git a/sandbox/base/main.c b/sandbox/base/main.c index 9b57f35..63d0d80 100644 --- a/sandbox/base/main.c +++ b/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; } diff --git a/sandbox/base/memory_test.c b/sandbox/base/memory_test.c index 2a1aa7b..69c39a6 100644 --- a/sandbox/base/memory_test.c +++ b/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"); diff --git a/sandbox/vm/include/socks/vm.h b/sandbox/vm/include/socks/vm.h index 4a82716..15ee0c6 100644 --- a/sandbox/vm/include/socks/vm.h +++ b/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_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 diff --git a/sandbox/vm/vm_bootstrap.c b/sandbox/vm/vm_bootstrap.c index d2336e2..51495b2 100644 --- a/sandbox/vm/vm_bootstrap.c +++ b/sandbox/vm/vm_bootstrap.c @@ -4,41 +4,23 @@ #include #include #include +#include #include /* 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; diff --git a/sandbox/vm/vm_page.c b/sandbox/vm/vm_page.c index e606062..c78fba4 100644 --- a/sandbox/vm/vm_page.c +++ b/sandbox/vm/vm_page.c @@ -1,7 +1,87 @@ +#include +#include #include #include +#include -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]; } diff --git a/sandbox/vm/vm_zone.c b/sandbox/vm/vm_zone.c new file mode 100644 index 0000000..e0c4c42 --- /dev/null +++ b/sandbox/vm/vm_zone.c @@ -0,0 +1,40 @@ +#include +#include +#include +#include +#include + +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; + } +}