tasks now take data and a destructor fn

Author: no382001

TODO

@@ -67,6 +67,8 @@ TODO:
   [x] usan
   [ ] asan
   [x] watchdog for thread stack and kheap magic
-  [ ] more comprehensive thread reg/unreg
+  [x] more comprehensive thread reg/unreg
+  [ ] kfree corruption
   [ ] thread the ehternet packets
-  [ ] add some log groups for debugging
+  [ ] add some log groups for debugging
+  [ ] write a readme and collect main features and quirks

cpu/task.c

@@ -20,14 +20,19 @@ void switch_stack_and_jump(uint32_t stack, uint32_t task);
 void switch_stack(uint32_t esp, uint32_t ebp);
 extern semaphore_t task_semaphore;
 
-void task_wrapper(task_function_t f) {
+void task_wrapper(task_fn_t f) {
   (void)f;
   serial_debug("task %d fired!", current_task_idx);
-  task_function_t fn = tasks[current_task_idx].task;
-  fn();
+  task_fn_t fn = tasks[current_task_idx].f;
+  fn(tasks[current_task_idx].data);
 
   asm volatile("cli");
 
+  task_destructor_fn_t df = tasks[current_task_idx].df;
+  if (df) {
+    df(tasks[current_task_idx].df_data);
+  }
+
   tasks[current_task_idx].status = TASK_DEAD;
   active_tasks--;
   serial_debug("task %d completed, now %d active tasks", current_task_idx,
@@ -36,7 +41,6 @@ void task_wrapper(task_function_t f) {
   asm volatile("sti");
   // asm volatile("int $0x20");
 
-  // should be never reached
   while (1) {
     asm volatile("hlt");
   }
@@ -84,10 +88,26 @@ bool check_stack_overflow(int task_id) {
   return (*(uint32_t *)stack_bottom != STACK_CANARY);
 }
 
-void create_task(int task_id, char *name, task_function_t f, void *stack,
-                 uint32_t stack_size) {
+int find_next_task_slot() {
+  for (int i = 1; i < MAX_TASK; i++) {
+    if (tasks[i].status == TASK_INACTIVE || tasks[i].status == TASK_DEAD) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+void create_task(char *name, task_fn_t f, void *data, task_destructor_fn_t df,
+                 void *df_data, void *stack, uint32_t stack_size) {
+  assert(f && stack);
   asm volatile("cli");
 
+  int task_id = find_next_task_slot();
+  if (task_id == -1) {
+    assert(0 && "no more slots for tasks");
+    asm volatile("sti");
+    return;
+  }
   task_t task = {0};
   assert(strlen(name) <= 16);
   memcpy(task.name, name, strlen(name));
@@ -112,7 +132,10 @@ void create_task(int task_id, char *name, task_function_t f, void *stack,
   // push parameter for task_wrapper
   task.esp -= 4;
   *(uint32_t *)task.esp = (uint32_t)f;
-  task.task = f;
+  task.f = f;
+  task.data = data;
+  task.df = df;
+  task.df_data = df_data;
   task.ebp = stack_top;
   task.stack_size = stack_size;
 
@@ -150,14 +173,13 @@ void init_tasking() {
 
   memcpy(tasks[0].name, "main", 5);
   tasks[0].status = TASK_RUNNING;
-  tasks[0].task = NULL;
 
   current_task_idx = 0;
   active_tasks = 1;
 
   void *ss = kmalloc(1024);
-  create_task(1, "task_stack_check", task_stack_check, ss, 1024);
+  create_task("task_stack_check", task_stack_check, ss, 0, 0, 0, 1024);
 
   void *s2 = kmalloc(5000);
-  create_task(2, "kheap_watchdog", kheap_watchdog, s2, 5000);
+  create_task("kheap_watchdog", kheap_watchdog, s2, 0, 0, 0, 5000);
 }

cpu/task.h

@@ -11,11 +11,15 @@ typedef enum {
   TASK_RUNNING
 } task_status_t;
 
-typedef void (*task_function_t)(void);
+typedef void (*task_fn_t)(void *);
+typedef void (*task_destructor_fn_t)(void *);
 typedef struct {
   char name[16];
   task_status_t status;
-  task_function_t task; // i dont actually use this for anything
+  task_fn_t f;
+  void *data;
+  task_destructor_fn_t df;
+  void *df_data;
   uint32_t ebp, esp;
   registers_t ctx;
   uint32_t stack_size;
@@ -27,5 +31,5 @@ typedef struct {
 void schedule(registers_t *regs);
 
 void init_tasking();
-void create_task(int task_id, char *name, task_function_t f, void *stack,
-                 uint32_t stack_size);
+void create_task(char *name, task_fn_t f, void *data, task_destructor_fn_t df,
+                 void *df_data, void *stack, uint32_t stack_size);

kernel/kernel.c

@@ -8,11 +8,16 @@ semaphore_t task_semaphore = {0};
 
 static volatile int sem = 0;
 
-static void sched_test_fn() {
+static void sched_test_fn(void *data) {
+  (void)data;
   // semaphore_signal(&selftest_sem);
-  kernel_printf("sched_test_fn ");
   sem = 1;
-  kernel_printf("this is now %d\n", sem);
+  kernel_printf("- scheduler looks good\n");
+  return;
+}
+
+static void sched_test_dfn(void *df_data) {
+  kfree(df_data);
   return;
 }
 
@@ -31,17 +36,17 @@ void selftest() {
   assert(t1 != t2 && "ticks are the same");
   kernel_printf("- ticks are good...\n");
 
-  uint32_t ss = 1024;
+  uint32_t ss = 1025;
   void *fnstack = kmalloc_a(ss);
-  create_task(3, "sched_test", &sched_test_fn, fnstack, ss);
+  create_task("sched_test", &sched_test_fn, fnstack, &sched_test_dfn, fnstack,
+              0, ss);
   int i = 1000000;
   while (1 != sem) {
     i--;
     if (i < 0) {
       assert("scheduler timed out");
     }
   }
-  kfree(fnstack);
   serial_debug("selftest finished!");
 }
 

libc/heap.c

@@ -318,7 +318,8 @@ void *kmalloc_ap(uint32_t size, uint32_t *phys) {
 
 void *kmalloc(uint32_t size) { return kmalloc_int(size, 0, 0); }
 
-void kheap_watchdog() {
+void kheap_watchdog(void *data) {
+  (void)data;
   serial_debug("heap watchdog started");
 
   while (1) {

net/rtl8139.c

@@ -21,7 +21,6 @@ void receive_packet() {
 
   // skip, packet header and packet length, now t points to the packet data
   t = t + 2;
-  // qemu_printf("Printing packet at addr 0x%x\n", (uint32_t)t);
 
   // now, ethernet layer starts to handle the packet(be sure to make a copy of
   // the packet, insteading of using the buffer) and probabbly this should be