feature (proc): processes have now an executable and a own page_map

kernel/inc/proc/process.h

@@ -26,6 +26,8 @@
 
 #include "utils/stdtypes.h"
 #include "utils/string.h"
+#include "mm/page_map.h"
+#include "drivers/elf/elf.h"
 
 typedef uint32_t pid_t;
 
@@ -35,23 +37,27 @@ typedef enum {
 } processes_standard_E;
 
 typedef struct process_T process_T;
-struct process_T{
+struct process_T {
-    char            name        [128];
+    char                name        [128];
-    pid_t           id;
+    pid_t               id;
-    void*           chunk;
+    void*               chunk;
-    uint32_t        chunk_id;
+    uint32_t            chunk_id;
 
-    uint32_t    num_threads;
+    page_map_T*         page_map;
-    void*           threads;
+    elf_executable_T*   executable;
 
-    process_T*      parent;
+    uint32_t        num_threads;
-    process_T*      childs;
+    void*               threads;
-    process_T*      prev;
+
-    process_T*      next;
+    process_T*          parent;
+    process_T*          childs;
+    process_T*          prev;
+    process_T*          next;
 };
 
-pid_t   process_spawn       (pid_t parent, string_t name);
+void    process_kernel_spawn    (elf_executable_T* executable);
-void    process_kill_pid    (pid_t pid);
+pid_t   process_spawn           (pid_t parent, string_t name, elf_executable_T* executable, void* buffer);
-void    process_kill        (process_T* process);
+void    process_kill_pid        (pid_t pid);
+void    process_kill            (process_T* process);
 
 #endif //NOX_PROCESS_H

kernel/inc/proc/scheduler.h

@@ -27,6 +27,7 @@
 #include "proc/thread.h"
 #include "proc/process.h"
 #include "utils/bitmap.h"
+#include "boot/boot_info.h"
 
 #define SCHEDULER_PROCESS_CHUNK_SIZE 64
 
@@ -51,7 +52,7 @@ typedef struct {
     bool                            initialized;
 } scheduler_T;
 
-void            scheduler_init                      ();
+void            scheduler_init                      (boot_info_T* boot_info);
 cpu_state_T*    scheduler_start                     (cpu_state_T* state);
 bool            scheduler_is_initialized            ();
 void            scheduler_dump_info                 (process_T* process, uint8_t indent);

kernel/src/kmain.c

@@ -33,8 +33,6 @@
 #include "drivers/fs/vfs.h"
 #include "proc/scheduler.h"
 
-#include "drivers/elf/elf.h"
-
 void limine_terminal_print(boot_info_T* boot_info, string_t string) {
     boot_info->terminal->write(boot_info->terminal->terminals[0], string, string_length(string));
 }
@@ -74,27 +72,13 @@ void kernel_init(boot_info_T* boot_info) {
     limine_terminal_print(boot_info, " ok\n");
 
     limine_terminal_print(boot_info, "    Initializing scheduler...");
-    scheduler_init();
+    scheduler_init(boot_info);
     limine_terminal_print(boot_info, " ok\n");
 }
 
-#include "utils/io.h"
+void test() {
-
+    while(1) {
-void test1() {
+        int x = 0 / 0;
-    while (true) {
-        io_out_byte(LOG_PORT, 'A');
-    }
-}
-
-void test2() {
-    while (true) {
-        io_out_byte(LOG_PORT, 'B');
-    }
-}
-
-void test3() {
-    while (true) {
-        io_out_byte(LOG_PORT, 'C');
     }
 }
 
@@ -108,20 +92,23 @@ void kmain(boot_info_T boot_info) {
     limine_terminal_print(&boot_info, "Kernel initialized\n");
     log(LOG_INFO, "!=====[ Kernel Initialized ]=====!\n");
 
-    elf_init_kernel_exec(&boot_info);
 
-    pid_t proc1 = process_spawn(PROCESS_KERNEL, "test_1");
+//    pid_t proc1 = process_spawn(PROCESS_KERNEL, "test_1");
+//
+//    pid_t proc1_1 = process_spawn(proc1, "test_1-1");
+//    thread_spawn(proc1_1, NULL);
+//    pid_t proc1_2 = process_spawn(proc1, "test_1-2");
+//
+//    pid_t proc2 = process_spawn(PROCESS_KERNEL, "test_2");
 
-    pid_t proc1_1 = process_spawn(proc1, "test_1-1");
+    thread_T* thread = thread_spawn(PROCESS_KERNEL, test);
-    thread_spawn(proc1_1, NULL);
-    pid_t proc1_2 = process_spawn(proc1, "test_1-2");
 
-    pid_t proc2 = process_spawn(PROCESS_KERNEL, "test_2");
+    scheduler_start_thread(thread);
 
     scheduler_dump_info(scheduler_get_process(PROCESS_KERNEL), 0);
 
-    process_kill_pid(proc1);
+//    process_kill_pid(proc1);
-    scheduler_dump_info(scheduler_get_process(PROCESS_KERNEL), 0);
+//    scheduler_dump_info(scheduler_get_process(PROCESS_KERNEL), 0);
 
 //    vfs_node_T* node = vfs_resolve_path(&g_root_fs, "/initrd/test.elf");
 //

kernel/src/proc/process.c

@@ -26,14 +26,34 @@
 #include "utils/memory.h"
 #include "utils/math.h"
 
-pid_t process_spawn(pid_t parent, string_t name) {
+void process_kernel_spawn(elf_executable_T* executable) {
+    process_T* process = memory_allocate(sizeof(process_T));
+    process->num_threads = 0;
+    process->threads     = NULL;
+    process->parent      = NULL;
+    process->executable  = executable;
+
+    memory_copy("kernel", process->name, 7);
+
+    process->page_map = g_kernel_page_map;
+
+    // the processes' id, chunk_id and chunk fields will be set by the scheduler
+
+    scheduler_register_process(process);
+}
+
+pid_t process_spawn(pid_t parent, string_t name, elf_executable_T* executable, void* buffer) {
     process_T* process = memory_allocate(sizeof(process_T));
     process->num_threads = 0;
     process->threads     = NULL;
     process->parent      = scheduler_get_process(parent);
+    process->executable  = executable;
 
     memory_copy(name, process->name, MIN(string_length(name), 127));
 
+    process->page_map = page_map_create();
+    elf_mappings_apply(executable->mappings, executable->num_mappings, buffer, 0, process->page_map);
+
     // the processes' id, chunk_id and chunk fields will be set by the scheduler
 
     return scheduler_register_process(process);
@@ -46,5 +66,7 @@ void process_kill_pid(pid_t pid) {
 void process_kill(process_T* process) {
     scheduler_kill_process(process);
 
+    page_map_destruct(process->page_map);
+
     memory_free(process);
 }

kernel/src/proc/scheduler.c

@@ -66,7 +66,7 @@ scheduler_processes_chunk_T* scheduler_processes_chunk_create(scheduler_processe
     return chunk;
 }
 
-void scheduler_init() {
+void scheduler_init(boot_info_T* boot_info) {
     g_scheduler.num_threads     = 0;
     g_scheduler.num_processes   = 0;
     g_scheduler.running_thread  = NULL;
@@ -76,13 +76,13 @@ void scheduler_init() {
 
     g_scheduler_info_buffer = graphics_buffer_request(graphics_renderer_get_width()-100, 0, 100, 200, GRAPHICS_BUFFER_STANDARD);
 
+    process_kernel_spawn(elf_executable_create(boot_info->kernel_file->address));
+
     syscall_perform(SYSCALL_KERNEL_SCHEDULER_START);
 }
 
 cpu_state_T* scheduler_start(cpu_state_T* state) {
 
-    process_spawn(PROCESS_NONE, "kernel");
-
     thread_T* thread = thread_spawn_from_state(PROCESS_KERNEL, state);
     thread->global_prev = thread;
     thread->global_next = thread;
@@ -292,11 +292,20 @@ process_T* scheduler_get_process(pid_t pid) {
 }
 
 thread_T* scheduler_get_current_thread() {
+    if (!g_scheduler.initialized) {
+        return NULL;
+    }
+
     return g_scheduler.running_thread;
 }
 
 process_T* scheduler_get_current_process() {
-    return g_scheduler.running_thread->process;
+    thread_T* thread = scheduler_get_current_thread();
+    if (thread == NULL) {
+        return NULL;
+    }
+
+    return thread->process;
 }
 
 cpu_state_T* scheduler_switch_context(cpu_state_T* state) {

kernel/src/proc/thread.c

@@ -43,7 +43,7 @@ thread_T* thread_spawn(pid_t process, void* function) {
     thread->cpu_time   = 0;
 
     thread->state = (cpu_state_T){
-            .cr3 = (uint64_t)g_kernel_page_map,
+            .cr3 = (uint64_t)thread->process->page_map,
             .rax = 0,
             .rbx = 0,
             .rcx = 0,