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

kernel: adjust formatting

Browse Source
This commit is contained in:
max 🍓
2026-02-08 12:17:27 +00:00
parent 49a75a1bbe
commit 0490541dc9
14 changed files with 478 additions and 320 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
vm/sparse.c
View File

@@ -22,13 +22,13 @@
of the sparse memory model may be outweighed by the extra
overhead, and the flat memory model may be a better choice.
*/
#include <mango/vm.h>
#include <mango/arg.h>
#include <mango/printk.h>
#include <mango/panic.h>
#include <mango/memblock.h>
#include <mango/util.h>
#include <mango/machine/cpu.h>
#include <mango/memblock.h>
#include <mango/panic.h>
#include <mango/printk.h>
#include <mango/util.h>
#include <mango/vm.h>
static struct vm_sector *sector_array = NULL;
static size_t sector_array_count = 0;
@@ -53,11 +53,16 @@ static enum sector_coverage_mode get_sector_coverage_mode(void)
return SECTOR_COVERAGE_ALL;
}
printk("vm: [sparse] ignoring unknown sector coverage mode '%s', using FREE", arg);
printk("vm: [sparse] ignoring unknown sector coverage mode '%s', using "
"FREE",
arg);
return SECTOR_COVERAGE_FREE;
}
static struct vm_sector *phys_addr_to_sector_and_index(phys_addr_t addr, size_t *sector_id, size_t *index)
static struct vm_sector *phys_addr_to_sector_and_index(
phys_addr_t addr,
size_t *sector_id,
size_t *index)
{
/* all sectors have the same size */
size_t step = vm_page_order_to_bytes(sector_array[0].s_size);
@@ -98,7 +103,6 @@ static struct vm_page *get_or_create_page(phys_addr_t addr)
}
}
sector->s_pages[page_number].p_sector = sector_number;
return &sector->s_pages[page_number];
}
@@ -123,9 +127,13 @@ static enum vm_page_order find_minimum_sector_size(phys_addr_t pmem_end)
are in need of improvement to ensure that sparse works well on a wide
range of systems. */
static void calculate_sector_size_and_count(
size_t last_reserved_pfn, size_t last_free_pfn, size_t limit_pfn,
size_t reserved_size, size_t free_size,
unsigned int *out_sector_count, enum vm_page_order *out_sector_size)
size_t last_reserved_pfn,
size_t last_free_pfn,
size_t limit_pfn,
size_t reserved_size,
size_t free_size,
unsigned int *out_sector_count,
enum vm_page_order *out_sector_size)
{
/* we can support up to VM_MAX_SECTORS memory sectors.
the minimum sector size is what ever is required
@@ -154,8 +162,8 @@ static void calculate_sector_size_and_count(
threshold. */
sector_size++;
/* if the difference is particularly big, increase the sector size
even further */
/* if the difference is particularly big, increase the sector
size even further */
if (memdiff >= 0x1000000) {
sector_size++;
}
@@ -183,13 +191,15 @@ void vm_sparse_init(void)
size_t last_reserved_pfn = 0, last_free_pfn = 0;
struct memblock_iter it;
for_each_mem_range (&it, 0x0, UINTPTR_MAX) {
for_each_mem_range(&it, 0x0, UINTPTR_MAX)
{
if (pmem_limit < it.it_limit + 1) {
pmem_limit = it.it_limit + 1;
}
}
for_each_free_mem_range (&it, 0x0, UINTPTR_MAX) {
for_each_free_mem_range(&it, 0x0, UINTPTR_MAX)
{
free_size += it.it_limit - it.it_base + 1;
size_t last_pfn = it.it_limit / VM_PAGE_SIZE;
@@ -199,7 +209,8 @@ void vm_sparse_init(void)
}
}
for_each_reserved_mem_range (&it, 0x0, UINTPTR_MAX) {
for_each_reserved_mem_range(&it, 0x0, UINTPTR_MAX)
{
reserved_size += it.it_limit - it.it_base + 1;
size_t last_pfn = it.it_limit / VM_PAGE_SIZE;
@@ -212,7 +223,8 @@ void vm_sparse_init(void)
enum sector_coverage_mode mode = get_sector_coverage_mode();
phys_addr_t pmem_end = 0;
enum vm_page_order sector_size = find_minimum_sector_size(last_free_pfn);
enum vm_page_order sector_size
= find_minimum_sector_size(last_free_pfn);
if (mode == SECTOR_COVERAGE_FREE) {
pmem_end = last_free_pfn * VM_PAGE_SIZE;
} else {
@@ -224,50 +236,63 @@ void vm_sparse_init(void)
size_t sector_bytes = 0;
unsigned int nr_sectors = 0;
calculate_sector_size_and_count(
last_reserved_pfn, last_free_pfn, pmem_end / VM_PAGE_SIZE,
reserved_size, free_size,
&nr_sectors, &sector_size);
last_reserved_pfn,
last_free_pfn,
pmem_end / VM_PAGE_SIZE,
reserved_size,
free_size,
&nr_sectors,
&sector_size);
sector_bytes = vm_page_order_to_bytes(sector_size);
char sector_size_str[64];
data_size_to_string(sector_bytes, sector_size_str, sizeof sector_size_str);
data_size_to_string(
sector_bytes,
sector_size_str,
sizeof sector_size_str);
sector_array = kzalloc(sizeof(struct vm_sector) * nr_sectors, 0);
sector_array_count = nr_sectors;
for (unsigned int i = 0; i < nr_sectors; i++) {
sector_array[i].s_size = sector_size;
sector_array[i].s_first_pfn = (i * sector_bytes) >> VM_PAGE_SHIFT;
sector_array[i].s_first_pfn
= (i * sector_bytes) >> VM_PAGE_SHIFT;
}
size_t s, i;
phys_addr_to_sector_and_index(0x3f00000, &s, &i);
for_each_free_mem_range(&it, 0x0, pmem_end) {
for_each_free_mem_range(&it, 0x0, pmem_end)
{
if (it.it_base & VM_PAGE_MASK) {
it.it_base &= ~VM_PAGE_MASK;
it.it_base += VM_PAGE_SIZE;
}
for (uintptr_t i = it.it_base; i < it.it_limit; i += VM_PAGE_SIZE) {
for (phys_addr_t i = it.it_base; i < it.it_limit;
i += VM_PAGE_SIZE) {
struct vm_page *pg = get_or_create_page(i);
pg->p_flags = 0;
}
}
for_each_reserved_mem_range(&it, 0x0, pmem_end) {
for_each_reserved_mem_range(&it, 0x0, pmem_end)
{
if (it.it_base & VM_PAGE_MASK) {
it.it_base &= ~VM_PAGE_MASK;
it.it_base += VM_PAGE_SIZE;
}
for (uintptr_t i = it.it_base; i < it.it_limit; i += VM_PAGE_SIZE) {
for (phys_addr_t i = it.it_base; i < it.it_limit;
i += VM_PAGE_SIZE) {
struct vm_page *pg = vm_page_get(i);
if (!pg) {
/* if the page doesn't exist, it is part of a sector
that only contains reserved pages. a NULL page
is implicitly treated as reserved */
/* if the page doesn't exist, it is part of a
sector that only contains reserved pages. a
NULL page is implicitly treated as reserved
*/
continue;
}
@@ -275,7 +300,9 @@ void vm_sparse_init(void)
}
}
printk("vm: [sparse] initialised %zu sectors of size %s", nr_sectors, sector_size_str);
printk("vm: [sparse] initialised %zu sectors of size %s",
nr_sectors,
sector_size_str);
}
struct vm_page *vm_page_get_sparse(phys_addr_t addr)
@@ -288,7 +315,8 @@ struct vm_page *vm_page_get_sparse(phys_addr_t addr)
struct vm_sector *sector = &sector_array[sector_number];
if (!sector->s_pages || page_number >= vm_page_order_to_pages(sector->s_size)) {
if (!sector->s_pages
|| page_number >= vm_page_order_to_pages(sector->s_size)) {
return NULL;
}
@@ -298,5 +326,6 @@ struct vm_page *vm_page_get_sparse(phys_addr_t addr)
size_t vm_page_get_pfn_sparse(struct vm_page *pg)
{
struct vm_sector *sector = &sector_array[pg->p_sector];
return sector->s_first_pfn + (((uintptr_t)pg - (uintptr_t)sector->s_pages) / sizeof *pg);
return sector->s_first_pfn
+ (((uintptr_t)pg - (uintptr_t)sector->s_pages) / sizeof *pg);
}