daniel/MontaukOS
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(kcp, IDT, Heap, kernel): Various fixes, scrap broken memory allocator

Browse Source
This commit is contained in:
Daniel Hammer
2025-03-11 20:00:04 +01:00
parent b774f82625
commit cc094a9172
23 changed files with 18910 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kernel/src/Common/Panic.cpp
+6 -5
View File
@@ -7,12 +7,11 @@ void Panic(const char *meditationString, System::PanicFrame* frame) {
#if defined (__x86_64__)
if (frame != nullptr) {
kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n";
if (frame->InterruptVector == 0xE) { // In case of #PF the CPU pushes an error code to the frame
auto pf_frame = (System::PageFaultPanicFrame*)frame;
frame = (System::PanicFrame*)&pf_frame->IP;
kerr << "\t" << "InterruptVector: " << "0x" << base::hex << 0xE << "\n";
/* Page fault error details */
kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n";
kerr << "\t" << "PageFaultWrite: " << base::dec << pf_frame->PageFaultError.Write << "\n";
@@ -23,9 +22,11 @@ void Panic(const char *meditationString, System::PanicFrame* frame) {
kerr << "\t" << "PageFaultShadowStack: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
}
else
{
kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n";
else if (frame->InterruptVector == 0xD) {
auto gpf_frame = (System::GPFPanicFrame*)frame;
frame = (System::PanicFrame*)&frame->IP;
kerr << "\t" << "ErrorCode: " << base::dec << gpf_frame->GeneralProtectionFaultError << "\n";
}
kerr << "\t" << "InstructionPointer: " << "0x" << base::hex << frame->IP << "\n";
kernel/src/Common/Panic.hpp
+1 -1
View File
@@ -1,5 +1,5 @@
#pragma once
#include <Platform/Registers.hpp>
#include <Terminal/terminal.hpp>
#include <Terminal/Terminal.hpp>
void Panic(const char *meditationString, System::PanicFrame* frame);
kernel/src/CppLib/CString.cpp
+42
View File
@@ -0,0 +1,42 @@
/*
* CString.cpp
* C++ string tooling
* Copyright (c) 2025 Daniel Hammer
*/
#include "CString.hpp"
#include "Stream.hpp"
#include <Libraries/Memory.hpp>
#include <Memory/Heap.hpp>
namespace kcp {
vector<const char*> splitstr(const char* str, char delimiter) {
vector<const char*> result;
cstringstream current_stream = cstringstream();
do {
if (*str == delimiter || *str == '\0') {
auto cstr = current_stream.cstr();
auto cstr_len = Lib::strlen(cstr);
result.push_back((const char*)Memory::g_heap->Request(sizeof(char) * (cstr_len + 1)));
memcpy((void*)result.at(result.size() - 1), cstr, cstr_len + 1);
if (*str == '\0') {
break;
}
current_stream = cstringstream();
str++;
continue;
}
current_stream << (char)*str;
str++;
} while (*str != '\0');
return result;
}
};
kernel/src/CppLib/CString.hpp
+12
View File
@@ -0,0 +1,12 @@
/*
* CString.cpp
* C++ string tooling
* Copyright (c) 2025 Daniel Hammer
*/
#pragma once
#include <CppLib/Vector.hpp>
namespace kcp {
vector<const char*> splitstr(const char* str, char delimiter);
};
kernel/src/CppLib/Stream.cpp
+3 -3
View File
@@ -6,8 +6,8 @@
#include "Stream.hpp"
#include <Memory/Heap.hpp>
#include <Terminal/terminal.hpp>
#include <Libraries/string.hpp>
#include <Terminal/Terminal.hpp>
#include <Libraries/String.hpp>
kcp::cstringstream::cstringstream()
{
@@ -21,7 +21,7 @@ kcp::cstringstream::~cstringstream()
}
kcp::cstringstream& kcp::cstringstream::operator<<(char c) {
this->string = (const char *)Memory::g_heap->Realloc((void *)this->string, this->size + 1);
this->string = (char *)Memory::g_heap->Realloc((void *)this->string, this->size + 2);
if (!this->string)
{
kernel/src/CppLib/Stream.hpp
+1 -1
View File
@@ -20,7 +20,7 @@ namespace kcp {
};
class cstringstream {
const char* string;
char* string;
std::size_t size;
base current_base = base::dec;
kernel/src/CppLib/Vector.hpp
+10 -5
View File
@@ -6,7 +6,7 @@
#pragma once
#include <cstdint>
#include <Terminal/terminal.hpp>
#include <Terminal/Terminal.hpp>
#include <Memory/Heap.hpp>
namespace kcp
@@ -24,11 +24,12 @@ namespace kcp
array = nullptr;
}
T operator[](std::size_t position)
T& operator[](std::size_t position)
{
if (position > (sz - 1)) {
kerr << "Vector out of bounds caught!" << Kt::newline;
return T{};
return at(0);
}
else
{
@@ -36,13 +37,17 @@ namespace kcp
}
}
T at(std::int64_t position) {
T& at(std::int64_t position) {
return this->operator[](position);
}
void push_back(T value) {
size_t push_back(T value) {
size_t _sz = sz;
array = (T *)Memory::g_heap->Realloc(array, sizeof(T) * (sz + 1));
array[sz++] = value;
return _sz;
}
T* get_array()
kernel/src/Hal/GDT.cpp
+4 -4
View File
@@ -3,7 +3,7 @@
*/
#include "GDT.hpp"
#include "../Terminal/terminal.hpp"
#include "../Terminal/Terminal.hpp"
// Limine loads a GDT of course, (CS = 0x28) but we will need to make a TSS someday... therefore we load our own now
@@ -14,7 +14,7 @@ namespace Hal {
BasicGDT kernelGDT{};
void PrepareGDT() {
kout << "[Hal] GDT at " << base::hex << (uint64_t)&kernelGDT << "\n";
kout << "HardwareAbstraction: GDT at " << base::hex << (uint64_t)&kernelGDT << "\n";
kernelGDT = {
// Code segment offset 0x08
// Data segment offset 0x10
@@ -61,10 +61,10 @@ namespace Hal {
void BridgeLoadGDT() {
// Puts the GDT pointer structure into the GDTR
kout << "[Hal] Setting GDTR" << Kt::newline;
kout << "HardwareAbstraction: Setting GDTR" << Kt::newline;
LoadGDT(&gdtPointer);
kout << "[Hal] Reloading segments" << Kt::newline;
kout << "HardwareAbstraction: Reloading segments" << Kt::newline;
ReloadSegments();
}
};
kernel/src/Hal/IDT.cpp
+7 -6
View File
@@ -16,6 +16,7 @@ namespace Hal {
constexpr auto TrapGate = 0x8F;
InterruptDescriptor* IDT;
InterruptDescriptor InterruptDescriptorTable[255]{};
IDTRStruct IDTR{};
const char* ExceptionStrings[] = {
@@ -55,12 +56,12 @@ namespace Hal {
template<size_t i>
__attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
{
kcp::cstringstream stream;
stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel";
// kcp::cstringstream stream;
// stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel";
frame->InterruptVector = i;
Panic(stream.cstr(), frame);
Panic(ExceptionStrings[i], frame);
}
void LoadIDT(IDTRStruct& idtr) {
@@ -112,16 +113,16 @@ namespace Hal {
struct SetHandler<N,N> {static void run() {}};
void IDTInitialize() {
IDT = (InterruptDescriptor*)Memory::g_heap->Request(4096);
IDT = (InterruptDescriptor*)&InterruptDescriptorTable;
IDTR.Limit = 0x0FF;
IDTR.Base = (uint64_t)&IDT;
SetHandler<0, 31>::run();
kout << "[Hal] Created exception interrupt vectors" << "\n";
kout << "HardwareAbstraction: Created exception interrupt vectors" << "\n";
LoadIDT(IDTR);
kout << "[Hal] Loaded new IDT" << "\n";
kout << "HardwareAbstraction: Loaded new IDT" << "\n";
}
};
kernel/src/Libraries/string.cpp → kernel/src/Libraries/String.cpp
+1 -1
View File
@@ -1,4 +1,4 @@
#include "string.hpp"
#include "String.hpp"
#include <cstdint>
#include <cstddef>
kernel/src/Libraries/string.hpp → kernel/src/Libraries/String.hpp
View File
kernel/src/main.cpp → kernel/src/Main.cpp
+21 -24
View File
@@ -9,19 +9,23 @@
#include <limine.h>
#include <Hal/GDT.hpp>
#include <Terminal/terminal.hpp>
#include <Libraries/string.hpp>
#include <Terminal/Terminal.hpp>
#include <Libraries/String.hpp>
#include <Efi/UEFI.hpp>
#include <Common/Panic.hpp>
#include <Memory/Memmap.hpp>
#include <Memory/Heap.hpp>
#include <Memory/HHDM.hpp>
#include <CppLib/Stream.hpp>
#include <CppLib/Vector.hpp>
#include <CppLib/CString.hpp>
#include <Platform/Limine.hpp>
#include <Platform/Util.hpp>
#include <Libraries/Memory.hpp>
#include <Hal/IDT.hpp>
using namespace Kt;
@@ -39,7 +43,6 @@ extern void (*__init_array[])();
extern void (*__init_array_end[])();
extern "C" void kmain() {
// Ensure the bootloader actually understands our base revision (see spec).
if (LIMINE_BASE_REVISION_SUPPORTED == false) {
hcf();
}
@@ -49,19 +52,25 @@ extern "C" void kmain() {
__init_array[i]();
}
// Ensure we got a framebuffer.
if (framebuffer_request.response == nullptr
|| framebuffer_request.response->framebuffer_count < 1) {
hcf();
}
// Fetch the first framebuffer.
limine_framebuffer *framebuffer{framebuffer_request.response->framebuffers[0]};
// Initialize the terminal
Kt::Initialize((uint32_t*)framebuffer->address, framebuffer->width, framebuffer->height, framebuffer->pitch, framebuffer->red_mask_size, framebuffer->red_mask_shift,
framebuffer->green_mask_size, framebuffer->green_mask_shift,
framebuffer->blue_mask_size, framebuffer->blue_mask_shift);
Kt::Initialize(
(uint32_t*)framebuffer->address,
framebuffer->width,
framebuffer->height,
framebuffer->pitch,
framebuffer->red_mask_size,
framebuffer->red_mask_shift,
framebuffer->green_mask_size,
framebuffer->green_mask_shift,
framebuffer->blue_mask_size,
framebuffer->blue_mask_shift
);
#if defined (__x86_64__)
Hal::PrepareGDT();
@@ -69,20 +78,10 @@ extern "C" void kmain() {
#endif
uint64_t hhdm_offset = hhdm_request.response->offset;
kout << "[Mem] HHDM offset: 0x" << base::hex << hhdm_offset << newline;
Memory::HHDMBase = hhdm_offset;
if (!system_table_request. response || !system_table_request.response->address) {
kout << "[Mp] Firmware type: PC BIOS" << newline;
} else {
kout << "[Mp] Firmware type: EFI" << newline;
kout << "[Efi] EFI system table at 0x" << base::hex << (uint64_t)system_table_request.response->address << newline;
}
if (memmap_request.response != nullptr) {
kout << "[Mem] Creating Allocator for system conventional memory" << newline;
kout << "MemoryManagement: Creating global HeapAllocator" << newline;
auto result = Memory::Scan(memmap_request.response);
auto allocator = Memory::HeapAllocator(result);
@@ -96,9 +95,7 @@ extern "C" void kmain() {
Hal::IDTInitialize();
#endif
int*x =(int*)0xffffffff;
*x=0;
int*a = (int*)0xffffff;
*a=10;
hcf();
}
kernel/src/Memory/Heap.cpp
+19 -128
View File
@@ -9,152 +9,43 @@
#include "HHDM.hpp"
#include <Libraries/Memory.hpp>
#include <Terminal/terminal.hpp>
#include <Terminal/Terminal.hpp>
#include <Common/Panic.hpp>
#include <Platform/Util.hpp>
#include <Common/Panic.hpp>
namespace Memory
{
constexpr size_t metadata_size = 8; // 8 bytes
HeapAllocator::HeapAllocator(LargestSection section)
{
g_section = section;
Block *current_ref{&head};
Block *start_block_ptr {(Block *)HHDM(section.address)};
Block& start_block = *start_block_ptr;
start_block = Block {
.size = section.size,
.next = nullptr
};
*start_block_ptr = start_block;
current_ref->next = start_block_ptr;
kout << "[Mem] HeapAllocator object created for memory section starting at 0x" << base::hex << section.address << Kt::newline;
kout << "HeapAllocator: constructor called" << Kt::newline;
}
void* HeapAllocator::Request(size_t size, bool phys) {
Block* current_block_ptr{head.next};
Block* current_prev_ptr{(Block *)&head};
while (true) {
if (current_block_ptr == nullptr) {
kerr << "A HeapAllocator was forced to return a Null pointer. (1)" << Kt::newline;
return nullptr;
}
if (current_prev_ptr == nullptr) {
kerr << "An HeapAllocator was forced to return a Null pointer. (2)" << Kt::newline;
return nullptr;
}
size_t descriptor_size = 8;
size_t total_size = size + descriptor_size;
if (current_block_ptr->size >= total_size) {
Block block_copy = *current_block_ptr;
BlockDescriptor* descriptor {(BlockDescriptor *)current_block_ptr};
descriptor->block_size = size;
void* block_start = (void *)((uint64_t)current_block_ptr + descriptor_size);
if (!block_copy.size) {
current_prev_ptr->next = block_copy.next;
}
else
{
block_copy.size -= total_size;
current_prev_ptr->next = (Block *)(uint64_t)descriptor + total_size;
*current_prev_ptr->next = block_copy;
}
if (phys) {
return (void *)SubHHDM(current_block_ptr);
}
return (void *)block_start;
} else {
if (current_block_ptr->next != nullptr) {
current_prev_ptr = current_block_ptr;
current_block_ptr = current_block_ptr->next;
continue;
} else {
kerr << "An HeapAllocator was forced to return a Null pointer. (3)" << Kt::newline;
return nullptr;
}
}
if (current_block_ptr != nullptr) {
if (current_block_ptr->next == nullptr) {
kerr << "An HeapAllocator was forced to return a Null pointer. (4)" << Kt::newline;
return nullptr;
}
current_block_ptr = current_block_ptr->next;
} else
{
kerr << "An HeapAllocator was forced to return a Null pointer. (5)" << Kt::newline;
return nullptr;
}
}
void* HeapAllocator::Request(size_t size) {
return nullptr;
}
void* HeapAllocator::Realloc(void* ptr, size_t size) {
void *new_block = this->Request(size);
if (ptr == nullptr) {
return new_block;
}
if (new_block == nullptr) {
kerr << "HeapAllocator: Reallocation failed due to memory starvation" << Kt::newline;
return nullptr;
}
BlockDescriptor* descriptor = (BlockDescriptor*)((uint64_t)ptr - 8);
memcpy(new_block, ptr, descriptor->block_size);
this->Free(ptr);
return new_block;
return nullptr;
}
void HeapAllocator::Free(void *pagePtr) {
if (!IsHDDMVirtAddr((uint64_t)pagePtr)) {
pagePtr = (void *)HHDM(pagePtr);
}
void HeapAllocator::Free(void* ptr) {
BlockDescriptor* descriptor_ptr = (BlockDescriptor*)((uint64_t)pagePtr - 8);
BlockDescriptor descriptor = *descriptor_ptr;
Block* fmrNext = head.next;
Block* blockPtr = (Block *)pagePtr;
// Merge the descriptor with the block
Block* base = (Block *)((uint64_t)blockPtr - 8);
head.next = base;
// Set the full size
base->size = descriptor.block_size + 8;
// Attach the merged block to the structure
head.next->next = fmrNext;
}
// Traverses the Allocator's linked list for debugging
void HeapAllocator::Walk() {
Block* current = {head.next};
size_t i{0};
// Node* current = {head.next};
// size_t i{0};
while (current != nullptr) {
kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline;
current = current->next;
i++;
}
// while (current != nullptr) {
// kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline;
// current = current->next;
// i++;
// }
}
};
kernel/src/Memory/Heap.hpp
+7 -6
View File
@@ -5,19 +5,20 @@ namespace Memory {
class HeapAllocator {
LargestSection g_section;
struct Block {
struct Node {
size_t size;
Block* next;
Node* next;
};
struct BlockDescriptor {
size_t block_size;
struct Metadata {
size_t size;
};
Block head;
Node head{0, 0};
public:
HeapAllocator(LargestSection section);
void* Request(size_t size, bool phys = false);
void* Request(size_t size);
void* Realloc(void* ptr, size_t size);
void Free(void *pagePtr);
void Walk();
kernel/src/Memory/Memmap.cpp
+2 -2
View File
@@ -1,5 +1,5 @@
#include "Memmap.hpp"
#include <Terminal/terminal.hpp>
#include <Terminal/Terminal.hpp>
#include <Common/Panic.hpp>
#include "Heap.hpp"
@@ -18,7 +18,7 @@ namespace Memory {
}
if (entry->type == LIMINE_MEMMAP_USABLE) {
kout << "[Mem] Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline;
kout << "MemoryManagement: Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline;
if (entry->length > currentLargestSection.size) {
currentLargestSection = {
kernel/src/ObjC/Test.mm
-5
View File
@@ -1,5 +0,0 @@
extern "C" {
int foobar(){
return 3;
}
}
kernel/src/Platform/Itanium.cpp → kernel/src/Platform/ABI.cpp
View File
kernel/src/Platform/Registers.hpp
+11
View File
@@ -39,5 +39,16 @@ namespace System {
uint8_t InterruptVector;
}__attribute__((packed));
struct GPFPanicFrame {
uint64_t GeneralProtectionFaultError;
uint64_t IP;
uint64_t CS;
uint64_t Flags;
uint64_t SP;
uint64_t SS;
uint8_t InterruptVector;
}__attribute__((packed));
};
#endif
kernel/src/Terminal/terminal.cpp → kernel/src/Terminal/Terminal.cpp
+2 -2
View File
@@ -1,8 +1,8 @@
#include "terminal.hpp"
#include "Terminal.hpp"
#include "../Libraries/flanterm/backends/fb.h"
#include "../Libraries/flanterm/flanterm.h"
#include "../Libraries/string.hpp"
#include "../Libraries/String.hpp"
namespace Kt {
flanterm_context *ctx;
kernel/src/Terminal/terminal.hpp → kernel/src/Terminal/Terminal.hpp
+1 -1
View File
@@ -2,7 +2,7 @@
#include <cstdint>
#include <cstddef>
#include <Libraries/string.hpp>
#include <Libraries/String.hpp>
#include <CppLib/Stream.hpp>
using namespace kcp;