Adds some event/uthread debugging code
[akaros.git] / kern / src / smp.c
index 6b43226..96412f0 100644 (file)
@@ -17,7 +17,7 @@
 #include <assert.h>
 #include <pmap.h>
 #include <process.h>
 #include <assert.h>
 #include <pmap.h>
 #include <process.h>
-#include <manager.h>
+#include <schedule.h>
 #include <trap.h>
 
 struct per_cpu_info per_cpu_info[MAX_NUM_CPUS];
 #include <trap.h>
 
 struct per_cpu_info per_cpu_info[MAX_NUM_CPUS];
@@ -25,52 +25,50 @@ struct per_cpu_info per_cpu_info[MAX_NUM_CPUS];
 // tracks number of global waits on smp_calls, must be <= NUM_HANDLER_WRAPPERS
 atomic_t outstanding_calls = 0;
 
 // tracks number of global waits on smp_calls, must be <= NUM_HANDLER_WRAPPERS
 atomic_t outstanding_calls = 0;
 
-/* All cores end up calling this whenever there is nothing left to do.  Non-zero
- * cores call it when they are done booting.  Other cases include after getting
- * a DEATH IPI.
- * - Management cores (core 0 for now) call manager, which should never return.
- * - Worker cores halt and wake up when interrupted, do any work on their work
- *   queue, then halt again.
- * TODO: think about unifying the manager into a workqueue function, so we don't
- * need to check mgmt_core in here.  it gets a little ugly, since there are
- * other places where we check for mgmt and might not smp_idle / call manager.
- */
-static void __smp_idle(void)
+/* Helper for running a proc (if we should).  Lots of repetition with
+ * proc_restartcore */
+static void try_run_proc(void)
 {
 {
-       int8_t state = 0;
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 
        struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
 
-       /* There was a process running here, and we should return to it */
-       if (pcpui->cur_tf) {                    /* aka, current_tf */
-               assert(pcpui->cur_proc);        /* aka, current */
+       disable_irq();
+       /* There was a process running here, and we should return to it. */
+       if (pcpui->owning_proc) {
                proc_restartcore();
                assert(0);
        }
                proc_restartcore();
                assert(0);
        }
+}
+
+/* All cores end up calling this whenever there is nothing left to do or they
+ * don't know explicitly what to do.  Non-zero cores call it when they are done
+ * booting.  Other cases include after getting a DEATH IPI.
+ *
+ * All cores attempt to run the context of any owning proc.  Barring that, the
+ * cores enter a loop.  They halt and wake up when interrupted, do any work on
+ * their work queue, then halt again.  In between, the ksched gets a chance to
+ * tell it to do something else, or perhaps to halt in another manner. */
+static void __smp_idle(void)
+{
+       int8_t state = 0;
+
+       /* TODO: idle, abandon_core(), and proc_restartcore() need cleaned up */
+       enable_irq();   /* get any IRQs before we halt later */
+       try_run_proc();
        /* if we made it here, we truly want to idle */
        /* in the future, we may need to proactively leave process context here.
         * for now, it is possible to have a current loaded, even if we are idle
         * (and presumably about to execute a kmsg or fire up a vcore). */
        /* if we made it here, we truly want to idle */
        /* in the future, we may need to proactively leave process context here.
         * for now, it is possible to have a current loaded, even if we are idle
         * (and presumably about to execute a kmsg or fire up a vcore). */
-       if (!management_core()) {
-               while (1) {
-                       disable_irq();
-                       process_routine_kmsg(0);
-                       /* cpu_halt() atomically turns on interrupts and halts the core.
-                        * Important to do this, since we could have a RKM come in via an
-                        * interrupt right while PRKM is returning, and we wouldn't catch
-                        * it. */
-                       cpu_halt();
-                       /* interrupts are back on now (given our current semantics) */
-               }
-       } else {
-               enable_irqsave(&state);
-               /* this makes us wait to enter the manager til any IO is done (totally
-                * arbitrary 10ms), so we can handle the routine message that we
-                * currently use to do the completion.  Note this also causes us to wait
-                * 10ms regardless of how long the IO takes.  This all needs work. */
-               //udelay(10000); /* done in the manager for now */
+       while (1) {
+               disable_irq();
                process_routine_kmsg(0);
                process_routine_kmsg(0);
-               disable_irqsave(&state);
-               manager();
+               try_run_proc();
+               cpu_bored();            /* call out to the ksched */
+               /* cpu_halt() atomically turns on interrupts and halts the core.
+                * Important to do this, since we could have a RKM come in via an
+                * interrupt right while PRKM is returning, and we wouldn't catch
+                * it. */
+               cpu_halt();
+               /* interrupts are back on now (given our current semantics) */
        }
        assert(0);
 }
        }
        assert(0);
 }
@@ -99,11 +97,9 @@ void smp_percpu_init(void)
        STAILQ_INIT(&per_cpu_info[coreid].routine_amsgs);
        /* Initialize the per-core timer chain */
        init_timer_chain(&per_cpu_info[coreid].tchain, set_pcpu_alarm_interrupt);
        STAILQ_INIT(&per_cpu_info[coreid].routine_amsgs);
        /* Initialize the per-core timer chain */
        init_timer_chain(&per_cpu_info[coreid].tchain, set_pcpu_alarm_interrupt);
-
 #ifdef __CONFIG_KTHREAD_POISON__
 #ifdef __CONFIG_KTHREAD_POISON__
-/* TODO: KTHR-STACK */
-uintptr_t *poison = (uintptr_t*)ROUNDDOWN(get_stack_top() - 1, PGSIZE);
-*poison = 0xdeadbeef;
+       /* TODO: KTHR-STACK */
+       uintptr_t *poison = (uintptr_t*)ROUNDDOWN(get_stack_top() - 1, PGSIZE);
+       *poison = 0xdeadbeef;
 #endif /* __CONFIG_KTHREAD_POISON__ */
 #endif /* __CONFIG_KTHREAD_POISON__ */
-
 }
 }