From ab9873fb6f315645bc68252cd098194e40c12d97 Mon Sep 17 00:00:00 2001 From: notsomeidiot123 Date: Tue, 19 Nov 2024 14:19:19 -0500 Subject: [PATCH] Scheduler Fixed --- src/kernel/arch_i386/idt.s | 1 + src/kernel/kmain.c | 18 ++++-- src/kernel/system/scheduler.c | 109 +++++++++++++++++++++++++--------- src/kernel/system/scheduler.h | 9 ++- 4 files changed, 100 insertions(+), 37 deletions(-) diff --git a/src/kernel/arch_i386/idt.s b/src/kernel/arch_i386/idt.s index 1fcd3e9..4a0c2c8 100644 --- a/src/kernel/arch_i386/idt.s +++ b/src/kernel/arch_i386/idt.s @@ -351,6 +351,7 @@ _irq_common_stub: pop ds popad add esp, 8 + ; sti iret global panic_hold diff --git a/src/kernel/kmain.c b/src/kernel/kmain.c index f51e02f..b4a66ef 100644 --- a/src/kernel/kmain.c +++ b/src/kernel/kmain.c @@ -10,14 +10,18 @@ void test(){ printf("Hello from thread!\n"); // thread_exit(1); + // enable_interrupts(); + // asm volatile ("jmp ."); + for(;;); } void test1(){ - printf("Hello from thread1!\n"); - uint32_t exit_code = -1; - uint32_t pid = thread_start(test); - // for(;;); - printf("Start"); - // printf("PID: %d", pid); + // printf("Hello from thread1!\n"); + uint16_t *test = (void *)0xb8000; + *test = 0x0f41; + for(;;); + // asm +} +void dead_proc(){ for(;;); } extern void kmain(kernel_info_t *kernel_info){ @@ -31,6 +35,8 @@ extern void kmain(kernel_info_t *kernel_info){ //TODO: Start Initial Process uint32_t exit_code = -1; init_scheduler(); + thread_start(dead_proc); + thread_start(test); thread_start(test1); enable_interrupts(); for(;;); diff --git a/src/kernel/system/scheduler.c b/src/kernel/system/scheduler.c index 607b27f..7ba8613 100644 --- a/src/kernel/system/scheduler.c +++ b/src/kernel/system/scheduler.c @@ -4,14 +4,21 @@ #include "../shared/kstdlib.h" #include "../shared/memory.h" -process_t volatile processes[0x10000]; -uint32_t volatile process_queue[0x10000]; +volatile process_t *processes; +volatile uint32_t process_queue[PROCESS_COUNT]; uint32_t volatile active_processes; uint32_t volatile current_pid; uint32_t volatile queue_length; uint32_t volatile current_queue_index; void init_scheduler(){ + // printf("?"); + // process_queue = kmalloc((PROCESS_COUNT * sizeof(uint32_t)) / 4096); + processes = kmalloc((PROCESS_COUNT * sizeof(process_t)) / 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 < 0x10000; i++){ + // printf("Index: %x, %d\n", process_queue, sizeof(process_t)); processes[i].flags.present = 0; process_queue[i] = 0; } @@ -19,30 +26,48 @@ void init_scheduler(){ queue_length = 0; current_queue_index = 0; active_processes = 0; + // printf("Init :3"); install_irq_handler(schedule, 0); // printf("Installing scheduler"); } cpu_registers_t *schedule(cpu_registers_t *regs){ - if(queue_length == 0){ - return regs; + // if(queue_length == 0){ + // return regs; + // } + uint32_t i = 0; + processes[current_pid].cpuregs = *regs; + processes[process_queue[current_queue_index]].flags.ran = 1; + uint32_t run_count = 0; + for(uint32_t i = 0; i < queue_length; i++){ + run_count += processes[process_queue[i]].flags.ran; } - uint32_t i = current_queue_index; - for(; i < queue_length; i++){ - if(processes[process_queue[i%queue_length]].flags.blocked) continue; - else break; + if(run_count == queue_length){ + for(uint32_t i = 0; i < queue_length; i++){ + processes[process_queue[i]].flags.ran = 0; + } + current_queue_index = 0; } - current_pid = process_queue[i]; - // printf("\n%d", current_pid); - // *regs = processes[current_pid].cpuregs; + else{ + current_queue_index++; + } + current_pid = process_queue[current_queue_index]; + asm volatile("mov %0, %%cr3" : : "r"(processes[current_pid].page_dir)); + 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; - // return regs; } 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); + return; } void remove_process_queue(uint32_t pid){ uint32_t last_queue_index = queue_length-1; @@ -58,16 +83,15 @@ void remove_process_queue(uint32_t pid){ process_queue[last_queue_index] = 0; } -void spawn_new_process(cpu_registers_t defaultregs, char **argv, uint32_t argc, void *cr3){ +uint32_t spawn_new_process(cpu_registers_t defaultregs, char **argv, uint32_t argc, void *cr3){ uint32_t i = current_pid; while(processes[i].flags.present){ i++; if(i >= 0x10000) i = 0; - if(i == current_pid) return; + if(i == current_pid) return -1; } - i += !active_processes; + // i += !active_processes; active_processes++; - // printf("Found %d", i); process_t new_proc = {0}; new_proc.argc = argc; new_proc.argv = argv; @@ -80,34 +104,61 @@ void spawn_new_process(cpu_registers_t defaultregs, char **argv, uint32_t argc, new_proc.flags.system = processes[current_pid].flags.system; processes[i] = new_proc; add_process_queue(i); - return; + return i; } void fork(){ - + //make a copy of original process, create new address space, + //and copy all page entries with write disabled + //(so we con perform a copy on write) } -void exec(){ - +void exec(char *filename, char **argv){ + //open and read file {filename} + //then create a new address space, parse elf header and create + //a new schedulable entity } -void exit(){ - +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); + for(uint32_t i = 0; i < 1024; i++){ + map(pt_ptr, (void *)pd_ptr[i], PT_PRESENT); + for(uint32_t j = 0; j < 1024; j++){ + uint32_t pt_paddr = pt_ptr[j] & ~(0xfff); + pm_free(pt_paddr); + } + unmap(pt_ptr); + } + processes[pid].flags.present = 0; + processes[pid].page_dir = 0; + remove_process_queue(pid); } -void thread_start(void (*function)(), uint32_t *exit_code){ +uint32_t thread_start(void (*function)()){ cpu_registers_t regs = {0}; regs.cs = 0x10; regs.ds = 0x18; regs.es = 0x18; regs.ss = 0x18; + regs.eflags = 0x202; // regs.ebp = - regs.esp = 0x7000 - sizeof(regs) + 8; + regs.esp = (uint32_t)kmalloc(8) - sizeof(regs) + 8; regs.ebp = regs.esp; regs.eip = (uint32_t)function; memcpy((char *)®s, (char*)regs.esp, sizeof(regs)); - spawn_new_process(regs, 0, 0, (void *)0x10000); + uint32_t retpid = spawn_new_process(regs, 0, 0, (void *)0x10000); + // printf("returning :3"); + // for(;;); + return retpid; } -void thread_join(uint32_t thread_id, uint32_t **exit_code){ - +void thread_join(uint32_t thread_id, uint32_t *exit_code){ + while(processes[thread_id].flags.present); + *exit_code = processes[thread_id].exit_value; } -void thread_exit(uint32_t *exit_code){ - +void thread_exit(uint32_t exit_code){ + processes[current_pid].flags.present = 0; + processes[current_pid].exit_value = exit_code; + remove_process_queue(current_pid); } \ No newline at end of file diff --git a/src/kernel/system/scheduler.h b/src/kernel/system/scheduler.h index 651bca6..8e78179 100644 --- a/src/kernel/system/scheduler.h +++ b/src/kernel/system/scheduler.h @@ -12,14 +12,19 @@ typedef struct{ uint8_t cpu_lvl :1; uint8_t priority:3; uint8_t present :1; - uint8_t unused :1; + uint8_t ran :1; }flags; + uint32_t exit_value; uint32_t thread_id; uint32_t parent; uint32_t uid; uint32_t gid; }process_t; +#define PROCESS_COUNT 0x10000 + cpu_registers_t* schedule(cpu_registers_t *regs); void init_scheduler(); -void thread_start(void (*function)(), uint32_t *exit_code); \ No newline at end of file +uint32_t thread_start(void (*function)()); +void thread_join(uint32_t thread_id, uint32_t *exit_code); +void thread_exit(uint32_t exit_code); \ No newline at end of file