WIP on kernel syscalls

include/context.h

@@ -1,10 +1,10 @@
 #pragma once
 
 #include "pageallocator.h"
-#include "process.h"
+#include "kernel.h"
 
 void *initialize_context(void *task_entry, struct page_stack_t *page_stack);
 
-void save_context(struct process_state_t *context, void *ptr);
+void save_context(struct process_context_t *context, void *ptr);
 
-void load_context(struct process_state_t *context);
+void load_context(struct process_context_t *context);

include/kernel.h

@@ -4,26 +4,41 @@
 #include "priorityqueue.h"
 #include "resource.h"
 #include "module.h"
-#include "process.h"
 #include "memorymap.h"
+#include "syscallid.h"
 #include <stddef.h>
 
-enum syscall_id_t
+typedef size_t (*syscall_t)(struct kernel_t*, size_t, size_t, size_t);
+
+enum process_state_t
 {
-    SYSCALL_TEST = 1,
+    PROCESS_ACTIVE,
-    SYSCALL_YIELD,
+    PROCESS_WAITING
-    SYSCALL_MMAP,
-    SYSCALL_MUNMAP
 };
 
-typedef size_t (*syscall_t)(struct kernel_t*, size_t, size_t, size_t);
+struct process_context_t;
+
+struct message_t
+{
+    uint16_t sender, type;
+    uint32_t param1, param2, param3;
+};
+
+struct process_t
+{
+    size_t priority;
+    size_t resource_id;
+    physaddr_t page_table;
+    struct process_context_t *state;
+    struct message_t *message;
+};
 
 struct kernel_t
 {
     struct page_stack_t *page_stack;
     struct priority_queue_t *priority_queue;
-    struct process_t *active_process;
     struct resource_table_t *resource_table;
+    struct process_t *active_process;
 };
 
 extern syscall_t syscall_table[32];
@@ -38,6 +53,12 @@ size_t do_syscall(struct kernel_t *kernel, enum syscall_id_t id, size_t arg1, si
 
 int load_module(struct kernel_t *kernel, struct module_t *module);
 
-struct process_state_t *next_process(struct kernel_t *kernel, struct process_state_t *prev_state);
+struct process_context_t *next_process(struct kernel_t *kernel, struct process_context_t *prev_state);
+
+int terminate_process(struct kernel_t *kernel, size_t process_id);
+
+int accept_message(struct kernel_t *kernel, size_t process_id, struct message_t *message);
+
+int send_message(struct kernel_t *kernel, size_t process_id, const struct message_t *message);
 
 void panic(const char *message) __attribute__ ((noreturn));

include/mmgr.h

@@ -70,3 +70,11 @@ physaddr_t unmap_page(void *page);
  * @return enum page_type_t 
  */
 enum page_type_t page_type(void *page);
+
+/**
+ * @brief 
+ * 
+ * @param linear_address 
+ * @return physaddr_t 
+ */
+physaddr_t physical_address(void *linear_address);

include/priorityqueue.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "pageallocator.h"
-#include "process.h"
+#include "kernel.h"
 #include <stddef.h>
 
 /**

include/process.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include "types/physaddr.h"
-#include <stddef.h>
-
-struct process_state_t;
-
-struct process_t
-{
-    size_t priority;
-    struct process_state_t *state;
-    physaddr_t page_table;
-};

include/resource.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "pageallocator.h"
-#include "process.h"
+#include "kernel.h"
 #include <stddef.h>
 
 enum resource_type_t

include/syscallid.h

@@ -0,0 +1,10 @@
+#pragma once
+
+enum syscall_id_t
+{
+    SYSCALL_TEST = 1,
+    SYSCALL_YIELD,
+    SYSCALL_MMAP,
+    SYSCALL_MUNMAP,
+    SYSCALL_TERMINATE_SELF
+};

include/syscalls.h

@@ -7,3 +7,5 @@ size_t test_syscall(struct kernel_t *kernel, size_t arg1, size_t arg2, size_t ar
 size_t mmap(struct kernel_t *kernel, size_t location, size_t length, size_t flags);
 
 size_t munmap(struct kernel_t *kernel, size_t location, size_t length, size_t arg3);
+
+size_t terminate_self(struct kernel_t *kernel, size_t arg1, size_t arg2, size_t arg3)

include/types/status.h

@@ -9,5 +9,6 @@ enum status_t
     S_OUT_OF_MEMORY,
     S_DOESNT_EXIST,
     S_EXISTS,
-    S_BAD_SYSCALL
+    S_BAD_SYSCALL,
+    S_BUSY
 };

include/x86/processstate.h

@@ -4,7 +4,7 @@
 
 #define PCB_LOCATION 0x800
 
-struct process_state_t
+struct process_context_t
 {
     uint32_t eax;
     uint32_t ebx;

rootfs/boot/grub/grub.cfg

@@ -2,4 +2,6 @@ menuentry "Quark OS" {
     multiboot2 /apps/quark-kernel
     module2 /apps/quark-testmod
     module2 /apps/quark-testmod
+    module2 /apps/quark-testmod
+    module2 /apps/quark-testmod
 }

src/kernel.c

@@ -3,6 +3,7 @@
 #include "stdio.h"
 #include "elf.h"
 #include "context.h"
+#include "string.h"
 #include "types/status.h"
 
 syscall_t syscall_table[32];
@@ -79,13 +80,14 @@ int load_module(struct kernel_t *kernel, struct module_t *module)
     }
     kernel->resource_table->array[index].type = RESOURCE_PROCESS;
     kernel->resource_table->array[index].process.priority = 1;
+    kernel->resource_table->array[index].process.resource_id = index;
     kernel->resource_table->array[index].process.state = module_context;
     kernel->resource_table->array[index].process.page_table = current_address_space();
     queue_insert(kernel->priority_queue, &kernel->resource_table->array[index].process);
     return S_OK;
 }
 
-struct process_state_t *next_process(struct kernel_t *kernel, struct process_state_t *prev_state)
+struct process_context_t *next_process(struct kernel_t *kernel, struct process_context_t *prev_state)
 {  
     if(prev_state != NULL)
     {
@@ -102,6 +104,79 @@ struct process_state_t *next_process(struct kernel_t *kernel, struct process_sta
     panic("no processes available to enter!");
 }
 
+int terminate_process(struct kernel_t *kernel, size_t process_id)
+{
+    if(kernel == NULL)
+    {
+        return S_NULL_POINTER;
+    }
+    else if(kernel->resource_table->limit >= process_id)
+    {
+        return S_OUT_OF_BOUNDS;
+    }
+    else if(kernel->resource_table->array[process_id].type != RESOURCE_PROCESS)
+    {
+        return S_INVALID_ARGUMENT;
+    }
+    struct process_t *process = &kernel->resource_table->array[process_id].process;
+    kernel->resource_table->array[process_id].type = RESOURCE_UNAVAILABLE;
+    if(kernel->active_process == process)
+    {
+        kernel->active_process = NULL;
+    }
+    queue_remove(kernel->priority_queue, process);
+    return S_OK;
+}
+
+int accept_message(struct kernel_t *kernel, size_t process_id, struct message_t *message)
+{
+    if(kernel == NULL || message == NULL)
+    {
+        return S_NULL_POINTER;
+    }
+    else if(kernel->resource_table->limit >= process_id)
+    {
+        return S_OUT_OF_BOUNDS;
+    }
+    else if(kernel->resource_table->array[process_id].type != RESOURCE_PROCESS)
+    {
+        return S_INVALID_ARGUMENT;
+    }
+    struct process_t *process = &kernel->resource_table->array[process_id].process;
+    process->state = PROCESS_WAITING;
+    process->message = message;
+    if(kernel->active_process == process)
+    {
+        kernel->active_process = NULL;
+    }
+    queue_remove(kernel->priority_queue, process);
+    return S_OK;
+}
+
+int send_message(struct kernel_t *kernel, size_t process_id, const struct message_t *message)
+{
+    if(kernel == NULL || message == NULL)
+    {
+        return S_NULL_POINTER;
+    }
+    else if(kernel->resource_table->limit >= process_id)
+    {
+        return S_OUT_OF_BOUNDS;
+    }
+    else if(kernel->resource_table->array[process_id].type != RESOURCE_PROCESS)
+    {
+        return S_INVALID_ARGUMENT;
+    }
+    struct process_t *process = &kernel->resource_table->array[process_id].process;
+    if(process->state != PROCESS_WAITING || process->message == NULL)
+    {
+        return S_BUSY;
+    }
+    queue_insert(kernel->priority_queue, kernel->active_process);
+    struct message_t buffer = *message;
+
+}
+
 void panic(const char *message)
 {
     printf("panic: %s", message);

src/syscalls.c

@@ -81,3 +81,8 @@ size_t munmap(struct kernel_t *kernel, size_t location, size_t length, size_t ar
     }
     return status;
 }
+
+size_t terminate_self(struct kernel_t *kernel, size_t arg1, size_t arg2, size_t arg3)
+{
+    return terminate_process(kernel, kernel->active_process->resource_id);
+}

src/x86/context.c

@@ -14,7 +14,7 @@ void *initialize_context(void *task_entry, struct page_stack_t *page_stack)
         "mov (%%esp), %0; "
         "popf; "
         : "=r"(flags));
-    struct process_state_t *state = (struct process_state_t*)PCB_LOCATION;
+    struct process_context_t *state = (struct process_context_t*)PCB_LOCATION;
     memset(NULL, 0, page_size);
     state->cs = 0x1B;
     state->eip = (uint32_t)task_entry;