sm: implement accurate request deferral semantics

stratosphere/sm/source/impl/sm_wait_list.cpp

@@ -0,0 +1,107 @@
+/*
+ * 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 <stratosphere.hpp>
+#include "sm_wait_list.hpp"
+
+namespace ams::sm::impl {
+
+    namespace {
+
+        static constexpr size_t DeferredSessionCountMax = 0x40;
+
+        struct WaitListEntry {
+            sm::ServiceName service;
+            os::WaitableHolderType *session;
+        };
+
+        constinit WaitListEntry g_entries[DeferredSessionCountMax];
+        constinit WaitListEntry *g_processing_entry = nullptr;
+        constinit ServiceName g_triggered_service = InvalidServiceName;
+
+        WaitListEntry *Find(ServiceName service) {
+            for (auto &entry : g_entries) {
+                if (entry.service == service) {
+                    return std::addressof(entry);
+                }
+            }
+
+            return nullptr;
+        }
+
+    }
+
+    Result StartRegisterRetry(ServiceName service) {
+        /* Check that we're not already processing a retry. */
+        AMS_ABORT_UNLESS(g_processing_entry == nullptr);
+
+        /* Find a free entry. */
+        auto *entry = Find(InvalidServiceName);
+        R_UNLESS(entry != nullptr, sm::ResultOutOfProcesses());
+
+        /* Initialize the entry. */
+        entry->service = service;
+        entry->session = nullptr;
+
+        /* Set the processing entry. */
+        g_processing_entry = entry;
+
+        return sf::ResultRequestDeferredByUser();
+    }
+
+    void ProcessRegisterRetry(os::WaitableHolderType *session_holder) {
+        /* Verify that we have a processing entry. */
+        AMS_ABORT_UNLESS(g_processing_entry != nullptr);
+
+        /* Process the session. */
+        g_processing_entry->session = session_holder;
+        g_processing_entry = nullptr;
+    }
+
+    void TriggerResume(ServiceName service) {
+        /* Check that we haven't already triggered a resume. */
+        AMS_ABORT_UNLESS(g_triggered_service == InvalidServiceName);
+
+        /* Set the triggered resume. */
+        g_triggered_service = service;
+    }
+
+    void TestAndResume(ResumeFunction resume_function) {
+        /* If we don't have a triggered service, there's nothing to do. */
+        if (g_triggered_service == InvalidServiceName) {
+            return;
+        }
+
+        /* Process all entries. */
+        for (auto &entry : g_entries) {
+            if (entry.service == g_triggered_service) {
+                /* Get the entry's session. */
+                auto * const session = entry.session;
+
+                /* Clear the entry. */
+                entry.service = InvalidServiceName;
+                entry.session = nullptr;
+
+                /* Resume the request. */
+                R_TRY_CATCH(resume_function(session)) {
+                    R_CATCH(sf::ResultRequestDeferred) {
+                        ProcessRegisterRetry(session);
+                    }
+                } R_END_TRY_CATCH_WITH_ABORT_UNLESS;
+            }
+        }
+    }
+
+}