raeofsunshine
/
KimisOS
mirror of https://github.com/raeofsunshinedev/KimisOS.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Changed scheduler.c/kill() away from using old trick to using new kmalloc_page_paddr(uint32_t, uint32_t) function

This commit is contained in:
notsomeidiot123 2026-02-02 02:23:01 -05:00
parent d16c1c68af
commit 806e011256
4 changed files with 14 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
c_build_helper.sh
View File

@ -4,7 +4,7 @@ LDFLAGS_i386="-Ttext 0xc0000000 --oformat binary -melf_i386"
cd src/kernel/
gcc kmain.c $CFLAGS -o ../../bin/kernel/kmain.o
for d in ./*/; do
if [ "$d" != "./obj/" ]; then
if [[ "$d" != "./obj/" ]]; then
echo "\033[1;32mCompiling files in $d\033[0m"
for f in $d*.c; do
echo -e "\033[1;36mfile: $f\033[0m"

14
src/kernel/arch_i386/memory.c
View File

@ -174,12 +174,10 @@ void *get_new_page(uint32_t flags){
map((void *)paddr+(i*4096), (void *)paddr, flags);
}
void *kmalloc(uint32_t size_pgs){
// static uint8_t fake = 0;
uint32_t i = 0xc0000000 >> 12; //4mb/4096 (start search at 1mb line)
while(i < (1 << 22)){
uint8_t found = 1;
for(uint32_t j = 0; j < size_pgs; j++){
// printf("found at %x, %x\n", (i + j) << 12, get_paddr((void*)((i + j) << 12)));
if(get_pflags((void *)((i + j) << 12))){
found = 0;
break;
@ -192,13 +190,8 @@ void *kmalloc(uint32_t size_pgs){
for(uint32_t j = 0; j < size_pgs; j++){
uint32_t flags = PT_PRESENT | PT_SYS | (PT_LINK_L * (j != 0)) | (PT_LINK_N * (j < (size_pgs - 1)) | PT_PCD);
uint32_t physaddr = pm_alloc();
// if(j == 0) printf("%x", physaddr);
// printf("Mapping %x to %x\n", (i + j) << 12, physaddr);
// if(fake) return 0;
map((void *)((i + j) << 12), (void*)physaddr, flags);
}
// fake = !fake;
// for(;;);
return (void*)(i << 12);
}
return 0;
@ -208,7 +201,6 @@ void *kmalloc_page_paddr(uint32_t paddr, uint32_t size_pgs){
while(i < (1 << 22)){
uint8_t found = 1;
for(uint32_t j = 0; j < size_pgs; j++){
// printf("found at %x, %x\n", (i + j) << 12, get_paddr((void*)((i + j) << 12)));
if(get_pflags((void *)((i + j) << 12))){
found = 0;
break;
@ -221,13 +213,9 @@ void *kmalloc_page_paddr(uint32_t paddr, uint32_t size_pgs){
for(uint32_t j = 0; j < size_pgs; j++){
uint32_t flags = PT_PRESENT | PT_SYS | (PT_LINK_L * (j != 0)) | (PT_LINK_N * (j < (size_pgs - 1)) | PT_PCD);
uint32_t physaddr = paddr + j * 4096;
// if(j == 0) printf("%x", physaddr);
// printf("Mapping %x to %x\n", (i + j) << 12, physaddr);
// if(fake) return 0;
map((void *)((i + j) << 12), (void*)physaddr, flags);
}
// fake = !fake;
// for(;;);
return (void*)(i << 12);
}
}

3
src/kernel/shared/memory.h
View File

@ -85,4 +85,5 @@ inline void *get_cr3(){
int pm_init(kernel_info_t *kernel_info);
void *kmalloc(uint32_t size_pgs);//allocates in multiples of 4096
void *kfree(void *vaddr);
void *kfree(void *vaddr);
void *kmalloc_page_paddr(uint32_t paddr, uint32_t size_pgs);

43
src/kernel/system/scheduler.c
View File

@ -11,14 +11,8 @@ uint32_t volatile current_pid;
uint32_t volatile queue_length;
uint32_t volatile current_queue_index;
void scheduler_init(){
// printf("?");
// process_queue = kmalloc((PROCESS_COUNT * sizeof(uint32_t)) / 4096);
processes = kmalloc((PROCESS_COUNT * sizeof(process_t) + 4095) / 4096);
// process_queue = kmalloc(1);
// printf("%x, %x\n", (PROCESS_COUNT * sizeof(process_t)) / 4096, (PROCESS_COUNT * sizeof(uint32_t)) / 4096);
// printf("%x, %x\n", processes, process_queue);
for(uint32_t i = 0; i < PROCESS_COUNT; i++){
// printf("Index: %x, %d\n", process_queue, sizeof(process_t));
processes[i].flags.present = 0;
process_queue[i] = 0;
}
@ -26,9 +20,7 @@ void scheduler_init(){
queue_length = 0;
current_queue_index = 0;
active_processes = 0;
// printf("Init :3");
install_irq_handler(schedule, 0);
// printf("Installing scheduler");
}
uint32_t timer = 0;
@ -37,8 +29,6 @@ void add_process_queue(uint32_t pid){
asm volatile ("" : : :"memory");
process_queue[queue_length] = pid;
queue_length++;
// printf("adding %d @ %d", pid, queue_length-1);
// printf("queue: %x", queue_length);
asm("sti");
return;
}
@ -53,7 +43,7 @@ void remove_process_queue(uint32_t pid){
process_queue[i] = 0;
}
}
if(old_index == last_queue_index || old_index < queue_length){
if(old_index == last_queue_index || old_index < queue_length || old_index < PROCESS_COUNT){
asm("sti");
return;
}
@ -68,22 +58,15 @@ void remove_process_queue(uint32_t pid){
cpu_registers_t *schedule(cpu_registers_t *regs){
if(queue_length == 0){
add_process_queue(0);
// return regs;
}
// uint32_t i = 0;
processes[current_pid].cpuregs = *regs;
current_queue_index++;
if(current_queue_index >= queue_length){
current_queue_index = 0;
}
// current_pid = [current_queue_index]
current_pid = process_queue[current_queue_index];
asm volatile("mov %0, %%cr3" : : "r"(processes[current_pid].page_dir));
// printf("pid: %d, %d\n", run_count, queue_length);
cpu_registers_t *newregs = (cpu_registers_t*)processes[current_pid].cpuregs.esp;
// printf("EAX: %x EBX: %x ECX: %x EDX: %x\n", newregs->eax, newregs->ebx, newregs->ecx, newregs->edx);
// printf("ESI: %x EDI: %x ESP: %x EBP: %x\n", newregs->esi, newregs->edi, newregs->esp, newregs->ebp);
// printf("EIP: %x CS: %x DS: %x\n", newregs->eip, newregs->cs, newregs->ds);
return newregs;
}
@ -123,18 +106,20 @@ void exec(char *filename, char **argv){
}
void kill(uint32_t pid){
void *pd = processes[pid].page_dir;
uint32_t *pd_ptr = kmalloc(1);
uint32_t *pt_ptr = kmalloc(1);
kfree(pt_ptr);
kfree(pd_ptr);
map(pd_ptr, pd, PT_PRESENT);
// uint32_t *pd_ptr = kmalloc(1);
// uint32_t *pt_ptr = kmalloc(1);
// kfree(pt_ptr);
// kfree(pd_ptr);
// map(pd_ptr, pd, PT_PRESENT);
uint32_t *pd_ptr = kmalloc_page_paddr(pd, 1);
for(uint32_t i = 0; i < 1024; i++){
map(pt_ptr, (void *)pd_ptr[i], PT_PRESENT);
// map(pt_ptr, (void *)pd_ptr[i], PT_PRESENT);
uint32_t *pt_ptr = kmalloc_page_paddr((void *)pd_ptr[i], 1);
for(uint32_t j = 0; j < 1024; j++){
uint32_t pt_paddr = pt_ptr[j] & ~(0xfff);
pm_free(pt_paddr);
}
unmap(pt_ptr);
kfree(pt_ptr);
}
processes[pid].flags.present = 0;
processes[pid].page_dir = 0;
@ -159,23 +144,16 @@ uint32_t thread_start(void (*function)()){
regs.es = 0x18;
regs.ss = 0x18;
regs.eflags = 0x202;
// regs.ebp =
regs.esp = (uint32_t)kmalloc(8) - sizeof(regs) + 8;
regs.ebp = regs.esp;
regs.eip = (uint32_t)function;
memcpy((char *)&regs, (char*)regs.esp, sizeof(regs));
uint32_t retpid = spawn_new_process(regs, 0, 0, (void *)0x10000);
processes[retpid].parent = current_pid;
// printf("returning :3");
// for(;;);
return retpid;
}
void thread_join(uint32_t thread_id, uint32_t *exit_code){
asm volatile ("" : : :"memory");
// while(processes[thread_id].flags.present){
// // printf("%d", processes[thread_id].flags.present);
// };
// printf("Done");
set_pid_blocked(current_pid);
asm("int $32");
*exit_code = processes[thread_id].exit_value;
@ -185,6 +163,5 @@ void thread_exit(uint32_t exit_code){
processes[current_pid].exit_value = exit_code;
remove_process_queue(current_pid);
set_pid_unblocked(processes[current_pid].parent);
// printf("Exiting pid %d, %d\n", current_pid);
asm volatile ("int $32");//call scheduler via interrupt
}