Kernel: De-templatefy ProcessorBase

This makes ProcessorBase a non-templated class, leading to a significant
reduction in LOC while also making the class (and the Processor class by
extension) much more decomposable.

Author: implicitfield

Kernel/Arch/Processor.cpp

@@ -19,8 +19,7 @@ namespace Kernel {
 READONLY_AFTER_INIT FPUState s_clean_fpu_state;
 READONLY_AFTER_INIT Atomic<u32> g_total_processors;
 
-template<typename T>
-void ProcessorBase<T>::check_invoke_scheduler()
+void ProcessorBase::check_invoke_scheduler()
 {
     VERIFY_INTERRUPTS_DISABLED();
     VERIFY(!m_in_irq);
@@ -31,10 +30,8 @@ void ProcessorBase<T>::check_invoke_scheduler()
         Scheduler::invoke_async();
     }
 }
-template void ProcessorBase<Processor>::check_invoke_scheduler();
 
-template<typename T>
-void ProcessorBase<T>::deferred_call_queue(Function<void()> callback)
+void ProcessorBase::deferred_call_queue(Function<void()> callback)
 {
     // NOTE: If we are called outside of a critical section and outside
     // of an irq handler, the function will be executed before we return!
@@ -46,10 +43,8 @@ void ProcessorBase<T>::deferred_call_queue(Function<void()> callback)
 
     cur_proc.m_deferred_call_pool.queue_entry(entry);
 }
-template void ProcessorBase<Processor>::deferred_call_queue(Function<void()>);
 
-template<typename T>
-void ProcessorBase<T>::enter_trap(TrapFrame& trap, bool raise_irq)
+void ProcessorBase::enter_trap(TrapFrame& trap, bool raise_irq)
 {
     VERIFY_INTERRUPTS_DISABLED();
     VERIFY(&Processor::current() == this);
@@ -72,25 +67,32 @@ void ProcessorBase<T>::enter_trap(TrapFrame& trap, bool raise_irq)
         trap.next_trap = nullptr;
     }
 }
-template void ProcessorBase<Processor>::enter_trap(TrapFrame&, bool);
 
-template<typename T>
-u64 ProcessorBase<T>::time_spent_idle() const
+InterruptsState ProcessorBase::interrupts_state()
+{
+    return ProcessorBase::are_interrupts_enabled() ? InterruptsState::Enabled : InterruptsState::Disabled;
+}
+
+void ProcessorBase::restore_interrupts_state(InterruptsState interrupts_state)
+{
+    if (interrupts_state == InterruptsState::Enabled)
+        ProcessorBase::enable_interrupts();
+    else
+        ProcessorBase::disable_interrupts();
+}
+
+u64 ProcessorBase::time_spent_idle() const
 {
     return m_idle_thread->time_in_user() + m_idle_thread->time_in_kernel();
 }
-template u64 ProcessorBase<Processor>::time_spent_idle() const;
 
-template<typename T>
-void ProcessorBase<T>::leave_critical()
+void ProcessorBase::leave_critical()
 {
     InterruptDisabler disabler;
     current().do_leave_critical();
 }
-template void ProcessorBase<Processor>::leave_critical();
 
-template<typename T>
-void ProcessorBase<T>::do_leave_critical()
+void ProcessorBase::do_leave_critical()
 {
     VERIFY(m_in_critical > 0);
     if (m_in_critical == 1) {
@@ -105,7 +107,6 @@ void ProcessorBase<T>::do_leave_critical()
         m_in_critical = m_in_critical - 1;
     }
 }
-template void ProcessorBase<Processor>::do_leave_critical();
 
 void exit_kernel_thread(void)
 {
@@ -135,8 +136,7 @@ void do_context_first_init(Thread* from_thread, Thread* to_thread)
     Scheduler::leave_on_first_switch(InterruptsState::Disabled);
 }
 
-template<typename T>
-ErrorOr<Vector<FlatPtr, 32>> ProcessorBase<T>::capture_stack_trace(Thread& thread, size_t max_frames)
+ErrorOr<Vector<FlatPtr, 32>> ProcessorBase::capture_stack_trace(Thread& thread, size_t max_frames)
 {
     FlatPtr frame_ptr = 0, pc = 0;
     Vector<FlatPtr, 32> stack_trace;
@@ -264,6 +264,5 @@ ErrorOr<Vector<FlatPtr, 32>> ProcessorBase<T>::capture_stack_trace(Thread& threa
 
     return stack_trace;
 }
-template ErrorOr<Vector<FlatPtr, 32>> ProcessorBase<Processor>::capture_stack_trace(Thread&, size_t);
 
 }

Kernel/Arch/Processor.h

@@ -48,7 +48,6 @@ extern "C" void thread_context_first_enter(void);
 extern "C" void do_assume_context(Thread* thread, u32 flags);
 extern "C" FlatPtr do_init_context(Thread* thread, u32) __attribute__((used));
 
-template<typename ProcessorT>
 class ProcessorBase {
 public:
     template<typename T>
@@ -80,7 +79,7 @@ class ProcessorBase {
     ALWAYS_INLINE static void pause();
     ALWAYS_INLINE static void wait_check();
 
-    ALWAYS_INLINE static ProcessorT& current();
+    ALWAYS_INLINE static Processor& current();
     static Processor& by_id(u32);
 
     ALWAYS_INLINE u32 id() const
@@ -94,7 +93,10 @@ class ProcessorBase {
     }
 
     ALWAYS_INLINE static u32 current_id();
-    ALWAYS_INLINE static bool is_bootstrap_processor();
+    ALWAYS_INLINE static bool is_bootstrap_processor()
+    {
+        return current_id() == 0;
+    }
     ALWAYS_INLINE bool has_nx() const;
     ALWAYS_INLINE bool has_feature(CPUFeature::Type const& feature) const
     {
@@ -174,7 +176,7 @@ class ProcessorBase {
     static ErrorOr<Vector<FlatPtr, 32>> capture_stack_trace(Thread& thread, size_t max_frames = 0);
 
 protected:
-    ProcessorT* m_self;
+    Processor* m_self;
     CPUFeature::Type m_features;
 
     Atomic<bool> m_halt_requested;
@@ -203,8 +205,6 @@ class ProcessorBase {
     DeferredCallPool m_deferred_call_pool {};
 };
 
-template class ProcessorBase<Processor>;
-
 }
 
 #if ARCH(X86_64)
@@ -219,27 +219,6 @@ template class ProcessorBase<Processor>;
 
 namespace Kernel {
 
-template<typename T>
-ALWAYS_INLINE bool ProcessorBase<T>::is_bootstrap_processor()
-{
-    return current_id() == 0;
-}
-
-template<typename T>
-InterruptsState ProcessorBase<T>::interrupts_state()
-{
-    return Processor::are_interrupts_enabled() ? InterruptsState::Enabled : InterruptsState::Disabled;
-}
-
-template<typename T>
-void ProcessorBase<T>::restore_interrupts_state(InterruptsState interrupts_state)
-{
-    if (interrupts_state == InterruptsState::Enabled)
-        Processor::enable_interrupts();
-    else
-        Processor::disable_interrupts();
-}
-
 struct ProcessorMessageEntry;
 struct ProcessorMessage {
     using CallbackFunction = Function<void()>;