formatting
This commit is contained in:
parent
821716adcc
commit
9e91024f35
9 changed files with 295 additions and 199 deletions
|
|
@ -3,43 +3,54 @@
|
|||
#include <stdarg.h>
|
||||
#include <drivers/uart.h>
|
||||
|
||||
void uart_put(size_t base_addr, uint8_t data) {
|
||||
void uart_put(size_t base_addr, uint8_t data)
|
||||
{
|
||||
*(volatile uint8_t *)base_addr = data;
|
||||
}
|
||||
|
||||
int kputchar(int ch) {
|
||||
int kputchar(int ch)
|
||||
{
|
||||
uart_put(UART_ADDRESS, ch);
|
||||
return ch;
|
||||
}
|
||||
|
||||
void kprint(const char *str) {
|
||||
while (*str) {
|
||||
void kprint(const char *str)
|
||||
{
|
||||
while (*str)
|
||||
{
|
||||
kputchar(*str++);
|
||||
}
|
||||
}
|
||||
|
||||
void kprint_int(int num) {
|
||||
void kprint_int(int num)
|
||||
{
|
||||
char buffer[21];
|
||||
int i = 0;
|
||||
if (num == 0) {
|
||||
if (num == 0)
|
||||
{
|
||||
kputchar('0');
|
||||
return;
|
||||
}
|
||||
if (num < 0) {
|
||||
if (num < 0)
|
||||
{
|
||||
kputchar('-');
|
||||
num = -num;
|
||||
}
|
||||
while (num > 0) {
|
||||
while (num > 0)
|
||||
{
|
||||
buffer[i++] = '0' + (num % 10);
|
||||
num /= 10;
|
||||
}
|
||||
while (i > 0) {
|
||||
while (i > 0)
|
||||
{
|
||||
kputchar(buffer[--i]);
|
||||
}
|
||||
}
|
||||
|
||||
void kprint_float(float num) {
|
||||
if (num < 0) {
|
||||
void kprint_float(float num)
|
||||
{
|
||||
if (num < 0)
|
||||
{
|
||||
kputchar('-');
|
||||
num = -num;
|
||||
}
|
||||
|
|
@ -47,20 +58,23 @@ void kprint_float(float num) {
|
|||
float frac_part = num - int_part;
|
||||
kprint_int(int_part);
|
||||
kputchar('.');
|
||||
for (int i = 0; i < 6; i++) {
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
frac_part *= 10.0f;
|
||||
}
|
||||
int fraction = (int)(frac_part + 0.5f); // Round to nearest
|
||||
kprint_int(fraction);
|
||||
}
|
||||
|
||||
void kprint_hex(uint64_t val) {
|
||||
void kprint_hex(uint64_t val)
|
||||
{
|
||||
char *digits = "0123456789ABCDEF";
|
||||
char buffer[17]; // 64-bit hex is 16 chars
|
||||
buffer[16] = '\0'; // Null-terminate the string
|
||||
|
||||
// We process from right to left
|
||||
for (int i = 15; i >= 0; i--) {
|
||||
for (int i = 15; i >= 0; i--)
|
||||
{
|
||||
buffer[i] = digits[val & 0xF];
|
||||
val >>= 4;
|
||||
}
|
||||
|
|
@ -68,40 +82,50 @@ void kprint_hex(uint64_t val) {
|
|||
kprint(buffer);
|
||||
}
|
||||
|
||||
void knewline(void) {
|
||||
void knewline(void)
|
||||
{
|
||||
kputchar('\n');
|
||||
}
|
||||
|
||||
void kputs(const char *str) {
|
||||
void kputs(const char *str)
|
||||
{
|
||||
kprint(str);
|
||||
knewline();
|
||||
}
|
||||
|
||||
void kprintf(const char *format, ...) {
|
||||
void kprintf(const char *format, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
|
||||
for(char *p = format; *p != '\0'; p++) {
|
||||
if (*p == '%') {
|
||||
for (char *p = format; *p != '\0'; p++)
|
||||
{
|
||||
if (*p == '%')
|
||||
{
|
||||
p++;
|
||||
switch (*p) {
|
||||
case 's': {
|
||||
switch (*p)
|
||||
{
|
||||
case 's':
|
||||
{
|
||||
char *s = va_arg(args, char *);
|
||||
kprint(s);
|
||||
break;
|
||||
}
|
||||
case 'd': {
|
||||
case 'd':
|
||||
{
|
||||
int d = va_arg(args, int);
|
||||
kprint_int(d);
|
||||
break;
|
||||
}
|
||||
case 'f': {
|
||||
case 'f':
|
||||
{
|
||||
double f = va_arg(args, double);
|
||||
kprint_float((float)f);
|
||||
break;
|
||||
}
|
||||
case 'x': // Hex
|
||||
case 'p': { // Pointer
|
||||
case 'p':
|
||||
{ // Pointer
|
||||
uint64_t x = va_arg(args, uint64_t);
|
||||
kprint_hex(x);
|
||||
break;
|
||||
|
|
@ -113,7 +137,9 @@ void kprintf(const char *format, ...) {
|
|||
kputchar('%');
|
||||
kputchar(*p);
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
kputchar(*p);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,17 +5,12 @@
|
|||
#include <kernel/panic.h>
|
||||
#include <kernel/memory.h>
|
||||
|
||||
void kmain() {
|
||||
void kmain()
|
||||
{
|
||||
kprintf("Hello, from %s!", "SquidgeOS");
|
||||
kputs("-------------------");
|
||||
knewline();
|
||||
page_init();
|
||||
|
||||
//kprint("Stress testing memory...\n");
|
||||
//while(1) {
|
||||
// void *p = page_alloc();
|
||||
//}
|
||||
|
||||
test_memory_integrity();
|
||||
test_memory_alignment();
|
||||
test_memory_stress();
|
||||
|
|
|
|||
|
|
@ -4,50 +4,59 @@
|
|||
#include "memory.h"
|
||||
#include "panic.h"
|
||||
|
||||
|
||||
HeapHeader *heap_free_list;
|
||||
extern uint8_t _heap_start[]; // named in the linker script
|
||||
|
||||
void page_init() {
|
||||
void page_init()
|
||||
{
|
||||
kprint("Initialising page allocator.\n");
|
||||
uintptr_t start = ((uintptr_t)_heap_start + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);
|
||||
uintptr_t end = 0x88000000; // Default QEMU RAM limit
|
||||
|
||||
for (uintptr_t addr = start; addr + PAGE_SIZE <= end; addr += PAGE_SIZE) {
|
||||
for (uintptr_t addr = start; addr + PAGE_SIZE <= end; addr += PAGE_SIZE)
|
||||
{
|
||||
page_free((void *)addr);
|
||||
}
|
||||
}
|
||||
|
||||
void page_free(void *addr) {
|
||||
if (addr == NULL) return;
|
||||
void page_free(void *addr)
|
||||
{
|
||||
if (addr == NULL)
|
||||
return;
|
||||
|
||||
struct Page *p = (struct Page *)addr;
|
||||
p->next = free_list;
|
||||
free_list = p;
|
||||
}
|
||||
|
||||
void *page_alloc() {
|
||||
if (free_list == NULL) {
|
||||
void *page_alloc()
|
||||
{
|
||||
if (free_list == NULL)
|
||||
{
|
||||
kpanic("No free pages!");
|
||||
}
|
||||
struct Page *p = free_list;
|
||||
free_list = free_list->next;
|
||||
|
||||
// zero out the page
|
||||
for (int i = 0; i < (PAGE_SIZE); i++) {
|
||||
for (int i = 0; i < (PAGE_SIZE); i++)
|
||||
{
|
||||
((uint8_t *)p)[i] = 0;
|
||||
}
|
||||
|
||||
return (void *)p;
|
||||
}
|
||||
|
||||
void *kmalloc(size_t size) {
|
||||
if (size == 0) return NULL;
|
||||
void *kmalloc(size_t size)
|
||||
{
|
||||
if (size == 0)
|
||||
return NULL;
|
||||
|
||||
// Align size to 8 bytes
|
||||
size = (size + 7) & ~7;
|
||||
|
||||
if (heap_free_list == NULL) {
|
||||
if (heap_free_list == NULL)
|
||||
{
|
||||
HeapHeader *header = (HeapHeader *)page_alloc();
|
||||
header->size = PAGE_SIZE - sizeof(HeapHeader);
|
||||
header->is_free = 1;
|
||||
|
|
@ -60,22 +69,26 @@ void *kmalloc(size_t size) {
|
|||
HeapHeader *current = heap_free_list;
|
||||
HeapHeader *prev = NULL;
|
||||
|
||||
while (current != NULL) {
|
||||
if (current->is_free && current->size >= size) {
|
||||
while (current != NULL)
|
||||
{
|
||||
if (current->is_free && current->size >= size)
|
||||
{
|
||||
break;
|
||||
}
|
||||
prev = current;
|
||||
current = current->next;
|
||||
}
|
||||
|
||||
if(current == NULL) {
|
||||
if (current == NULL)
|
||||
{
|
||||
// No suitable block found, allocate a new page
|
||||
HeapHeader *header = (HeapHeader *)page_alloc();
|
||||
header->size = PAGE_SIZE - sizeof(HeapHeader);
|
||||
header->is_free = 1;
|
||||
header->next = heap_free_list;
|
||||
header->prev = NULL;
|
||||
if(heap_free_list) {
|
||||
if (heap_free_list)
|
||||
{
|
||||
heap_free_list->prev = header;
|
||||
}
|
||||
heap_free_list = header;
|
||||
|
|
@ -83,7 +96,8 @@ void *kmalloc(size_t size) {
|
|||
}
|
||||
|
||||
// Now, current is a block that can be used
|
||||
if (!current) {
|
||||
if (!current)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -91,10 +105,12 @@ void *kmalloc(size_t size) {
|
|||
|
||||
// If the block is larger than needed, split it
|
||||
size_t min_split_size = sizeof(HeapHeader) + 16;
|
||||
if (current->size >= size + min_split_size) {
|
||||
if (current->size >= size + min_split_size)
|
||||
{
|
||||
HeapHeader *new_header = (HeapHeader *)((uint8_t *)current + sizeof(HeapHeader) + size);
|
||||
// Safety check: if new_header address is wild, abort!
|
||||
if ((uintptr_t)new_header < 0x80000000 || (uintptr_t)new_header > 0x88000000) {
|
||||
if ((uintptr_t)new_header < 0x80000000 || (uintptr_t)new_header > 0x88000000)
|
||||
{
|
||||
kpanic("Splitting created invalid pointer!");
|
||||
}
|
||||
new_header->size = current->size - size - sizeof(HeapHeader);
|
||||
|
|
@ -102,7 +118,8 @@ void *kmalloc(size_t size) {
|
|||
|
||||
new_header->next = current->next;
|
||||
new_header->prev = current;
|
||||
if(current->next) {
|
||||
if (current->next)
|
||||
{
|
||||
current->next->prev = new_header;
|
||||
}
|
||||
current->size = size;
|
||||
|
|
@ -112,11 +129,14 @@ void *kmalloc(size_t size) {
|
|||
return (void *)((char *)current + sizeof(HeapHeader));
|
||||
}
|
||||
|
||||
void kfree(void *ptr) {
|
||||
if (ptr == NULL) return;
|
||||
void kfree(void *ptr)
|
||||
{
|
||||
if (ptr == NULL)
|
||||
return;
|
||||
|
||||
HeapHeader *header = (HeapHeader *)((uint8_t *)ptr - sizeof(HeapHeader));
|
||||
if(header->is_free) {
|
||||
if (header->is_free)
|
||||
{
|
||||
kpanic("Double free detected!");
|
||||
}
|
||||
header->is_free = 1;
|
||||
|
|
@ -124,28 +144,37 @@ void kfree(void *ptr) {
|
|||
kcoalesce(header);
|
||||
}
|
||||
|
||||
void kcoalesce(HeapHeader *header) {
|
||||
if(!header || !header->is_free) return;
|
||||
void kcoalesce(HeapHeader *header)
|
||||
{
|
||||
if (!header || !header->is_free)
|
||||
return;
|
||||
// merge backward
|
||||
while (header->prev && header->prev->is_free) {
|
||||
while (header->prev && header->prev->is_free)
|
||||
{
|
||||
header = header->prev;
|
||||
}
|
||||
// merge forward
|
||||
while (header->next && header->next->is_free){
|
||||
while (header->next && header->next->is_free)
|
||||
{
|
||||
uintptr_t current_end = (uintptr_t)header + sizeof(HeapHeader) + header->size;
|
||||
if (current_end == (uintptr_t)header->next) {
|
||||
if (current_end == (uintptr_t)header->next)
|
||||
{
|
||||
header->size += sizeof(HeapHeader) + header->next->size;
|
||||
header->next = header->next->next;
|
||||
if(header->next) {
|
||||
if (header->next)
|
||||
{
|
||||
header->next->prev = header;
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void test_memory_integrity() {
|
||||
void test_memory_integrity()
|
||||
{
|
||||
kprint("Running Integrity Test...\n");
|
||||
uint64_t *a = (uint64_t *)kmalloc(16);
|
||||
uint64_t *b = (uint64_t *)kmalloc(16);
|
||||
|
|
@ -153,20 +182,26 @@ void test_memory_integrity() {
|
|||
*a = 0x1122334455667788;
|
||||
*b = 0x99AABBCCDDEEFF00;
|
||||
|
||||
if (*a == 0x1122334455667788) {
|
||||
if (*a == 0x1122334455667788)
|
||||
{
|
||||
kprint("Integrity Pass!\n");
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
kprint("CORRUPTION DETECTED!\n");
|
||||
}
|
||||
kfree(a);
|
||||
kfree(b);
|
||||
}
|
||||
|
||||
void test_memory_alignment() {
|
||||
void test_memory_alignment()
|
||||
{
|
||||
kprint("Running Alignment Test...\n");
|
||||
for (int i = 1; i <= 64; i++) {
|
||||
for (int i = 1; i <= 64; i++)
|
||||
{
|
||||
void *ptr = kmalloc(i);
|
||||
if (((uintptr_t)ptr % 8) != 0) {
|
||||
if (((uintptr_t)ptr % 8) != 0)
|
||||
{
|
||||
kprint("Misaligned allocation detected!\n");
|
||||
return;
|
||||
}
|
||||
|
|
@ -175,20 +210,25 @@ void test_memory_alignment() {
|
|||
kprint("All allocations are properly aligned!\n");
|
||||
}
|
||||
|
||||
void test_memory_stress() {
|
||||
void test_memory_stress()
|
||||
{
|
||||
kprintf("Starting Stress Test...\n");
|
||||
heap_stats();
|
||||
void *ptrs[100] = {0}; // Track allocated pointers
|
||||
uint32_t seed = 0xACE2026; // Example seed
|
||||
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
for (int i = 0; i < 1000; i++)
|
||||
{
|
||||
// 1. Randomly allocate or free
|
||||
int idx = (seed >> 16) % 50;
|
||||
if (ptrs[idx] == NULL) {
|
||||
if (ptrs[idx] == NULL)
|
||||
{
|
||||
size_t size = (seed % 256) + 1;
|
||||
ptrs[idx] = kmalloc(size);
|
||||
// Optional: fill with data to check integrity later
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
kfree(ptrs[idx]);
|
||||
ptrs[idx] = NULL;
|
||||
}
|
||||
|
|
@ -199,8 +239,10 @@ void test_memory_stress() {
|
|||
kprintf("HeadHeader size: %d bytes\n", sizeof(HeapHeader));
|
||||
heap_stats();
|
||||
kprintf("Cleaning up remaining allocations...\n");
|
||||
for (int i = 0; i < 100; i++) {
|
||||
if (ptrs[i] != NULL) {
|
||||
for (int i = 0; i < 100; i++)
|
||||
{
|
||||
if (ptrs[i] != NULL)
|
||||
{
|
||||
kfree(ptrs[i]);
|
||||
ptrs[i] = NULL;
|
||||
}
|
||||
|
|
@ -208,7 +250,8 @@ void test_memory_stress() {
|
|||
heap_stats();
|
||||
}
|
||||
|
||||
void heap_stats() {
|
||||
void heap_stats()
|
||||
{
|
||||
size_t free_size = 0;
|
||||
size_t used_size = 0;
|
||||
size_t free_blocks = 0;
|
||||
|
|
@ -216,11 +259,15 @@ void heap_stats() {
|
|||
|
||||
HeapHeader *current = heap_free_list;
|
||||
|
||||
while (current != NULL) {
|
||||
if (current->is_free) {
|
||||
while (current != NULL)
|
||||
{
|
||||
if (current->is_free)
|
||||
{
|
||||
free_size += current->size;
|
||||
free_blocks++;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
used_size += current->size;
|
||||
used_blocks++;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,11 +3,13 @@
|
|||
|
||||
#define PAGE_SIZE 4096
|
||||
|
||||
typedef struct Page {
|
||||
typedef struct Page
|
||||
{
|
||||
struct Page *next;
|
||||
} Page;
|
||||
|
||||
typedef struct HeapHeader {
|
||||
typedef struct HeapHeader
|
||||
{
|
||||
size_t size;
|
||||
int is_free;
|
||||
struct HeapHeader *next;
|
||||
|
|
|
|||
|
|
@ -4,14 +4,16 @@
|
|||
#include <syscon/syscon.h>
|
||||
#include "memory.h"
|
||||
|
||||
void kpanic(const char *reason){
|
||||
void kpanic(const char *reason)
|
||||
{
|
||||
kputs("\n!!! PANIC !!!\n");
|
||||
kputs(reason);
|
||||
kputs("\n!!! PANIC !!!\n");
|
||||
poweroff();
|
||||
}
|
||||
|
||||
void kpanic_force() {
|
||||
void kpanic_force()
|
||||
{
|
||||
kprint("\n!!! FORCE PANIC !!!\n");
|
||||
|
||||
// 'ebreak' is the standard RISC-V way to trigger a debug trap.
|
||||
|
|
@ -21,12 +23,14 @@ void kpanic_force() {
|
|||
poweroff();
|
||||
|
||||
kprint("Force panic falled. Power off failed. sleep until interupt. \n");
|
||||
while(1) {
|
||||
while (1)
|
||||
{
|
||||
__asm__ volatile("wfi");
|
||||
}
|
||||
}
|
||||
|
||||
void handle_trap() {
|
||||
void handle_trap()
|
||||
{
|
||||
kprint("\n!!! HARDWARE EXCEPTION DETECTED !!!\n");
|
||||
|
||||
// Read the 'mcause' register to see WHY we trapped
|
||||
|
|
@ -37,15 +41,32 @@ void handle_trap() {
|
|||
uintptr_t mtval;
|
||||
asm volatile("csrr %0, mtval" : "=r"(mtval));
|
||||
|
||||
switch(cause) {
|
||||
case 0: kprint("Reason: Instruction Address Misaligned\n"); break;
|
||||
case 1: kprint("Reason: Instruction Access Fault\n"); break;
|
||||
case 2: kprint("Reason: Illegal Instruction\n"); break;
|
||||
case 3: kprint("Reason: Breakpoint (ebreak)\n"); break;
|
||||
case 4: kprint("Reason: Load Address Misaligned\n"); break;
|
||||
case 5: kprint("Reason: Load Access Fault\n"); break;
|
||||
case 6: kprint("Reason: Store/AMO Address Misaligned\n"); break;
|
||||
case 7: kprint("Reason: Store/AMO Access Fault\n"); break;
|
||||
switch (cause)
|
||||
{
|
||||
case 0:
|
||||
kprint("Reason: Instruction Address Misaligned\n");
|
||||
break;
|
||||
case 1:
|
||||
kprint("Reason: Instruction Access Fault\n");
|
||||
break;
|
||||
case 2:
|
||||
kprint("Reason: Illegal Instruction\n");
|
||||
break;
|
||||
case 3:
|
||||
kprint("Reason: Breakpoint (ebreak)\n");
|
||||
break;
|
||||
case 4:
|
||||
kprint("Reason: Load Address Misaligned\n");
|
||||
break;
|
||||
case 5:
|
||||
kprint("Reason: Load Access Fault\n");
|
||||
break;
|
||||
case 6:
|
||||
kprint("Reason: Store/AMO Address Misaligned\n");
|
||||
break;
|
||||
case 7:
|
||||
kprint("Reason: Store/AMO Access Fault\n");
|
||||
break;
|
||||
default:
|
||||
kprintf("Reason: Unknown Exception Code %d\n", cause);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ void kpanic(const char *reason);
|
|||
void kpanic_force();
|
||||
|
||||
#define KASSERT(cond, msg) \
|
||||
if (!(cond)) { \
|
||||
if (!(cond)) \
|
||||
{ \
|
||||
kprint("ASSERTION FAILED: "); \
|
||||
kprint(__FILE__); \
|
||||
kprint(":"); \
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
#include <stddef.h>
|
||||
#include "string.h"
|
||||
|
||||
void *memset(void *s, int c, size_t n) {
|
||||
void *memset(void *s, int c, size_t n)
|
||||
{
|
||||
unsigned char *p = s;
|
||||
while (n--) {
|
||||
while (n--)
|
||||
{
|
||||
*p++ = (unsigned char)c;
|
||||
}
|
||||
return s;
|
||||
|
|
|
|||
|
|
@ -3,7 +3,8 @@
|
|||
#include "syscon.h"
|
||||
#include "drivers/uart.h"
|
||||
|
||||
void poweroff(void) {
|
||||
void poweroff(void)
|
||||
{
|
||||
knewline();
|
||||
kputs("-------");
|
||||
knewline();
|
||||
|
|
@ -11,7 +12,8 @@ void poweroff(void) {
|
|||
*(volatile uint32_t *)SYSCON_ADDR = SYSCON_POWEROFF;
|
||||
}
|
||||
|
||||
void reboot(void) {
|
||||
void reboot(void)
|
||||
{
|
||||
knewline();
|
||||
kputs("-------");
|
||||
knewline();
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue