keyb/kernel
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix: make pmm works for x86_64 + panic$

Browse source
This commit is contained in:
Jordan ⌨️ 2025-09-25 01:06:41 +02:00
parent 335e24a733
commit 3811f1b867
8 changed files with 106 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
meta/plugins/cli.py
View file

@ -45,8 +45,8 @@ def _(args: StartArgs):
# "-enable-kvm",
"-no-reboot",
"-no-shutdown",
# "-display",
# "none",
"-display",
"none",
"-smp",
"4",
"-serial",

15
src/kernel/hal/rv32/paging.c
View file

@ -97,8 +97,7 @@ void hal_switch_space(HalPage space) {
void paging_init(void) {
PhysObj page_phys = pmm_alloc(page_size());
if (page_phys.base == 0) {
error$("Couldn't allocate page table");
hal_brkpoint();
panic$("Couldn't allocate page table");
}
memset((void*)page_phys.base, 0, page_size());
@ -108,32 +107,28 @@ void paging_init(void) {
size_t text_end = align_up$((uintptr_t)text_end_addr, page_size());
HalMappingError err = hal_map_page((HalPage){kernel_page_table}, text_start, text_start, text_end - text_start, HAL_MAP_READ | HAL_MAP_EXEC);
if (err != HAL_MAP_OK) {
error$("Couldn't map kernel text, cause: %s", HalMappingErrorString(err));
hal_brkpoint();
panic$("Couldn't map kernel text, cause: %s", HalMappingErrorString(err));
}
size_t rodata_start = align_down$((uintptr_t)rodata_start_addr, page_size());
size_t rodata_end = align_up$((uintptr_t)rodata_end_addr, page_size());
err = hal_map_page((HalPage){kernel_page_table}, rodata_start, rodata_start, rodata_end - rodata_start, HAL_MAP_READ);
if (err != HAL_MAP_OK) {
error$("Couldn't map kernel rodata, cause: %s", HalMappingErrorString(err));
hal_brkpoint();
panic$("Couldn't map kernel rodata, cause: %s", HalMappingErrorString(err));
}
size_t data_start = align_down$((uintptr_t)data_start_addr, page_size());
size_t data_end = align_up$((uintptr_t)data_end_addr, page_size());
err = hal_map_page((HalPage){kernel_page_table}, data_start, data_start, data_end - data_start, HAL_MAP_READ | HAL_MAP_WRITE);
if (err != HAL_MAP_OK) {
error$("Couldn't map kernel data, cause: %s", HalMappingErrorString(err));
hal_brkpoint();
panic$("Couldn't map kernel data, cause: %s", HalMappingErrorString(err));
}
size_t stack_start = align_down$((uintptr_t)__stack_top - kib$(128), page_size());
size_t stack_end = align_up$((uintptr_t)__stack_top, page_size());
err = hal_map_page((HalPage){kernel_page_table}, stack_start, stack_start, stack_end - stack_start, HAL_MAP_READ | HAL_MAP_WRITE);
if (err != HAL_MAP_OK) {
error$("Couldn't map kernel stack, cause: %s", HalMappingErrorString(err));
hal_brkpoint();
panic$("Couldn't map kernel stack, cause: %s", HalMappingErrorString(err));
}
HandoverRecord rec;

5
src/kernel/hal/x86_64/boot.c
View file

@ -1,6 +1,7 @@
#include <dtb>
#include <limine>
#include <logger>
#include <pmm>
__attribute__((used, section(".limine_requests"))) static volatile LIMINE_BASE_REVISION(3);
__attribute__((used, section(".limine_requests_start"))) static volatile LIMINE_REQUESTS_START_MARKER;
@ -9,8 +10,8 @@ __attribute__((used, section(".limine_requests_end"))) static volatile LIMINE_RE
void kmain(void);
void x86_64_start(void) {
info$("Hello, x86_64 !");
// kmain();
pmm_init();
kmain();
}
DTBNode* hal_dtb_root(void) {

0
src/libs/handover/limine/manifest.json → src/kernel/libs/handover-limine/manifest.json
View file

93
src/kernel/libs/handover-limine/mod.c Normal file
View file

@ -0,0 +1,93 @@
#include <helpers/mem.h>
#include <limine>
#include <logger>
#include <stdint.h>
#include "limine/mod.h"
#include "mod.h"
/* --- Handover ------------------------------------------------------------- */
static uint8_t handover_buffer[kib$(16)] = {0};
static HandoverPayload* payload = NULL;
/* --- Limine requests ------------------------------------------------------ */
__attribute__((used, section(".limine_requests"))) static volatile struct limine_memmap_request mmap_req = {
.id = LIMINE_MEMMAP_REQUEST,
.revision = 0
};
static void handover_parse_mmap(HandoverPayload* self) {
if (mmap_req.response == NULL) [[clang::unlikely]] {
panic$("Couldn't get limine's memory maps");
}
info$("Retrieved memory map from Limine");
info$("======================================================");
info$(" TYPE | BASE | LIMIT ");
info$("======================================================");
for (size_t i = 0; i < mmap_req.response->entry_count; i++) {
struct limine_memmap_entry* entry = mmap_req.response->entries[i];
HandoverRecord record = {0};
switch (entry->type) {
case LIMINE_MEMMAP_USABLE: {
info$(" FREE | %p | %p", entry->base, entry->base + entry->length);
record.tag = HANDOVER_FREE;
break;
}
case LIMINE_MEMMAP_ACPI_NVS:
case LIMINE_MEMMAP_RESERVED:
case LIMINE_MEMMAP_BAD_MEMORY: {
info$(" RESERVED | %p | %p", entry->base, entry->base + entry->length);
record.tag = HANDOVER_RESERVED;
break;
}
case LIMINE_MEMMAP_ACPI_RECLAIMABLE:
case LIMINE_MEMMAP_BOOTLOADER_RECLAIMABLE: {
info$(" RECLAIMABLE | %p | %p", entry->base, entry->base + entry->length);
record.tag = HANDOVER_LOADER;
break;
}
case LIMINE_MEMMAP_KERNEL_AND_MODULES: {
info$(" MODULE | %p | %p", entry->base, entry->base + entry->length);
record.tag = HANDOVER_KERNEL;
break;
}
case LIMINE_MEMMAP_FRAMEBUFFER: {
info$(" FRAMEBUFFER | %p | %p", entry->base, entry->base + entry->length);
record.tag = HANDOVER_FB;
break;
}
default:
[[clang::unlikely]] {
panic$("Unknown memory map entry type %d", entry->type);
}
}
record.start = entry->base;
record.size = entry->length;
handover_append(self, record);
}
info$("=====================================================");
}
HandoverPayload* handover(void) {
if (payload == NULL) {
payload = (HandoverPayload*)handover_buffer;
payload->size = kib$(16);
handover_parse_mmap(payload);
}
return payload;
}

0
src/libs/handover/limine/mod.h → src/kernel/libs/handover-limine/mod.h
View file

8
src/kernel/pmm/mod.c
View file

@ -50,7 +50,7 @@ void pmm_init(void) {
handover_foreach_record(hand, record) {
if (record.tag == HANDOVER_FREE && record.size >= bitmap.len) {
debug$("Bitmap base: %p", record.start);
bitmap.bitmap = (uint8_t*)record.start;
bitmap.bitmap = (uint8_t*)hal_mmap_l2h(record.start);
handover_append(handover(), (HandoverRecord){
.tag = HANDOVER_RESERVED,
@ -65,8 +65,7 @@ void pmm_init(void) {
}
if (bitmap.bitmap == NULL) {
error$("Couldn't allocate bitmap");
hal_brkpoint();
panic$("Couldn't allocate bitmap");
}
memset(bitmap.bitmap, 0xFF, bitmap.len);
@ -108,8 +107,7 @@ PhysObj pmm_alloc(size_t len) {
bitmap.last = 0;
return pmm_alloc(pages);
} else {
error$("Out of physical memory");
hal_brkpoint();
panic$("Out of physical memory");
}
__builtin_unreachable();
}

8
src/libs/handover/limine/mod.c
View file

@ -1,8 +0,0 @@
#include "mod.h"
#include <limine>
static HandoverPayload* payload = NULL;
HandoverPayload* handover(void) {
return payload;
}