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

vm: zone: ensure memblock region bounds are page-aligned while creating zone blocks

Browse Source
This commit is contained in:
max 🍓
2026-02-21 11:01:58 +00:00
parent 9a90662eaa
commit 0bae39e550
1 changed files with 96 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
vm/zone.c
View File

@@ -1,14 +1,19 @@
#include <kernel/locks.h>
#include <kernel/util.h>
#include <kernel/queue.h>
#include <kernel/memblock.h>
#include <kernel/types.h>
#include <kernel/vm.h>
#include <kernel/printk.h>
#include <kernel/libc/string.h> #include <kernel/libc/string.h>
#include <kernel/locks.h>
#include <kernel/machine/cpu.h> #include <kernel/machine/cpu.h>
#include <kernel/memblock.h>
#include <kernel/panic.h>
#include <kernel/printk.h>
#include <kernel/queue.h>
#include <kernel/types.h>
#include <kernel/util.h>
#include <kernel/vm.h>
static struct vm_page *group_pages_into_block(struct vm_zone *z, phys_addr_t base, phys_addr_t limit, int order) static struct vm_page *group_pages_into_block(
struct vm_zone *z,
phys_addr_t base,
phys_addr_t limit,
int order)
{ {
struct vm_page *first_page = NULL; struct vm_page *first_page = NULL;
for (phys_addr_t i = base; i < limit; i += VM_PAGE_SIZE) { for (phys_addr_t i = base; i < limit; i += VM_PAGE_SIZE) {
@@ -37,16 +42,23 @@ static struct vm_page *group_pages_into_block(struct vm_zone *z, phys_addr_t bas
return first_page; return first_page;
} }
static void convert_region_to_blocks(struct vm_zone *zone, static void convert_region_to_blocks(
phys_addr_t base, phys_addr_t limit, struct vm_zone *zone,
phys_addr_t base,
phys_addr_t limit,
int reserved) int reserved)
{ {
if (base & VM_PAGE_MASK || (limit + 1) & VM_PAGE_MASK) {
panic("convert_region_to_blocks: region must be page-aligned");
}
size_t block_frames = vm_bytes_to_pages(limit - base + 1); size_t block_frames = vm_bytes_to_pages(limit - base + 1);
int reset_order = 0; int reset_order = 0;
for (int order = VM_PAGE_MAX_ORDER; order >= VM_PAGE_MIN_ORDER;) { for (int order = VM_PAGE_MAX_ORDER; order >= VM_PAGE_MIN_ORDER;) {
size_t order_frames = vm_page_order_to_pages(order); size_t order_frames = vm_page_order_to_pages(order);
vm_alignment_t order_alignment = vm_page_order_to_alignment(order); vm_alignment_t order_alignment
= vm_page_order_to_alignment(order);
if (order_frames > block_frames) { if (order_frames > block_frames) {
order--; order--;
@@ -59,11 +71,18 @@ static void convert_region_to_blocks(struct vm_zone *zone,
continue; continue;
} }
phys_addr_t block_limit = base + (order_frames * VM_PAGE_SIZE) - 1; phys_addr_t block_limit
struct vm_page *block_page = group_pages_into_block(zone, base, block_limit, order); = base + (order_frames * VM_PAGE_SIZE) - 1;
struct vm_page *block_page = group_pages_into_block(
zone,
base,
block_limit,
order);
if (reserved == 0) { if (reserved == 0) {
queue_push_back(&zone->z_free_pages[order], &block_page->p_list); queue_push_back(
&zone->z_free_pages[order],
&block_page->p_list);
} }
base = block_limit + 1; base = block_limit + 1;
@@ -83,10 +102,12 @@ static void convert_region_to_blocks(struct vm_zone *zone,
static size_t zone_free_bytes(struct vm_zone *z) static size_t zone_free_bytes(struct vm_zone *z)
{ {
size_t free_bytes = 0; size_t free_bytes = 0;
for (enum vm_page_order i = VM_PAGE_MIN_ORDER; i <= VM_PAGE_MAX_ORDER; i++) { for (enum vm_page_order i = VM_PAGE_MIN_ORDER; i <= VM_PAGE_MAX_ORDER;
i++) {
size_t page_bytes = vm_page_order_to_bytes(i); size_t page_bytes = vm_page_order_to_bytes(i);
size_t nr_pages = 0; size_t nr_pages = 0;
queue_foreach (struct vm_page, pg, &z->z_free_pages[i], p_list) { queue_foreach(struct vm_page, pg, &z->z_free_pages[i], p_list)
{
free_bytes += page_bytes; free_bytes += page_bytes;
nr_pages++; nr_pages++;
} }
@@ -106,24 +127,37 @@ void vm_zone_init(struct vm_zone *z, const struct vm_zone_descriptor *zone_info)
struct memblock_iter it; struct memblock_iter it;
/* TODO this only creates page blocks for free memory regions, not reserved memory regions. /* TODO this only creates page blocks for free memory regions, not
* this is faster for systems that have huge amounts of reserved memory, but it means * reserved memory regions. this is faster for systems that have huge
* that a call to vm_page_get() for a reserved memory region will return null * amounts of reserved memory, but it means that a call to vm_page_get()
* rather than a reserved page. * for a reserved memory region will return null rather than a reserved
* page.
* *
* vm_page_get() should probably create reserved pages on-demand for these regions. */ * vm_page_get() should probably create reserved pages on-demand for
* these regions. */
size_t nr_pages_found = 0; size_t nr_pages_found = 0;
for_each_free_mem_range(&it, z->z_info.zd_base, z->z_info.zd_limit) { for_each_free_mem_range(&it, z->z_info.zd_base, z->z_info.zd_limit)
{
it.it_base &= ~VM_PAGE_MASK;
if (it.it_limit & VM_PAGE_MASK) {
it.it_limit &= ~VM_PAGE_MASK;
it.it_limit += VM_PAGE_SIZE;
}
phys_addr_t block_start = it.it_base, block_end = it.it_limit; phys_addr_t block_start = it.it_base, block_end = it.it_limit;
int this_page_reserved = 0, last_page_reserved = -1; int this_page_reserved = 0, last_page_reserved = -1;
for (uintptr_t i = it.it_base; i < it.it_limit; i += VM_PAGE_SIZE) { for (uintptr_t i = it.it_base; i < it.it_limit;
i += VM_PAGE_SIZE) {
struct vm_page *pg = vm_page_get(i); struct vm_page *pg = vm_page_get(i);
if (pg) { if (pg) {
nr_pages_found++; nr_pages_found++;
this_page_reserved = (pg->p_flags & VM_PAGE_RESERVED) ? 1 : 0; this_page_reserved
= (pg->p_flags & VM_PAGE_RESERVED) ? 1
: 0;
} else { } else {
this_page_reserved = 1; this_page_reserved = 1;
} }
@@ -139,20 +173,28 @@ void vm_zone_init(struct vm_zone *z, const struct vm_zone_descriptor *zone_info)
convert_region_to_blocks( convert_region_to_blocks(
z, z,
block_start, block_end + VM_PAGE_SIZE - 1, block_start,
block_end + VM_PAGE_SIZE - 1,
last_page_reserved); last_page_reserved);
block_start = i; block_start = i;
if (block_start & VM_PAGE_MASK) {
block_start &= ~VM_PAGE_MASK;
block_start += VM_PAGE_SIZE;
}
last_page_reserved = this_page_reserved; last_page_reserved = this_page_reserved;
nr_pages_found = 0;
} }
if (block_start != block_end) { if (block_start != block_end) {
/* either the entire zone is homogeneous (all free/all reserved) or the entire zone is empty. */ /* either the entire zone is homogeneous (all free/all
* reserved) or the entire zone is empty. */
if (nr_pages_found > 0) { if (nr_pages_found > 0) {
/* the entire zone is homogeneous :) */ /* the entire zone is homogeneous :) */
convert_region_to_blocks( convert_region_to_blocks(
z, z,
block_start, block_end + VM_PAGE_SIZE - 1, block_start,
block_end + VM_PAGE_SIZE - 1,
this_page_reserved); this_page_reserved);
} }
} }
@@ -201,7 +243,10 @@ void vm_zone_init(struct vm_zone *z, const struct vm_zone_descriptor *zone_info)
char free_bytes_str[64]; char free_bytes_str[64];
data_size_to_string(free_bytes, free_bytes_str, sizeof free_bytes_str); data_size_to_string(free_bytes, free_bytes_str, sizeof free_bytes_str);
printk("vm: zone %u/%s: %s of memory online.", z->z_info.zd_node, z->z_info.zd_name, free_bytes_str); printk("vm: zone %u/%s: %s of memory online.",
z->z_info.zd_node,
z->z_info.zd_name,
free_bytes_str);
} }
static int replenish_free_page_list(struct vm_zone *z, enum vm_page_order order) static int replenish_free_page_list(struct vm_zone *z, enum vm_page_order order)
@@ -216,7 +261,8 @@ static int replenish_free_page_list(struct vm_zone *z, enum vm_page_order order)
return -1; return -1;
} }
/* the lowest page order that is >= `order` and still has pages available */ /* the lowest page order that is >= `order` and still has pages
* available */
enum vm_page_order first_order_with_free = VM_MAX_PAGE_ORDERS; enum vm_page_order first_order_with_free = VM_MAX_PAGE_ORDERS;
for (enum vm_page_order i = order; i <= VM_PAGE_MAX_ORDER; i++) { for (enum vm_page_order i = order; i <= VM_PAGE_MAX_ORDER; i++) {
@@ -232,7 +278,8 @@ static int replenish_free_page_list(struct vm_zone *z, enum vm_page_order order)
} }
if (first_order_with_free == order) { if (first_order_with_free == order) {
/* there are free pages of the requested order, so nothing needs to be done */ /* there are free pages of the requested order, so nothing needs
* to be done */
return 0; return 0;
} }
@@ -240,8 +287,10 @@ static int replenish_free_page_list(struct vm_zone *z, enum vm_page_order order)
take a page, split it in half, and add the sub-pages take a page, split it in half, and add the sub-pages
to the next order's free list. */ to the next order's free list. */
for (enum vm_page_order i = first_order_with_free; i > order; i--) { for (enum vm_page_order i = first_order_with_free; i > order; i--) {
struct queue_entry *pg_entry = queue_pop_front(&z->z_free_pages[i]); struct queue_entry *pg_entry
struct vm_page *pg = QUEUE_CONTAINER(struct vm_page, p_list, pg_entry); = queue_pop_front(&z->z_free_pages[i]);
struct vm_page *pg
= QUEUE_CONTAINER(struct vm_page, p_list, pg_entry);
struct vm_page *a, *b; struct vm_page *a, *b;
vm_page_split(pg, &a, &b); vm_page_split(pg, &a, &b);
@@ -253,7 +302,10 @@ static int replenish_free_page_list(struct vm_zone *z, enum vm_page_order order)
return 0; return 0;
} }
struct vm_page *vm_zone_alloc_page(struct vm_zone *z, enum vm_page_order order, enum vm_flags flags) struct vm_page *vm_zone_alloc_page(
struct vm_zone *z,
enum vm_page_order order,
enum vm_flags flags)
{ {
unsigned long irq_flags; unsigned long irq_flags;
spin_lock_irqsave(&z->z_lock, &irq_flags); spin_lock_irqsave(&z->z_lock, &irq_flags);
@@ -266,7 +318,8 @@ struct vm_page *vm_zone_alloc_page(struct vm_zone *z, enum vm_page_order order,
struct queue_entry *pg_entry = queue_pop_front(&z->z_free_pages[order]); struct queue_entry *pg_entry = queue_pop_front(&z->z_free_pages[order]);
struct vm_page *pg = QUEUE_CONTAINER(struct vm_page, p_list, pg_entry); struct vm_page *pg = QUEUE_CONTAINER(struct vm_page, p_list, pg_entry);
vm_page_foreach (pg, i) { vm_page_foreach(pg, i)
{
i->p_flags |= VM_PAGE_ALLOC; i->p_flags |= VM_PAGE_ALLOC;
} }
@@ -289,7 +342,9 @@ void vm_zone_free_page(struct vm_zone *z, struct vm_page *pg)
break; break;
} }
queue_delete(&z->z_free_pages[buddy->p_order - 1], &buddy->p_list); queue_delete(
&z->z_free_pages[buddy->p_order - 1],
&buddy->p_list);
queue_delete(&z->z_free_pages[buddy->p_order - 1], &pg->p_list); queue_delete(&z->z_free_pages[buddy->p_order - 1], &pg->p_list);
queue_push_back(&z->z_free_pages[huge->p_order], &huge->p_list); queue_push_back(&z->z_free_pages[huge->p_order], &huge->p_list);