From d6667e4cb85afb4a65aab25a4014920dfff9c6da Mon Sep 17 00:00:00 2001
From: Andreas Kling <kling@serenityos.org>
Date: Sat, 7 Aug 2021 13:12:35 +0200
Subject: [PATCH] Kernel: Port process groups to SpinLockProtectedValue

---
 Kernel/Process.cpp      |  1 -
 Kernel/ProcessGroup.cpp | 55 ++++++++++++++++++++++++-----------------
 Kernel/ProcessGroup.h   |  5 ++--
 3 files changed, 35 insertions(+), 26 deletions(-)

diff --git a/Kernel/Process.cpp b/Kernel/Process.cpp
index d920b4ff2f6..b417b6d40db 100644
--- a/Kernel/Process.cpp
+++ b/Kernel/Process.cpp
@@ -76,7 +76,6 @@ UNMAP_AFTER_INIT void Process::initialize()
     g_modules = new HashMap<String, OwnPtr<Module>>;
 
     next_pid.store(0, AK::MemoryOrder::memory_order_release);
-    g_process_groups = new ProcessGroup::List();
 
     hostname().with_exclusive([&](auto& name) {
         name = "courage";
diff --git a/Kernel/ProcessGroup.cpp b/Kernel/ProcessGroup.cpp
index 443363e94d8..8de61719a0c 100644
--- a/Kernel/ProcessGroup.cpp
+++ b/Kernel/ProcessGroup.cpp
@@ -1,52 +1,63 @@
 /*
  * Copyright (c) 2020, the SerenityOS developers.
+ * Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
 
+#include <AK/Singleton.h>
 #include <Kernel/ProcessGroup.h>
 
 namespace Kernel {
 
-RecursiveSpinLock g_process_groups_lock;
-ProcessGroup::List* g_process_groups;
+static AK::Singleton<SpinLockProtectedValue<ProcessGroup::List>> s_process_groups;
+
+SpinLockProtectedValue<ProcessGroup::List>& process_groups()
+{
+    return *s_process_groups;
+}
 
 ProcessGroup::~ProcessGroup()
 {
-    ScopedSpinLock lock(g_process_groups_lock);
-    g_process_groups->remove(*this);
+    process_groups().with([&](auto& groups) {
+        groups.remove(*this);
+    });
 }
 
 RefPtr<ProcessGroup> ProcessGroup::create(ProcessGroupID pgid)
 {
     auto process_group = adopt_ref_if_nonnull(new (nothrow) ProcessGroup(pgid));
-    if (process_group) {
-        ScopedSpinLock lock(g_process_groups_lock);
-        g_process_groups->prepend(*process_group);
-    }
-
+    if (!process_group)
+        return {};
+    process_groups().with([&](auto& groups) {
+        groups.prepend(*process_group);
+    });
     return process_group;
 }
 
 RefPtr<ProcessGroup> ProcessGroup::find_or_create(ProcessGroupID pgid)
 {
-    ScopedSpinLock lock(g_process_groups_lock);
-
-    if (auto existing = from_pgid(pgid))
-        return existing.release_nonnull();
-
-    return create(pgid);
+    return process_groups().with([&](auto& groups) -> RefPtr<ProcessGroup> {
+        for (auto& group : groups) {
+            if (group.pgid() == pgid)
+                return &group;
+        }
+        auto process_group = adopt_ref_if_nonnull(new (nothrow) ProcessGroup(pgid));
+        if (process_group)
+            groups.prepend(*process_group);
+        return process_group;
+    });
 }
 
 RefPtr<ProcessGroup> ProcessGroup::from_pgid(ProcessGroupID pgid)
 {
-    ScopedSpinLock lock(g_process_groups_lock);
-
-    for (auto& group : *g_process_groups) {
-        if (group.pgid() == pgid)
-            return &group;
-    }
-    return nullptr;
+    return process_groups().with([&](auto& groups) -> RefPtr<ProcessGroup> {
+        for (auto& group : groups) {
+            if (group.pgid() == pgid)
+                return &group;
+        }
+        return nullptr;
+    });
 }
 
 }
diff --git a/Kernel/ProcessGroup.h b/Kernel/ProcessGroup.h
index 0798afd8f83..1fdea593ed9 100644
--- a/Kernel/ProcessGroup.h
+++ b/Kernel/ProcessGroup.h
@@ -9,7 +9,7 @@
 #include <AK/IntrusiveList.h>
 #include <AK/RefCounted.h>
 #include <AK/Weakable.h>
-#include <Kernel/Locking/SpinLock.h>
+#include <Kernel/Locking/SpinLockProtectedValue.h>
 #include <Kernel/UnixTypes.h>
 
 namespace Kernel {
@@ -43,7 +43,6 @@ public:
     using List = IntrusiveList<ProcessGroup, RawPtr<ProcessGroup>, &ProcessGroup::m_list_node>;
 };
 
-extern ProcessGroup::List* g_process_groups;
-extern RecursiveSpinLock g_process_groups_lock;
+SpinLockProtectedValue<ProcessGroup::List>& process_groups();
 
 }