Fix user apps randomly crashing (APIC, GDT layout, syscall entry)

kernel/proc/proc.c

@@ -214,11 +214,11 @@ static void proc_register (struct proc* proc, struct cpu* cpu) {
 /* caller holds cpu->lock */
 static struct proc* proc_find_sched (struct cpu* cpu) {
   struct rb_node_link* node = NULL;
-  struct proc* start = cpu->proc_current;
+  struct proc* current = cpu->proc_current;
   struct proc* proc = NULL;
 
-  if (start)
-    node = &start->cpu_run_q_link;
+  if (current)
+    rbtree_next (&current->cpu_run_q_link, node);
 
   if (!node)
     rbtree_first (&cpu->proc_run_q, node);
@@ -235,15 +235,12 @@ static struct proc* proc_find_sched (struct cpu* cpu) {
 
     rbtree_next (node, node);
 
-    if (!node) {
+    if (!node)
       rbtree_first (&cpu->proc_run_q, node);
-    }
 
-    if (node == first)
-      break;
   } while (node != first);
 
-  return NULL;
+  return ((atomic_load (&current->state) == PROC_READY) ? current : NULL);
 }
 
 static void proc_reap (void) {
@@ -283,8 +280,10 @@ static void proc_reap (void) {
   }
 }
 
-void proc_sched (void) {
-  if (atomic_fetch_add (&sched_cycles, 1) % SCHED_REAP_FREQ == 0)
+void proc_sched (void* regs) {
+  int s_cycles = atomic_fetch_add (&sched_cycles, 1);
+
+  if (s_cycles % SCHED_REAP_FREQ == 0)
     proc_reap ();
 
   struct proc* next = NULL;
@@ -292,25 +291,36 @@ void proc_sched (void) {
 
   spin_lock (&cpu->lock);
 
-  if (cpu->proc_run_q != NULL) {
-    next = proc_find_sched (cpu);
-    if (next)
-      cpu->proc_current = next;
+  struct proc* prev = cpu->proc_current;
+
+  if (prev != NULL) {
+    spin_lock (&prev->lock);
+    prev->pdata.regs = *(struct saved_regs*)regs;
+    spin_unlock (&prev->lock);
   }
 
-  spin_unlock (&thiscpu->lock);
+  next = proc_find_sched (cpu);
+
+  if (next) {
+    cpu->proc_current = next;
+    spin_unlock (&cpu->lock);
 
-  if ((next != NULL) && (atomic_load (&next->state) == PROC_READY))
     do_sched (next);
+  } else {
+    cpu->proc_current = NULL;
+    spin_unlock (&cpu->lock);
 
-  spin ();
+    spin ();
+  }
 }
 
-void proc_kill (struct proc* proc) {
-  atomic_store (&proc->state, PROC_DEAD);
-
+void proc_kill (struct proc* proc, void* regs) {
   struct cpu* cpu = proc->cpu;
 
+  spin_lock (&proc->lock);
+  atomic_store (&proc->state, PROC_DEAD);
+  spin_unlock (&proc->lock);
+
   spin_lock (&cpu->lock);
 
   rbtree_delete (&cpu->proc_run_q, &proc->cpu_run_q_link);
@@ -322,39 +332,35 @@ void proc_kill (struct proc* proc) {
   DEBUG ("killed PID %d\n", proc->pid);
 
   if (cpu == thiscpu)
-    proc_sched ();
+    proc_sched (regs);
   else
     cpu_request_sched (cpu);
 }
 
 void proc_suspend (struct proc* proc, struct proc_suspension_q* sq) {
+  struct cpu* cpu = proc->cpu;
+
   spin_lock (&proc->lock);
   atomic_store (&proc->state, PROC_SUSPENDED);
-
-  struct cpu* cpu = proc->cpu;
+  proc->suspension_q = sq;
+  spin_unlock (&proc->lock);
 
   /* remove from run q */
   spin_lock (&cpu->lock);
+
   rbtree_delete (&cpu->proc_run_q, &proc->cpu_run_q_link);
   if (cpu->proc_current == proc)
     cpu->proc_current = NULL;
   spin_unlock (&cpu->lock);
 
-  proc->suspension_q = sq;
-
-  spin_lock (&proc->suspension_q->lock);
-  rbtree_insert (struct proc, &proc->suspension_q->proc_tree, &proc->suspension_link,
-                 suspension_link, pid);
-  spin_unlock (&proc->suspension_q->lock);
-
-  spin_unlock (&proc->lock);
+  spin_lock (&sq->lock);
+  rbtree_insert (struct proc, &sq->proc_tree, &proc->suspension_link, suspension_link, pid);
+  spin_unlock (&sq->lock);
 
   cpu_request_sched (cpu);
 }
 
 void proc_resume (struct proc* proc) {
-  spin_lock (&proc->lock);
-
   struct cpu* cpu = proc->cpu;
   struct proc_suspension_q* sq = proc->suspension_q;
 
@@ -362,26 +368,27 @@ void proc_resume (struct proc* proc) {
   rbtree_delete (&sq->proc_tree, &proc->suspension_link);
   spin_unlock (&sq->lock);
 
+  spin_lock (&proc->lock);
   proc->suspension_q = NULL;
+  atomic_store (&proc->state, PROC_READY);
+  spin_unlock (&proc->lock);
 
   spin_lock (&cpu->lock);
   rbtree_insert (struct proc, &cpu->proc_run_q, &proc->cpu_run_q_link, cpu_run_q_link, pid);
   spin_unlock (&cpu->lock);
 
-  atomic_store (&proc->state, PROC_READY);
-  spin_unlock (&proc->lock);
-
   cpu_request_sched (cpu);
 }
 
 static void proc_irq_sched (void* arg, void* regs) {
-  (void)arg, (void)regs;
-  proc_sched ();
-}
+  (void)arg;
 
-static void proc_irq_cpu_request_sched (void* arg, void* regs) {
-  (void)arg, (void)regs;
-  proc_sched ();
+#if defined(__x86_64__)
+  struct saved_regs* s_regs = regs;
+  /* Only schedule, when we came from usermode */
+  if ((s_regs->cs & 0x03))
+    proc_sched (regs);
+#endif
 }
 
 void proc_init (void) {
@@ -389,8 +396,8 @@ void proc_init (void) {
   proc_register (init, thiscpu);
 
 #if defined(__x86_64__)
-  irq_attach (&proc_irq_sched, NULL, SCHED_PREEMPT_TIMER, IRQ_INTERRUPT_SAFE);
-  irq_attach (&proc_irq_cpu_request_sched, NULL, CPU_REQUEST_SCHED, IRQ_INTERRUPT_SAFE);
+  irq_attach (&proc_irq_sched, NULL, SCHED_PREEMPT_TIMER, IRQ_INTERRUPT_UNSAFE);
+  irq_attach (&proc_irq_sched, NULL, CPU_REQUEST_SCHED, IRQ_INTERRUPT_UNSAFE);
 #endif
 
   do_sched (init);