Fix scheduler locking hierarchy

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:
-  spin_lock (&mutex->resource->lock, &ctxmt);
+  for (;;) {
+    spin_lock (&mutex->resource->lock, &ctxmt);
 
-  if (!mutex->locked || mutex->owner == proc) {
-    mutex->locked = true;
-    mutex->owner = proc;
-    spin_unlock (&mutex->resource->lock, &ctxmt);
-    return;
+    if (!mutex->locked || mutex->owner == proc) {
+      mutex->locked = true;
+      mutex->owner = proc;
+      spin_unlock (&mutex->resource->lock, &ctxmt);
+      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;
   }