Make proc_restartcore() call smp_idle()
authorBarret Rhoden <brho@cs.berkeley.edu>
Mon, 30 Jul 2018 19:46:52 +0000 (15:46 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 30 Jul 2018 20:06:25 +0000 (16:06 -0400)
Maybe we should just remove proc_restartcore().  They both did similar
things, and proc_restartcore() could call smp_idle.  PRKM calls smp_idle()
if it handles a message, which is built for how smp_idle works, but then it
ignores proc_restartcore().

It's not a big deal either way.  Though by having a single function that
deals with all of the RCU / halting / PRKM / abandon_core issues is a lot
simpler.

The old proc_restartcore() actually had an RCU bug too - it reported the
quiescent state after checking PRKM, which means the rcu_gp_ktask could
have been delayed from starting up.  This wouldn't usually show up as a
deadlock or anything, since there was a process on that core which would
eventually either block or die, at which point we'd run our kernel
messages.  You'd have needed a process to be stuck in a while(1), waiting
for an event that was triggered by RCU.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
kern/src/process.c

index 5fa70ba..11a936e 100644 (file)
@@ -784,28 +784,18 @@ void __proc_startcore(struct proc *p, struct user_context *ctx)
 }
 
 /* Restarts/runs the current_ctx, which must be for the current process, on the
- * core this code executes on.  Calls an internal function to do the work.
+ * core this code executes on.
  *
- * In case there are pending routine messages, like __death, __preempt, or
- * __notify, we need to run them.  Alternatively, if there are any, we could
- * self_ipi, and run the messages immediately after popping back to userspace,
- * but that would have crappy overhead. */
+ * For now, we just smp_idle.  We used to do something similar, but customized
+ * for expecting to return to the process.  But it was a source of bugs.  If we
+ * want to optimize for the case where we know we had a process current, then we
+ * can do so here.
+ *
+ * Note that PRKM currently calls smp_idle() if it ever has a message, so the
+ * value of optimizing may depend on the semantics of PRKM. */
 void proc_restartcore(void)
 {
-       struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
-
-       assert(!pcpui->cur_kthread->sysc);
-       process_routine_kmsg();
-       /* If there is no owning process, just idle, since we don't know what to do.
-        * This could be because the process had been restarted a long time ago and
-        * has since left the core, or due to a KMSG like __preempt or __death. */
-       if (!pcpui->owning_proc) {
-               abandon_core();
-               smp_idle();
-       }
-       assert(pcpui->cur_ctx);
-       rcu_report_qs();
-       __proc_startcore(pcpui->owning_proc, pcpui->cur_ctx);
+       smp_idle();
 }
 
 /* Helper for proc_destroy.  Disowns any children. */