kern: improve KSynchronizationObject, kill KSynchronization

libraries/libmesosphere/include/mesosphere.hpp

@@ -77,7 +77,6 @@
 #include <mesosphere/kern_select_debug.hpp>
 #include <mesosphere/kern_k_process.hpp>
 #include <mesosphere/kern_k_resource_limit.hpp>
-#include <mesosphere/kern_k_synchronization.hpp>
 
 /* More Miscellaneous objects. */
 #include <mesosphere/kern_k_object_name.hpp>

libraries/libmesosphere/include/mesosphere/kern_k_synchronization.hpp

@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-#include <mesosphere/kern_k_auto_object.hpp>
-#include <mesosphere/kern_slab_helpers.hpp>
-#include <mesosphere/kern_k_linked_list.hpp>
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-#include <mesosphere/kern_k_auto_object.hpp>
-#include <mesosphere/kern_k_synchronization_object.hpp>
-#include <mesosphere/kern_k_thread.hpp>
-
-namespace ams::kern {
-
-    class KSynchronization {
-        private:
-            friend class KSynchronizationObject;
-        public:
-            constexpr KSynchronization() { /* ... */ }
-
-            Result Wait(s32 *out_index, KSynchronizationObject **objects, const s32 num_objects, s64 timeout);
-        private:
-            void OnAvailable(KSynchronizationObject *object);
-            void OnAbort(KSynchronizationObject *object, Result abort_reason);
-    };
-
-}

libraries/libmesosphere/include/mesosphere/kern_k_synchronization_object.hpp

@@ -25,28 +25,28 @@ namespace ams::kern {
     class KSynchronizationObject : public KAutoObjectWithList {
         MESOSPHERE_AUTOOBJECT_TRAITS(KSynchronizationObject, KAutoObject);
         public:
-            using ThreadList = KLinkedList<KThread>;
+            struct ThreadListNode {
-            using iterator = ThreadList::iterator;
+                ThreadListNode *next;
+                KThread *thread;
+            };
         private:
-            ThreadList thread_list;
+            ThreadListNode *thread_list_root;
         protected:
-            constexpr ALWAYS_INLINE explicit KSynchronizationObject() : KAutoObjectWithList(), thread_list() { MESOSPHERE_ASSERT_THIS(); }
+            constexpr ALWAYS_INLINE explicit KSynchronizationObject() : KAutoObjectWithList(), thread_list_root() { MESOSPHERE_ASSERT_THIS(); }
             virtual ~KSynchronizationObject() { MESOSPHERE_ASSERT_THIS(); }
 
             virtual void OnFinalizeSynchronizationObject() { MESOSPHERE_ASSERT_THIS(); }
 
-            void NotifyAvailable();
+            void NotifyAvailable(Result result);
-            void NotifyAbort(Result abort_reason);
+            void NotifyAvailable() {
+                return this->NotifyAvailable(ResultSuccess());
+            }
+        public:
+            static Result Wait(s32 *out_index, KSynchronizationObject **objects, const s32 num_objects, s64 timeout);
         public:
             virtual void Finalize() override;
             virtual bool IsSignaled() const = 0;
             virtual void DebugWaiters();
-
-            iterator RegisterWaitingThread(KThread *thread);
-            iterator UnregisterWaitingThread(iterator it);
-
-            iterator begin();
-            iterator end();
     };
 
 }

libraries/libmesosphere/include/mesosphere/kern_kernel.hpp

@@ -37,7 +37,6 @@ namespace ams::kern {
     class KPageTableManager;
     class KMemoryBlockSlabManager;
     class KBlockInfoManager;
-    class KSynchronization;
     class KUnsafeMemory;
 
 #if defined(ATMOSPHERE_ARCH_ARM64)
@@ -73,7 +72,6 @@ namespace ams::kern {
             static KMemoryBlockSlabManager s_sys_memory_block_manager;
             static KBlockInfoManager s_block_info_manager;
             static KSupervisorPageTable s_supervisor_page_table;
-            static KSynchronization s_synchronization;
             static KUnsafeMemory s_unsafe_memory;
             static KWorkerTaskManager s_worker_task_managers[KWorkerTaskManager::WorkerType_Count];
             static KInterruptManager s_interrupt_manager;
@@ -144,10 +142,6 @@ namespace ams::kern {
                 return s_supervisor_page_table;
             }
 
-            static ALWAYS_INLINE KSynchronization &GetSynchronization() {
-                return s_synchronization;
-            }
-
             static ALWAYS_INLINE KUnsafeMemory &GetUnsafeMemory() {
                 return s_unsafe_memory;
             }

libraries/libmesosphere/source/kern_k_server_session.cpp

@@ -1359,7 +1359,7 @@ namespace ams::kern {
         }
 
         /* Notify. */
-        this->NotifyAbort(svc::ResultSessionClosed());
+        this->NotifyAvailable(svc::ResultSessionClosed());
     }
 
 }

libraries/libmesosphere/source/kern_k_synchronization.cpp

@@ -1,139 +0,0 @@
-/*
- * Copyright (c) 2018-2020 Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#include <mesosphere.hpp>
-
-namespace ams::kern {
-
-    Result KSynchronization::Wait(s32 *out_index, KSynchronizationObject **objects, const s32 num_objects, s64 timeout) {
-        MESOSPHERE_ASSERT_THIS();
-
-        /* Allocate space on stack for thread iterators. */
-        KSynchronizationObject::iterator *thread_iters = static_cast<KSynchronizationObject::iterator *>(__builtin_alloca(sizeof(KSynchronizationObject::iterator) * num_objects));
-
-        /* Prepare for wait. */
-        KThread *thread = GetCurrentThreadPointer();
-        s32 sync_index = -1;
-        KHardwareTimer *timer;
-
-        {
-            /* Setup the scheduling lock and sleep. */
-            KScopedSchedulerLockAndSleep slp(std::addressof(timer), thread, timeout);
-
-            /* Check if any of the objects are already signaled. */
-            for (auto i = 0; i < num_objects; ++i) {
-                AMS_ASSERT(objects[i] != nullptr);
-
-                if (objects[i]->IsSignaled()) {
-                    *out_index = i;
-                    slp.CancelSleep();
-                    return ResultSuccess();
-                }
-            }
-
-            /* Check if the timeout is zero. */
-            if (timeout == 0) {
-                slp.CancelSleep();
-                return svc::ResultTimedOut();
-            }
-
-            /* Check if the thread should terminate. */
-            if (thread->IsTerminationRequested()) {
-                slp.CancelSleep();
-                return svc::ResultTerminationRequested();
-            }
-
-            /* Check if waiting was canceled. */
-            if (thread->IsWaitCancelled()) {
-                slp.CancelSleep();
-                thread->ClearWaitCancelled();
-                return svc::ResultCancelled();
-            }
-
-            /* Add the waiters. */
-            for (auto i = 0; i < num_objects; ++i) {
-                thread_iters[i] = objects[i]->RegisterWaitingThread(thread);
-            }
-
-            /* Mark the thread as waiting. */
-            thread->SetCancellable();
-            thread->SetSyncedObject(nullptr, svc::ResultTimedOut());
-            thread->SetState(KThread::ThreadState_Waiting);
-        }
-
-        /* The lock/sleep is done, so we should be able to get our result. */
-
-        /* Thread is no longer cancellable. */
-        thread->ClearCancellable();
-
-        /* Cancel the timer as needed. */
-        if (timer != nullptr) {
-            timer->CancelTask(thread);
-        }
-
-        /* Get the wait result. */
-        Result wait_result;
-        {
-            KScopedSchedulerLock lk;
-            KSynchronizationObject *synced_obj;
-            wait_result = thread->GetWaitResult(std::addressof(synced_obj));
-
-            for (auto i = 0; i < num_objects; ++i) {
-                objects[i]->UnregisterWaitingThread(thread_iters[i]);
-                if (objects[i] == synced_obj) {
-                    sync_index = i;
-                }
-            }
-        }
-
-        /* Set output. */
-        *out_index = sync_index;
-        return wait_result;
-    }
-
-    void KSynchronization::OnAvailable(KSynchronizationObject *object) {
-        MESOSPHERE_ASSERT_THIS();
-
-        KScopedSchedulerLock sl;
-
-        /* If we're not signaled, we've nothing to notify. */
-        if (!object->IsSignaled()) {
-            return;
-        }
-
-        /* Iterate over each thread. */
-        for (auto &thread : *object) {
-            if (thread.GetState() == KThread::ThreadState_Waiting) {
-                thread.SetSyncedObject(object, ResultSuccess());
-                thread.SetState(KThread::ThreadState_Runnable);
-            }
-        }
-    }
-
-    void KSynchronization::OnAbort(KSynchronizationObject *object, Result abort_reason) {
-        MESOSPHERE_ASSERT_THIS();
-
-        KScopedSchedulerLock sl;
-
-        /* Iterate over each thread. */
-        for (auto &thread : *object) {
-            if (thread.GetState() == KThread::ThreadState_Waiting) {
-                thread.SetSyncedObject(object, abort_reason);
-                thread.SetState(KThread::ThreadState_Runnable);
-            }
-        }
-    }
-
-}

libraries/libmesosphere/source/kern_k_synchronization_object.cpp

@@ -17,18 +17,6 @@
 
 namespace ams::kern {
 
-    void KSynchronizationObject::NotifyAvailable() {
-        MESOSPHERE_ASSERT_THIS();
-
-        Kernel::GetSynchronization().OnAvailable(this);
-    }
-
-    void KSynchronizationObject::NotifyAbort(Result abort_reason) {
-        MESOSPHERE_ASSERT_THIS();
-
-        Kernel::GetSynchronization().OnAbort(this, abort_reason);
-    }
-
     void KSynchronizationObject::Finalize() {
         MESOSPHERE_ASSERT_THIS();
 
@@ -37,9 +25,8 @@ namespace ams::kern {
         {
             KScopedSchedulerLock sl;
 
-            auto end = this->end();
+            for (auto *cur_node = this->thread_list_root; cur_node != nullptr; cur_node = cur_node->next) {
-            for (auto it = this->begin(); it != end; ++it) {
+                KThread *thread = cur_node->thread;
-                KThread *thread = std::addressof(*it);
                 MESOSPHERE_LOG("KSynchronizationObject::Finalize(%p) with %p (id=%ld) waiting.\n", this, thread, thread->GetId());
             }
         }
@@ -49,6 +36,118 @@ namespace ams::kern {
         KAutoObject::Finalize();
     }
 
+    Result KSynchronizationObject::Wait(s32 *out_index, KSynchronizationObject **objects, const s32 num_objects, s64 timeout) {
+        /* Allocate space on stack for thread nodes. */
+        ThreadListNode *thread_nodes = static_cast<ThreadListNode *>(__builtin_alloca(sizeof(ThreadListNode) * num_objects));
+
+        /* Prepare for wait. */
+        KThread *thread = GetCurrentThreadPointer();
+        KHardwareTimer *timer;
+
+        {
+            /* Setup the scheduling lock and sleep. */
+            KScopedSchedulerLockAndSleep slp(std::addressof(timer), thread, timeout);
+
+            /* Check if any of the objects are already signaled. */
+            for (auto i = 0; i < num_objects; ++i) {
+                AMS_ASSERT(objects[i] != nullptr);
+
+                if (objects[i]->IsSignaled()) {
+                    *out_index = i;
+                    slp.CancelSleep();
+                    return ResultSuccess();
+                }
+            }
+
+            /* Check if the timeout is zero. */
+            if (timeout == 0) {
+                slp.CancelSleep();
+                return svc::ResultTimedOut();
+            }
+
+            /* Check if the thread should terminate. */
+            if (thread->IsTerminationRequested()) {
+                slp.CancelSleep();
+                return svc::ResultTerminationRequested();
+            }
+
+            /* Check if waiting was canceled. */
+            if (thread->IsWaitCancelled()) {
+                slp.CancelSleep();
+                thread->ClearWaitCancelled();
+                return svc::ResultCancelled();
+            }
+
+            /* Add the waiters. */
+            for (auto i = 0; i < num_objects; ++i) {
+                thread_nodes[i].thread      = thread;
+                thread_nodes[i].next        = objects[i]->thread_list_root;
+                objects[i]->thread_list_root = std::addressof(thread_nodes[i]);
+            }
+
+            /* Mark the thread as waiting. */
+            thread->SetCancellable();
+            thread->SetSyncedObject(nullptr, svc::ResultTimedOut());
+            thread->SetState(KThread::ThreadState_Waiting);
+        }
+
+        /* The lock/sleep is done, so we should be able to get our result. */
+
+        /* Thread is no longer cancellable. */
+        thread->ClearCancellable();
+
+        /* Cancel the timer as needed. */
+        if (timer != nullptr) {
+            timer->CancelTask(thread);
+        }
+
+        /* Get the wait result. */
+        Result wait_result;
+        s32 sync_index = -1;
+        {
+            KScopedSchedulerLock lk;
+            KSynchronizationObject *synced_obj;
+            wait_result = thread->GetWaitResult(std::addressof(synced_obj));
+
+            for (auto i = 0; i < num_objects; ++i) {
+                /* Unlink the object from the list. */
+                ThreadListNode **link = std::addressof(objects[i]->thread_list_root);
+                while (*link != std::addressof(thread_nodes[i])) {
+                    link = std::addressof((*link)->next);
+                }
+                *link = thread_nodes[i].next;
+
+                if (objects[i] == synced_obj) {
+                    sync_index = i;
+                }
+            }
+        }
+
+        /* Set output. */
+        *out_index = sync_index;
+        return wait_result;
+    }
+
+    void KSynchronizationObject::NotifyAvailable(Result result) {
+        MESOSPHERE_ASSERT_THIS();
+
+        KScopedSchedulerLock sl;
+
+        /* If we're not signaled, we've nothing to notify. */
+        if (!this->IsSignaled()) {
+            return;
+        }
+
+        /* Iterate over each thread. */
+        for (auto *cur_node = this->thread_list_root; cur_node != nullptr; cur_node = cur_node->next) {
+            KThread *thread = cur_node->thread;
+            if (thread->GetState() == KThread::ThreadState_Waiting) {
+                thread->SetSyncedObject(this, result);
+                thread->SetState(KThread::ThreadState_Runnable);
+            }
+        }
+    }
+
     void KSynchronizationObject::DebugWaiters() {
         MESOSPHERE_ASSERT_THIS();
 
@@ -60,9 +159,8 @@ namespace ams::kern {
             MESOSPHERE_RELEASE_LOG("Threads waiting on %p:\n", this);
 
             bool has_waiters = false;
-            auto end = this->end();
+            for (auto *cur_node = this->thread_list_root; cur_node != nullptr; cur_node = cur_node->next) {
-            for (auto it = this->begin(); it != end; ++it) {
+                KThread *thread = cur_node->thread;
-                KThread *thread = std::addressof(*it);
 
                 if (KProcess *process = thread->GetOwnerProcess(); process != nullptr) {
                     MESOSPHERE_RELEASE_LOG("    %p tid=%ld pid=%ld (%s)\n", thread, thread->GetId(), process->GetId(), process->GetName());
@@ -81,28 +179,4 @@ namespace ams::kern {
         #endif
     }
 
-    KSynchronizationObject::iterator KSynchronizationObject::RegisterWaitingThread(KThread *thread) {
-        MESOSPHERE_ASSERT_THIS();
-
-        return this->thread_list.insert(this->thread_list.end(), *thread);
-    }
-
-    KSynchronizationObject::iterator KSynchronizationObject::UnregisterWaitingThread(KSynchronizationObject::iterator it) {
-        MESOSPHERE_ASSERT_THIS();
-
-        return this->thread_list.erase(it);
-    }
-
-    KSynchronizationObject::iterator KSynchronizationObject::begin() {
-        MESOSPHERE_ASSERT_THIS();
-
-        return this->thread_list.begin();
-    }
-
-    KSynchronizationObject::iterator KSynchronizationObject::end() {
-        MESOSPHERE_ASSERT_THIS();
-
-        return this->thread_list.end();
-    }
-
 }

libraries/libmesosphere/source/kern_k_thread.cpp

@@ -1089,7 +1089,7 @@ namespace ams::kern {
             /* If the thread isn't terminated, wait for it to terminate. */
             s32 index;
             KSynchronizationObject *objects[] = { this };
-            Kernel::GetSynchronization().Wait(std::addressof(index), objects, 1, ams::svc::WaitInfinite);
+            KSynchronizationObject::Wait(std::addressof(index), objects, 1, ams::svc::WaitInfinite);
         }
     }
 

libraries/libmesosphere/source/svc/kern_svc_ipc.cpp

@@ -72,7 +72,7 @@ namespace ams::kern::svc {
                 /* Wait for a message. */
                 while (true) {
                     s32 index;
-                    Result result = Kernel::GetSynchronization().Wait(std::addressof(index), objs, num_objects, timeout);
+                    Result result = KSynchronizationObject::Wait(std::addressof(index), objs, num_objects, timeout);
                     if (svc::ResultTimedOut::Includes(result)) {
                         return result;
                     }

libraries/libmesosphere/source/svc/kern_svc_synchronization.cpp

@@ -63,7 +63,7 @@ namespace ams::kern::svc {
                 timeout = timeout_ns;
             }
 
-            return Kernel::GetSynchronization().Wait(out_index, objs, num_handles, timeout);
+            return KSynchronizationObject::Wait(out_index, objs, num_handles, timeout);
         }
 
         Result WaitSynchronization(int32_t *out_index, KUserPointer<const ams::svc::Handle *> user_handles, int32_t num_handles, int64_t timeout_ns) {

mesosphere/kernel/source/kern_kernel_instantiations.cpp

@@ -26,7 +26,6 @@ namespace ams::kern {
     constinit KMemoryBlockSlabManager Kernel::s_sys_memory_block_manager;
     constinit KBlockInfoManager       Kernel::s_block_info_manager;
     constinit KSupervisorPageTable    Kernel::s_supervisor_page_table;
-    constinit KSynchronization        Kernel::s_synchronization;
     constinit KUnsafeMemory           Kernel::s_unsafe_memory;
     constinit KWorkerTaskManager      Kernel::s_worker_task_managers[KWorkerTaskManager::WorkerType_Count];
     constinit KInterruptManager       Kernel::s_interrupt_manager;