Kernel: Port FinalizerTask to WaitQueue

Author: implicitfield

Kernel/Tasks/FinalizerTask.cpp

@@ -8,6 +8,7 @@
 #include <Kernel/Tasks/FinalizerTask.h>
 #include <Kernel/Tasks/Process.h>
 #include <Kernel/Tasks/Scheduler.h>
+#include <Kernel/Tasks/WaitQueue.h>
 
 namespace Kernel {
 
@@ -17,12 +18,13 @@ static void finalizer_task(void*)
 {
     Thread::current()->set_priority(THREAD_PRIORITY_LOW);
     while (!Process::current().is_dying()) {
-        // The order of this if-else is important: We want to continue trying to finalize the threads in case
-        // Thread::finalize_dying_threads set g_finalizer_has_work back to true due to OOM conditions
-        if (g_finalizer_has_work.exchange(false, AK::MemoryOrder::memory_order_acq_rel) == true)
-            Thread::finalize_dying_threads();
-        else
-            g_finalizer_wait_queue->wait_forever(finalizer_task_name);
+        MUST(g_finalizer_wait_queue->wait_until(g_finalizer_has_work, [](bool& has_work) -> bool {
+            if (!has_work)
+                return false;
+            has_work = false;
+            return true;
+        }));;
+        Thread::finalize_dying_threads();
     }
     Process::current().sys$exit(0);
     VERIFY_NOT_REACHED();

Kernel/Tasks/Scheduler.cpp

@@ -16,6 +16,7 @@
 #include <Kernel/Tasks/PerformanceManager.h>
 #include <Kernel/Tasks/Process.h>
 #include <Kernel/Tasks/Scheduler.h>
+#include <Kernel/Tasks/WaitQueue.h>
 #include <Kernel/Time/TimeManagement.h>
 #include <Kernel/kstdio.h>
 
@@ -32,8 +33,8 @@ static u32 time_slice_for(Thread const& thread)
 }
 
 READONLY_AFTER_INIT Thread* g_finalizer;
-READONLY_AFTER_INIT DeprecatedWaitQueue* g_finalizer_wait_queue;
-Atomic<bool> g_finalizer_has_work { false };
+READONLY_AFTER_INIT WaitQueue* g_finalizer_wait_queue;
+SpinlockProtected<bool, LockRank::None> g_finalizer_has_work;
 READONLY_AFTER_INIT static Process* s_colonel_process;
 
 struct ThreadReadyQueue {
@@ -376,9 +377,11 @@ UNMAP_AFTER_INIT void Scheduler::initialize()
     VERIFY(Processor::is_initialized()); // sanity check
     VERIFY(TimeManagement::is_initialized());
 
-    g_finalizer_wait_queue = new DeprecatedWaitQueue;
+    g_finalizer_wait_queue = new WaitQueue;
 
-    g_finalizer_has_work.store(false, AK::MemoryOrder::memory_order_release);
+    g_finalizer_has_work.with([](auto& has_work) {
+        has_work = false;
+    });
     auto [colonel_process, idle_thread] = MUST(Process::create_kernel_process("colonel"sv, idle_loop, nullptr, 1, Process::RegisterProcess::No));
     s_colonel_process = &colonel_process.leak_ref();
     idle_thread->set_priority(THREAD_PRIORITY_MIN);
@@ -477,8 +480,10 @@ void Scheduler::invoke_async()
 
 void Scheduler::notify_finalizer()
 {
-    if (!g_finalizer_has_work.exchange(true, AK::MemoryOrder::memory_order_acq_rel))
-        g_finalizer_wait_queue->wake_all();
+    g_finalizer_has_work.with([](auto& has_work) {
+        has_work = true;
+        g_finalizer_wait_queue->notify_all();
+    });
 }
 
 void Scheduler::idle_loop(void*)

Kernel/Tasks/Scheduler.h

@@ -12,6 +12,7 @@
 #include <AK/Types.h>
 #include <Kernel/Forward.h>
 #include <Kernel/Locking/Spinlock.h>
+#include <Kernel/Locking/SpinlockProtected.h>
 #include <Kernel/Time/TimeManagement.h>
 #include <Kernel/UnixTypes.h>
 
@@ -20,8 +21,8 @@ namespace Kernel {
 struct RegisterState;
 
 extern Thread* g_finalizer;
-extern DeprecatedWaitQueue* g_finalizer_wait_queue;
-extern Atomic<bool> g_finalizer_has_work;
+extern WaitQueue* g_finalizer_wait_queue;
+extern SpinlockProtected<bool, LockRank::None> g_finalizer_has_work;
 extern RecursiveSpinlock<LockRank::None> g_scheduler_lock;
 
 struct TotalTimeScheduled {

Kernel/Tasks/Thread.cpp

@@ -577,8 +577,11 @@ void Thread::finalize_dying_threads()
             auto result = dying_threads.try_append(&thread);
             // We ignore allocation failures above the first 32 guaranteed thread slots, and
             // just flag our future-selves to finalize these threads at a later point
-            if (result.is_error())
-                g_finalizer_has_work.store(true, AK::MemoryOrder::memory_order_release);
+            if (result.is_error()) {
+                g_finalizer_has_work.with([](bool& has_work) {
+                    has_work = true;
+                });
+            }
         });
     }
     for (auto* thread : dying_threads) {