Disable kernel preemption, fix requesting rescheduling

init/init.c

@@ -48,22 +48,23 @@ void app_main (void) {
   spawn (&app_thread1);
 
   for (;;) {
-    /* lock_mutex (MUTEX, RV_PRIVATE); */
+    lock_mutex (MUTEX, RV_PRIVATE);
 
     for (int i = 0; i < 3; i++)
       test ('a');
 
-    /* unlock_mutex (MUTEX, RV_PRIVATE); */
+    unlock_mutex (MUTEX, RV_PRIVATE);
   }
 }
 
 void app_thread1 (void) {
-  for (int i = 0; i < 3; i++)
-    test ('b');
   for (;;) {
-    /* lock_mutex (MUTEX, RV_PRIVATE); */
+    lock_mutex (MUTEX, RV_PRIVATE);
 
-    /* unlock_mutex (MUTEX, RV_PRIVATE); */
+    for (int i = 0; i < 3; i++)
+      test ('b');
+
+    unlock_mutex (MUTEX, RV_PRIVATE);
   }
 
   quit ();

kernel/amd64/apic.c

@@ -270,5 +270,5 @@ void amd64_lapic_ipi (uint32_t lapic_id, uint32_t vec) {
   }
 
   amd64_lapic_write (LAPIC_ICR + 0x10, (lapic_id << 24));
-  amd64_lapic_write (LAPIC_ICR, vec);
+  amd64_lapic_write (LAPIC_ICR, vec | (1 << 14));
 }

kernel/amd64/intr.c

@@ -165,10 +165,15 @@ static void amd64_intr_exception (struct saved_regs* regs) {
 
 /* Handle incoming interrupt, dispatch IRQ handlers. */
 void amd64_intr_handler (void* stack_ptr) {
+  spin_lock_ctx_t ctxcpu;
   amd64_load_kernel_cr3 ();
 
   struct saved_regs* regs = stack_ptr;
 
+  spin_lock (&thiscpu->lock, &ctxcpu);
+  memcpy (&thiscpu->regs, regs, sizeof (struct saved_regs));
+  spin_unlock (&thiscpu->lock, &ctxcpu);
+
   if (regs->trap <= 31) {
     amd64_intr_exception (regs);
   } else {
@@ -177,13 +182,7 @@ void amd64_intr_handler (void* stack_ptr) {
     struct irq* irq = irq_find (regs->trap);
 
     if (irq != NULL) {
-      if ((irq->flags & IRQ_INTERRUPT_SAFE))
-        __asm__ volatile ("sti");
-
       irq->func (irq->arg, stack_ptr);
-
-      if ((irq->flags & IRQ_INTERRUPT_SAFE))
-        __asm__ volatile ("cli");
     }
   }
 }

kernel/amd64/mm.c

@@ -418,9 +418,7 @@ static void amd64_tlb_shootdown_irq (void* arg, void* regs) {
 
 /* Continue initializing memory management subsystem for AMD64 after the essential parts were
  * initialized */
-void mm_init2 (void) {
+void mm_init2 (void) { irq_attach (&amd64_tlb_shootdown_irq, NULL, TLB_SHOOTDOWN); }
-  irq_attach (&amd64_tlb_shootdown_irq, NULL, TLB_SHOOTDOWN, IRQ_INTERRUPT_SAFE);
-}
 
 /* Initialize essentials for the AMD64 memory management subsystem */
 void mm_init (void) { kernel_pd.cr3_paddr = amd64_current_cr3 (); }

kernel/amd64/smp.c

@@ -8,6 +8,7 @@
 #include <libk/string.h>
 #include <limine/requests.h>
 #include <mm/liballoc.h>
+#include <proc/proc.h>
 #include <sync/spin_lock.h>
 #include <sys/debug.h>
 #include <sys/smp.h>
@@ -41,6 +42,11 @@ struct cpu* cpu_get (void) {
 }
 
 void cpu_request_sched (struct cpu* cpu) {
+  if (cpu == thiscpu) {
+    proc_sched ();
+    return;
+  }
+
   struct limine_mp_response* mp = limine_mp_request.response;
 
   for (size_t i = 0; i < mp->cpu_count; i++) {

kernel/amd64/smp.h

@@ -2,6 +2,7 @@
 #define _KERNEL_AMD64_SMP_H
 
 #include <amd64/gdt.h>
+#include <amd64/intr.h>
 #include <amd64/tss.h>
 #include <aux/compiler.h>
 #include <libk/rbtree.h>
@@ -20,6 +21,7 @@ struct cpu {
   volatile uint8_t irq_stack[KSTACK_SIZE] ALIGNED (16);
   volatile struct gdt_extended gdt ALIGNED (16);
   volatile struct tss tss;
+  struct saved_regs regs;
 
   uintptr_t lapic_mmio_base;
   uint64_t lapic_ticks;

kernel/amd64/syscall.c

@@ -3,6 +3,7 @@
 #include <amd64/mm.h>
 #include <amd64/msr-index.h>
 #include <amd64/msr.h>
+#include <libk/string.h>
 #include <m/status.h>
 #include <m/syscall_defs.h>
 #include <proc/proc.h>
@@ -13,10 +14,16 @@
 extern void amd64_syscall_entry (void);
 
 int amd64_syscall_dispatch (void* stack_ptr) {
+  spin_lock_ctx_t ctxcpu;
+
   amd64_load_kernel_cr3 ();
 
   struct saved_regs* regs = stack_ptr;
 
+  spin_lock (&thiscpu->lock, &ctxcpu);
+  memcpy (&thiscpu->regs, regs, sizeof (struct saved_regs));
+  spin_unlock (&thiscpu->lock, &ctxcpu);
+
   int syscall_num = regs->rax;
   syscall_handler_func_t func = syscall_find_handler (syscall_num);
 

kernel/irq/irq.c

@@ -14,7 +14,7 @@ struct irq* irq_table[0x100];
 
 static rw_spin_lock_t irqs_lock;
 
-bool irq_attach (void (*func) (void*, void*), void* arg, uint32_t irq_num, uint32_t flags) {
+bool irq_attach (void (*func) (void*, void*), void* arg, uint32_t irq_num) {
   spin_lock_ctx_t ctxiqa;
 
   struct irq* irq = malloc (sizeof (*irq));
@@ -25,7 +25,6 @@ bool irq_attach (void (*func) (void*, void*), void* arg, uint32_t irq_num, uint3
   irq->func = func;
   irq->arg = arg;
   irq->irq_num = irq_num;
-  irq->flags = flags;
 
   rw_spin_write_lock (&irqs_lock, &ctxiqa);
   irq_table[irq_num] = irq;

kernel/irq/irq.h

@@ -4,9 +4,6 @@
 #include <libk/list.h>
 #include <libk/std.h>
 
-#define IRQ_INTERRUPT_SAFE   (1 << 0)
-#define IRQ_INTERRUPT_UNSAFE (1 << 1)
-
 typedef void (*irq_func_t) (void* arg, void* regs);
 
 struct irq {
@@ -15,10 +12,9 @@ struct irq {
   irq_func_t func;
   void* arg;
   uint32_t irq_num;
-  uint32_t flags;
 };
 
-bool irq_attach (irq_func_t, void* arg, uint32_t irq_num, uint32_t flags);
+bool irq_attach (irq_func_t, void* arg, uint32_t irq_num);
 struct irq* irq_find (uint32_t irq_num);
 
 #endif // _KERNEL_IRQ_IRQ_H

kernel/proc/locks.txt

@@ -0,0 +1,6 @@
+Lock hierarchy for process scheduling:
+
+1. proc_tree_lock
+2. cpu->lock
+3. proc->lock
+4. sq->lock

kernel/proc/mutex.c

@@ -19,25 +19,76 @@ void proc_cleanup_resource_mutex (struct proc* proc, struct proc_resource* resou
   proc_mutex_unlock (proc, mutex);
 }
 
+static void proc_mutex_suspend (struct proc* proc, struct proc_suspension_q* sq,
+                                spin_lock_t* resource_lock, spin_lock_ctx_t* ctxrl) {
+  spin_lock_ctx_t ctxpr, ctxcpu, ctxsq;
+  struct cpu* cpu = proc->cpu;
+
+  spin_lock (&cpu->lock, &ctxcpu);
+  spin_lock (&proc->lock, &ctxpr);
+  spin_lock (&sq->lock, &ctxsq);
+
+  spin_unlock (resource_lock, ctxrl);
+
+  atomic_store (&proc->state, PROC_SUSPENDED);
+  proc->suspension_q = sq;
+
+  list_remove (cpu->proc_run_q, &proc->cpu_run_q_link);
+  if (cpu->proc_current == proc)
+    cpu->proc_current = NULL;
+
+  list_append (sq->proc_list, &proc->suspension_link);
+
+  spin_unlock (&sq->lock, &ctxsq);
+  spin_unlock (&proc->lock, &ctxpr);
+  spin_unlock (&cpu->lock, &ctxcpu);
+
+  cpu_request_sched (cpu);
+}
+
+static void proc_mutex_resume (struct proc* proc) {
+  spin_lock_ctx_t ctxsq, ctxpr, ctxcpu;
+  struct cpu* cpu = proc->cpu;
+
+  spin_lock (&cpu->lock, &ctxcpu);
+  spin_lock (&proc->lock, &ctxpr);
+
+  struct proc_suspension_q* sq = proc->suspension_q;
+
+  if (sq) {
+    spin_lock (&sq->lock, &ctxsq);
+
+    list_remove (sq->proc_list, &proc->suspension_link);
+
+    proc->suspension_q = NULL;
+    atomic_store (&proc->state, PROC_READY);
+
+    list_append (cpu->proc_run_q, &proc->cpu_run_q_link);
+
+    spin_unlock (&sq->lock, &ctxsq);
+  }
+
+  spin_unlock (&proc->lock, &ctxpr);
+  spin_unlock (&cpu->lock, &ctxcpu);
+
+  cpu_request_sched (cpu);
+}
+
 void proc_mutex_lock (struct proc* proc, struct proc_mutex* mutex) {
   spin_lock_ctx_t ctxmt;
 
-try:
+  for (;;) {
-  spin_lock (&mutex->resource->lock, &ctxmt);
+    spin_lock (&mutex->resource->lock, &ctxmt);
 
-  if (!mutex->locked || mutex->owner == proc) {
+    if (!mutex->locked || mutex->owner == proc) {
-    mutex->locked = true;
+      mutex->locked = true;
-    mutex->owner = proc;
+      mutex->owner = proc;
-    spin_unlock (&mutex->resource->lock, &ctxmt);
+      spin_unlock (&mutex->resource->lock, &ctxmt);
-    return;
+      return;
+    }
+
+    proc_mutex_suspend (proc, &mutex->suspension_q, &mutex->resource->lock, &ctxmt);
   }
-
-  spin_unlock (&mutex->resource->lock, &ctxmt);
-
-  DEBUG ("proc->pid=%d\n", proc->pid);
-  proc_suspend (proc, &mutex->suspension_q);
-
-  goto try;
 }
 
 bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
@@ -63,7 +114,7 @@ bool proc_mutex_unlock (struct proc* proc, struct proc_mutex* mutex) {
     spin_unlock (&mutex->suspension_q.lock, &ctxsq);
     spin_unlock (&mutex->resource->lock, &ctxmt);
 
-    proc_resume (resumed_proc);
+    proc_mutex_resume (resumed_proc);
 
     return true;
   }

kernel/proc/proc.c

@@ -289,7 +289,7 @@ static void proc_reap (void) {
   }
 }
 
-void proc_sched (void* regs) {
+void proc_sched (void) {
   spin_lock_ctx_t ctxcpu, ctxpr;
 
   int s_cycles = atomic_fetch_add (&sched_cycles, 1);
@@ -303,15 +303,13 @@ void proc_sched (void* regs) {
   spin_lock (&cpu->lock, &ctxcpu);
 
   struct proc* prev = cpu->proc_current;
+  next = proc_find_sched (cpu);
 
   if (prev != NULL) {
-    spin_lock (&prev->lock, &ctxpr);
+    memcpy (&prev->pdata.regs, &cpu->regs, sizeof (struct saved_regs));
-    memcpy (&prev->pdata.regs, regs, sizeof (struct saved_regs));
     spin_unlock (&prev->lock, &ctxpr);
   }
 
-  next = proc_find_sched (cpu);
-
   if (next) {
     cpu->proc_current = next;
     spin_unlock (&cpu->lock, &ctxcpu);
@@ -346,54 +344,9 @@ void proc_kill (struct proc* proc) {
   cpu_request_sched (cpu);
 }
 
-void proc_suspend (struct proc* proc, struct proc_suspension_q* sq) {
-  spin_lock_ctx_t ctxpr, ctxcpu, ctxsq;
-  struct cpu* cpu = proc->cpu;
-
-  spin_lock (&proc->lock, &ctxpr);
-  atomic_store (&proc->state, PROC_SUSPENDED);
-  proc->suspension_q = sq;
-  spin_unlock (&proc->lock, &ctxpr);
-
-  /* remove from run q */
-  spin_lock (&cpu->lock, &ctxcpu);
-
-  list_remove (cpu->proc_run_q, &proc->cpu_run_q_link);
-  if (cpu->proc_current == proc)
-    cpu->proc_current = NULL;
-  spin_unlock (&cpu->lock, &ctxcpu);
-
-  spin_lock (&sq->lock, &ctxsq);
-  list_append (sq->proc_list, &proc->suspension_link);
-  spin_unlock (&sq->lock, &ctxsq);
-
-  cpu_request_sched (cpu);
-}
-
-void proc_resume (struct proc* proc) {
-  spin_lock_ctx_t ctxsq, ctxpr, ctxcpu;
-  struct cpu* cpu = proc->cpu;
-  struct proc_suspension_q* sq = proc->suspension_q;
-
-  spin_lock (&sq->lock, &ctxsq);
-  list_remove (sq->proc_list, &proc->suspension_link);
-  spin_unlock (&sq->lock, &ctxsq);
-
-  spin_lock (&proc->lock, &ctxpr);
-  proc->suspension_q = NULL;
-  atomic_store (&proc->state, PROC_READY);
-  spin_unlock (&proc->lock, &ctxpr);
-
-  spin_lock (&cpu->lock, &ctxcpu);
-  list_append (cpu->proc_run_q, &proc->cpu_run_q_link);
-  spin_unlock (&cpu->lock, &ctxcpu);
-
-  cpu_request_sched (cpu);
-}
-
 static void proc_irq_sched (void* arg, void* regs) {
   (void)arg;
-  proc_sched (regs);
+  proc_sched ();
 }
 
 static void proc_kpproc_init (void) {
@@ -450,8 +403,8 @@ static void proc_kpproc_init (void) {
 
 void proc_init (void) {
 #if defined(__x86_64__)
-  irq_attach (&proc_irq_sched, NULL, SCHED_PREEMPT_TIMER, IRQ_INTERRUPT_SAFE);
+  irq_attach (&proc_irq_sched, NULL, SCHED_PREEMPT_TIMER);
-  irq_attach (&proc_irq_sched, NULL, CPU_REQUEST_SCHED, IRQ_INTERRUPT_SAFE);
+  irq_attach (&proc_irq_sched, NULL, CPU_REQUEST_SCHED);
 #endif
 
   proc_kpproc_init ();

kernel/proc/proc.h

@@ -60,9 +60,7 @@ struct proc {
   struct proc_resources* resources;
 };
 
-void proc_suspend (struct proc* proc, struct proc_suspension_q* sq);
+void proc_sched (void);
-void proc_resume (struct proc* proc);
-void proc_sched (void* regs);
 void proc_kill (struct proc* proc);
 bool proc_map (struct proc* proc, uintptr_t start_paddr, uintptr_t start_vaddr, size_t pages,
                uint32_t flags);

kernel/syscall/syscall.c

@@ -179,7 +179,7 @@ DEFINE_SYSCALL (sys_clone) {
 
 /* int sched (void) */
 DEFINE_SYSCALL (sys_sched) {
-  proc_sched (regs);
+  proc_sched ();
   return ST_OK;
 }
 
@@ -234,6 +234,7 @@ DEFINE_SYSCALL (sys_lock_mutex) {
   if (mutex_resource == NULL)
     return -ST_NOT_FOUND;
 
+  DEBUG ("locking %d\n", proc->pid);
   proc_mutex_lock (proc, &mutex_resource->u.mutex);
 
   return ST_OK;
@@ -252,6 +253,7 @@ DEFINE_SYSCALL (sys_unlock_mutex) {
   if (mutex_resource == NULL)
     return -ST_NOT_FOUND;
 
+  DEBUG ("unlocking %d\n", proc->pid);
   return proc_mutex_unlock (proc, &mutex_resource->u.mutex) ? ST_OK : -ST_PERMISSION_ERROR;
 }