From c805d24dd0405d24a984383ccbd84e408dde5f2e Mon Sep 17 00:00:00 2001 From: vmttmv Date: Mon, 12 Jan 2026 03:48:02 +0200 Subject: [PATCH] Fix PDE/PTE definitions, header cleanup - Fixes PDE/PTE definitions in kernel/paging.h - removes memset declaration from kernel/utils.h, uses klibc string.h as needed --- kernel/paging.c | 43 ++++--------- kernel/paging.h | 42 ++++++------- kernel/threading.c | 146 +++++++++++++++++++++++---------------------- kernel/utils.h | 2 - 4 files changed, 107 insertions(+), 126 deletions(-) diff --git a/kernel/paging.c b/kernel/paging.c index 321a404..1bb1f20 100644 --- a/kernel/paging.c +++ b/kernel/paging.c @@ -1,21 +1,17 @@ -#include "paging.h" -#include "io.h" #include -#include +#include +#include "io.h" +#include "paging.h" page_directory_entry_t *page_directory = (page_directory_entry_t *)0x200000; page_table_entry_t *page_table = (page_table_entry_t *)0x201000; -page_table_entry_t *heap_page_table = (page_table_entry_t *)0x202000; // Helper function to set up the page directory entry void set_page_directory(page_directory_entry_t *dir) { - for (int i = 0; i < PAGE_DIRECTORY_SIZE; i++) { - dir[i].present = 0; - } + // Set first PDE dir[0].present = 1; dir[0].rw = 1; - dir[0].user = 0; - dir[0].frame = (uint32_t)page_table >> 12; + dir[0].addr = (uint32_t)page_table >> 12; } // Helper function to set up the page table entry @@ -23,12 +19,8 @@ void set_page_table(page_table_entry_t *table) { for (int i = 0; i < PAGE_TABLE_SIZE; i++) { // Set up page table entries with identity mapping table[i].present = 1; - table[i].rw = 1; // Read/Write - table[i].user = 0; // Kernel mode - table[i].write_through = 0; - table[i].cache_disabled = 0; - table[i].accessed = 0; - table[i].frame = i; // Identity mapping + table[i].rw = 1; // Read/Write + table[i].addr = i; // Identity mapping } } @@ -47,26 +39,13 @@ void enable_paging() { // Initialize paging: set up the page directory and enable paging void paging_init() { + // Zero out the tables + memset(page_directory, 0x00, PAGE_DIRECTORY_SIZE * sizeof *page_directory); + memset(page_table, 0x00, PAGE_TABLE_SIZE * sizeof *page_table); + // Set up identity-mapped page directory + table set_page_directory(page_directory); set_page_table(page_table); - // === Set up heap mapping at 0xC0100000 === - for (int i = 0; i < PAGE_TABLE_SIZE; i++) { - heap_page_table[i].present = 1; - heap_page_table[i].rw = 1; - heap_page_table[i].user = 0; - heap_page_table[i].write_through = 0; - heap_page_table[i].cache_disabled = 0; - heap_page_table[i].accessed = 0; - heap_page_table[i].frame = (256 + i); // Start physical heap at 1MB (256*4KB = 1MB) - } - - // Index 772 = 0xC0100000 / 4MB - page_directory[772].present = 1; - page_directory[772].rw = 1; - page_directory[772].user = 0; - page_directory[772].frame = (uint32_t)heap_page_table >> 12; - enable_paging(); } diff --git a/kernel/paging.h b/kernel/paging.h index 01e73aa..57b2253 100644 --- a/kernel/paging.h +++ b/kernel/paging.h @@ -10,31 +10,31 @@ // Page Directory and Page Table structure typedef struct { - uint32_t present : 1; // Present bit (1: page is present in memory) - uint32_t rw : 1; // Read-Write bit (1: page is read-write) - uint32_t user : 1; // User-supervisor bit (1: user mode access) - uint32_t write_through : 1; // Write-through cache - uint32_t cache_disabled : 1; // Cache disabled - uint32_t accessed : 1; // Accessed bit - uint32_t reserved : 1; // Reserved bit - uint32_t page_size : 1; // Page size (0: 4KB, 1: 4MB) - uint32_t global : 1; // Global page (can be used across different processes) - uint32_t available : 3; // Available bits for the system - uint32_t frame : 20; // Frame address (physical address) + uint32_t present : 1; // Present bit (1: page is present in memory) + uint32_t rw : 1; // Read-Write bit (1: page is read-write) + uint32_t user : 1; // User-supervisor bit (1: user mode access) + uint32_t write_through : 1; // Write-through cache + uint32_t cache_disabled : 1; // Cache disabled + uint32_t accessed : 1; // Accessed bit + uint32_t dirty : 1; // Dirty bit + uint32_t attribute : 1; // Page size (0: 4KB, 1: 4MB) + uint32_t global : 1; // Global page (can be used across different processes) + uint32_t reserved : 3; // Unused + uint32_t addr : 20; // Page frame address (physical address) } __attribute__((packed)) page_table_entry_t; // Define page directory entry typedef struct { - uint32_t present : 1; - uint32_t rw : 1; - uint32_t user : 1; - uint32_t write_through : 1; - uint32_t cache_disabled : 1; - uint32_t accessed : 1; - uint32_t reserved : 1; - uint32_t zero : 5; // Must be zero for page directory - uint32_t reserved_2 : 7; // Reserved bits - uint32_t frame : 20; // Frame address of the page table + uint32_t present : 1; // Present bit (1: PTE is present in memory) + uint32_t rw : 1; // Read-Write bit (1: pages are read-write) + uint32_t user : 1; // User-supervisor bit (1: user mode access) + uint32_t write_through : 1; // Write-through cache + uint32_t cache_disabled : 1; // Cache disabled + uint32_t accessed : 1; // Accessed bit + uint32_t available : 1; // Unused + uint32_t page_size : 1; // Page size (0: 4KB, 1: 4MB) + uint32_t available_2 : 4; // Unused + uint32_t addr : 20; // Page table address } __attribute__((packed)) page_directory_entry_t; extern page_directory_entry_t *page_directory; diff --git a/kernel/threading.c b/kernel/threading.c index ff6d15b..4cdd551 100644 --- a/kernel/threading.c +++ b/kernel/threading.c @@ -1,12 +1,13 @@ +#include "threading.h" + #include -#include +#include + #include "malloc.h" #include "print.h" -#include "threading.h" -#include "utils.h" -#define MAX_THREADS 16 // Maximum number of threads -#define THREAD_STACK_SIZE 8192 // Stack size for each thread +#define MAX_THREADS 16 // Maximum number of threads +#define THREAD_STACK_SIZE 8192 // Stack size for each thread // The thread table stores information about all threads static Thread thread_table[MAX_THREADS]; @@ -17,103 +18,106 @@ static uint32_t num_threads = 0; // Number of active threads static volatile int mutex_locked = 0; // Function declaration for context_switch -void context_switch(Thread *next); +void context_switch(Thread* next); // Initialize the threading system void thread_init(void) { - memset(thread_table, 0, sizeof(thread_table)); - num_threads = 0; + memset(thread_table, 0, sizeof(thread_table)); + num_threads = 0; } // Create a new thread -void thread_create(Thread *thread __attribute__((unused)), void (*start_routine)(void *), void *arg) { - if (num_threads >= MAX_THREADS) { - my_printf("Error: Maximum thread count reached.\n"); - return; - } +void thread_create(Thread* thread __attribute__((unused)), + void (*start_routine)(void*), void* arg) { + if (num_threads >= MAX_THREADS) { + my_printf("Error: Maximum thread count reached.\n"); + return; + } - // Find an empty slot for the new thread - int index = num_threads++; - thread_table[index] = (Thread){0}; - - // Set up the new thread - thread_table[index].start_routine = start_routine; - thread_table[index].arg = arg; - thread_table[index].stack_size = THREAD_STACK_SIZE; - thread_table[index].stack = (uint32_t*)malloc(THREAD_STACK_SIZE); - thread_table[index].stack_top = thread_table[index].stack + THREAD_STACK_SIZE / sizeof(uint32_t); + // Find an empty slot for the new thread + int index = num_threads++; + thread_table[index] = (Thread){0}; - // Initialize the stack (simulate pushing the function's return address) - uint32_t *stack_top = thread_table[index].stack_top; - *(--stack_top) = (uint32_t)start_routine; // Return address (the thread's entry point) - *(--stack_top) = (uint32_t)arg; // Argument to pass to the thread + // Set up the new thread + thread_table[index].start_routine = start_routine; + thread_table[index].arg = arg; + thread_table[index].stack_size = THREAD_STACK_SIZE; + thread_table[index].stack = (uint32_t*)malloc(THREAD_STACK_SIZE); + thread_table[index].stack_top = + thread_table[index].stack + THREAD_STACK_SIZE / sizeof(uint32_t); - // Set the thread's state to ready - thread_table[index].state = THREAD_READY; + // Initialize the stack (simulate pushing the function's return address) + uint32_t* stack_top = thread_table[index].stack_top; + *(--stack_top) = + (uint32_t)start_routine; // Return address (the thread's entry point) + *(--stack_top) = (uint32_t)arg; // Argument to pass to the thread - // If this is the first thread, switch to it - if (index == 0) { - scheduler(); - } + // Set the thread's state to ready + thread_table[index].state = THREAD_READY; + + // If this is the first thread, switch to it + if (index == 0) { + scheduler(); + } } // Yield the CPU to another thread void thread_yield(void) { - // Find the next thread in a round-robin manner - uint32_t next_thread = (current_thread + 1) % num_threads; - while (next_thread != current_thread && thread_table[next_thread].state != THREAD_READY) { - next_thread = (next_thread + 1) % num_threads; - } + // Find the next thread in a round-robin manner + uint32_t next_thread = (current_thread + 1) % num_threads; + while (next_thread != current_thread && + thread_table[next_thread].state != THREAD_READY) { + next_thread = (next_thread + 1) % num_threads; + } - if (next_thread != current_thread) { - current_thread = next_thread; - scheduler(); - } + if (next_thread != current_thread) { + current_thread = next_thread; + scheduler(); + } } // Exit the current thread void thread_exit(void) { - thread_table[current_thread].state = THREAD_BLOCKED; // Mark the thread as blocked (finished) - free(thread_table[current_thread].stack); // Free the thread's stack - num_threads--; // Decrease thread count + thread_table[current_thread].state = + THREAD_BLOCKED; // Mark the thread as blocked (finished) + free(thread_table[current_thread].stack); // Free the thread's stack + num_threads--; // Decrease thread count - // Yield to the next thread - thread_yield(); + // Yield to the next thread + thread_yield(); } // Scheduler: This function selects the next thread to run void scheduler(void) { - // Find the next ready thread - uint32_t next_thread = (current_thread + 1) % num_threads; - while (thread_table[next_thread].state != THREAD_READY) { - next_thread = (next_thread + 1) % num_threads; - } + // Find the next ready thread + uint32_t next_thread = (current_thread + 1) % num_threads; + while (thread_table[next_thread].state != THREAD_READY) { + next_thread = (next_thread + 1) % num_threads; + } - if (next_thread != current_thread) { - current_thread = next_thread; - context_switch(&thread_table[current_thread]); - } + if (next_thread != current_thread) { + current_thread = next_thread; + context_switch(&thread_table[current_thread]); + } } -// Context switch to the next thread (assembly would go here to save/load registers) -void context_switch(Thread *next) { - // For simplicity, context switching in this example would involve saving/restoring registers. - // In a real system, you would need to save the CPU state (registers) and restore the next thread's state. - my_printf("Switching to thread...\n"); - next->start_routine(next->arg); // Start running the next thread +// Context switch to the next thread (assembly would go here to save/load +// registers) +void context_switch(Thread* next) { + // For simplicity, context switching in this example would involve + // saving/restoring registers. In a real system, you would need to save the + // CPU state (registers) and restore the next thread's state. + my_printf("Switching to thread...\n"); + next->start_routine(next->arg); // Start running the next thread } // Simple mutex functions (spinlock) -void mutex_init(void) { - mutex_locked = 0; -} +void mutex_init(void) { mutex_locked = 0; } void mutex_lock(void) { - while (__sync_lock_test_and_set(&mutex_locked, 1)) { - // Busy wait (spinlock) - } + while (__sync_lock_test_and_set(&mutex_locked, 1)) { + // Busy wait (spinlock) + } } -void mutex_unlock(void) { - __sync_lock_release(&mutex_locked); -} +void mutex_unlock(void) { __sync_lock_release(&mutex_locked); } diff --git a/kernel/utils.h b/kernel/utils.h index 0c25890..cb4d566 100644 --- a/kernel/utils.h +++ b/kernel/utils.h @@ -9,6 +9,4 @@ char* itoa(int value, char* str, int base); // Convert unsigned integer to string (base is typically 10, 16, etc.) char* utoa(unsigned int value, char* str, int base); -void *memset(void *dest, int value, size_t len); - #endif // UTILS_H