Move scheduler to new global class format.

zion/interrupt/interrupt.cpp

@@ -123,7 +123,7 @@ extern "C" void interrupt_timer(InterruptFrame*) {
     dbgln("timer: %us", cnt * 50 / 1000);
   }
   outb(PIC1_COMMAND, PIC_EOI);
-  sched::Preempt();
+  gScheduler->Preempt();
 }
 
 void EnablePic() {

zion/scheduler/process.cpp

@@ -31,7 +31,7 @@ Process::Process(uint64_t elf_ptr) : id_(gNextId++), state_(RUNNING) {
 void Process::CreateThread(uint64_t elf_ptr) {
   Thread* thread = new Thread(this, next_thread_id_++, elf_ptr);
   threads_.PushBack(thread);
-  sched::EnqueueThread(thread);
+  gScheduler->Enqueue(thread);
 }
 
 SharedPtr<Thread> Process::GetThread(uint64_t tid) {

zion/scheduler/scheduler.cpp

@@ -4,27 +4,23 @@
 #include "lib/linked_list.h"
 #include "scheduler/process_manager.h"
 
-namespace sched {
 namespace {
 
 extern "C" void context_switch(uint64_t* current_esp, uint64_t* next_esp);
 
-class Scheduler {
+}  // namespace
- public:
+
-  Scheduler() {
+Scheduler* gScheduler = nullptr;
+
+void Scheduler::Init() { gScheduler = new Scheduler(); }
+Scheduler::Scheduler() {
   Process& root = gProcMan->FromId(0);
   sleep_thread_ = root.GetThread(0);
   // TODO: Implement a separate sleep thread?
   current_thread_ = sleep_thread_;
-  }
+}
-  void Enable() { enabled_ = true; }
 
-  Process& CurrentProcess() { return CurrentThread().process(); }
+void Scheduler::SwapToCurrent(Thread& prev) {
-  Thread& CurrentThread() { return *current_thread_; }
-
-  void Enqueue(Thread* thread) { runnable_threads_.PushBack(thread); }
-
-  void SwapToCurrent(Thread& prev) {
   if (current_thread_->GetState() != Thread::RUNNABLE) {
     panic("Swapping to non-runnable thread.");
   }
@@ -33,9 +29,9 @@ class Scheduler {
   context_switch(prev.Rsp0Ptr(), current_thread_->Rsp0Ptr());
 
   asm volatile("sti");
-  }
+}
 
-  void Preempt() {
+void Scheduler::Preempt() {
   if (!enabled_) {
     return;
   }
@@ -57,9 +53,9 @@ class Scheduler {
   current_thread_ = runnable_threads_.CycleFront(prev);
 
   SwapToCurrent(*prev);
-  }
+}
 
-  void Yield() {
+void Scheduler::Yield() {
   if (!enabled_) {
     dbgln("WARN Scheduler skipped yield.");
     return;
@@ -88,37 +84,4 @@ class Scheduler {
   }
 
   SwapToCurrent(*prev);
-  }
-
- private:
-  bool enabled_ = false;
-
-  SharedPtr<Thread> current_thread_;
-  LinkedList<SharedPtr<Thread>> runnable_threads_;
-
-  SharedPtr<Thread> sleep_thread_;
-};
-
-static Scheduler* gScheduler = nullptr;
-
-Scheduler& GetScheduler() {
-  if (!gScheduler) {
-    panic("Scheduler not initialized");
-  }
-  return *gScheduler;
 }
-
-}  // namespace
-
-void InitScheduler() { gScheduler = new Scheduler(); }
-void EnableScheduler() { GetScheduler().Enable(); }
-
-void Preempt() { GetScheduler().Preempt(); }
-void Yield() { GetScheduler().Yield(); }
-
-void EnqueueThread(Thread* thread) { GetScheduler().Enqueue(thread); }
-
-Process& CurrentProcess() { return GetScheduler().CurrentProcess(); }
-Thread& CurrentThread() { return GetScheduler().CurrentThread(); }
-
-}  // namespace sched

zion/scheduler/scheduler.h

@@ -3,27 +3,35 @@
 #include "scheduler/process.h"
 #include "scheduler/thread.h"
 
-namespace sched {
+class Scheduler {
+ public:
+  // Initializes the scheduler in a disabled state.
+  //
+  // Requires the process manager to have been initialized.
+  static void Init();
 
-// Create the scheduler object in a disabled state,
+  void Enable() { enabled_ = true; }
-// processes can be added but will not be scheduled.
-void InitScheduler();
 
-// Enables the scheduler such that processes will yield on ticks.
+  Process& CurrentProcess() { return current_thread_->process(); }
-void EnableScheduler();
+  Thread& CurrentThread() { return *current_thread_; }
 
-// Preempts the current thread and flags it as runnable in the queue.
+  void Enqueue(const SharedPtr<Thread> thread) {
-// Generally used by the timer to move to the next timeslice.
+    runnable_threads_.PushBack(thread);
-void Preempt();
+  }
 
-// Current thread yields and is not rescheduled until some external process
+  void Preempt();
-// adds it.
+  void Yield();
-// Used when a thread blocks or exits.
-void Yield();
 
-void EnqueueThread(Thread* thread);
+ private:
+  bool enabled_ = false;
 
-Process& CurrentProcess();
+  SharedPtr<Thread> current_thread_;
-Thread& CurrentThread();
+  LinkedList<SharedPtr<Thread>> runnable_threads_;
 
-}  // namespace sched
+  SharedPtr<Thread> sleep_thread_;
+
+  Scheduler();
+  void SwapToCurrent(Thread& prev);
+};
+
+extern Scheduler* gScheduler;

zion/scheduler/thread.cpp

@@ -13,7 +13,7 @@ extern "C" void jump_user_space(uint64_t rip, uint64_t rsp);
 
 extern "C" void thread_init() {
   asm("sti");
-  sched::CurrentThread().Init();
+  gScheduler->CurrentThread().Init();
   panic("Reached end of thread.");
 }
 
@@ -54,5 +54,5 @@ void Thread::Exit() {
   dbgln("[%u.%u] Exiting", pid(), id_);
   state_ = FINISHED;
   process_->CheckState();
-  sched::Yield();
+  gScheduler->Yield();
 }

zion/syscall/syscall.cpp

@@ -30,7 +30,7 @@ extern "C" void syscall_enter();
 
 // Used by syscall_enter.s
 extern "C" uint64_t GetKernelRsp() {
-  return sched::CurrentThread().Rsp0Start();
+  return gScheduler->CurrentThread().Rsp0Start();
 }
 
 void InitSyscall() {
@@ -54,7 +54,7 @@ void InitSyscall() {
 }
 
 extern "C" void SyscallHandler(uint64_t call_id, char* message) {
-  Thread& thread = sched::CurrentThread();
+  Thread& thread = gScheduler->CurrentThread();
   switch (call_id) {
     case Z_THREAD_EXIT:
       thread.Exit();

zion/zion.cpp

@@ -30,16 +30,16 @@ extern "C" void zion() {
 
   dbgln("[boot] Init scheduler.");
   ProcessManager::Init();
+  Scheduler::Init();
   // Schedule every 50ms.
   SetFrequency(/* hertz= */ 20);
-  sched::InitScheduler();
 
   dbgln("[boot] Loading sys init program.");
   LoadInitProgram();
 
   dbgln("[boot] Init finished, yielding.");
-  sched::EnableScheduler();
+  gScheduler->Enable();
-  sched::Yield();
+  gScheduler->Yield();
 
   dbgln("Sleeping!");
   while (1)