debugger: monitor handles lists each handle's type and service event name

gdbrsp.py gains raw and monitor commands.

3 files changed, 48 insertions, 1 deletions

diff --git a/src/core/debugger/gdbstub.cpp b/src/core/debugger/gdbstub.cpp
index 44ddf11c39..71af2acee3 100644
--- a/src/core/debugger/gdbstub.cpp
+++ b/src/core/debugger/gdbstub.cpp
@@ -25,7 +25,10 @@
 #include "core/debugger/gdbstub_arch.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_thread.h"
+#include "core/hle/service/kernel_helpers.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 
@@ -731,8 +734,26 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
                 break;
             cur_addr = next_address;
         }
+    } else if (command_str == "handles" || command_str == "get handles") {
+        // Every handle of the process: its object type and, for service events, their name.
+        reply = "Handles:\n";
+        auto& handle_table = debug_process->GetHandleTable();
+        for (size_t i = 0; i < handle_table.GetTableSize(); ++i) {
+            Kernel::Handle handle{};
+            auto object = handle_table.GetObjectByIndex(system.Kernel(), std::addressof(handle), i);
+            if (object.IsNull()) {
+                continue;
+            }
+            std::string name;
+            if (auto* readable = object->DynamicCast<Kernel::KReadableEvent*>(); readable != nullptr) {
+                name = Service::KernelHelpers::ServiceContext::GetEventName(readable->GetParent());
+            } else if (auto* event = object->DynamicCast<Kernel::KEvent*>(); event != nullptr) {
+                name = Service::KernelHelpers::ServiceContext::GetEventName(event);
+            }
+            reply += fmt::format("  {:#010x} {} {}\n", handle, object->GetTypeObj().GetName(), name);
+        }
     } else {
-        reply += "Commands: fastmem, info, mappings\n";
+        reply += "Commands: fastmem, info, mappings, handles\n";
     }
 
     std::span<const u8> reply_span{reinterpret_cast<u8*>(&reply.front()), reply.size()};
diff --git a/src/core/hle/service/kernel_helpers.cpp b/src/core/hle/service/kernel_helpers.cpp
index f7a5cb7049..e4d6925f19 100644
--- a/src/core/hle/service/kernel_helpers.cpp
+++ b/src/core/hle/service/kernel_helpers.cpp
@@ -4,6 +4,9 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <mutex>
+#include <unordered_map>
+
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"
@@ -16,6 +19,12 @@
 
 namespace Service::KernelHelpers {
 
+namespace {
+// Event names for the debugger's handle listing.
+std::mutex event_names_mutex;
+std::unordered_map<const Kernel::KEvent*, std::string> event_names;
+} // namespace
+
 ServiceContext::ServiceContext(Core::System& system_, std::string name_)
     : kernel(system_.Kernel())
 {
@@ -64,14 +73,28 @@ Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
     // Register the event.
     Kernel::KEvent::Register(kernel, event);
 
+    {
+        std::scoped_lock lk{event_names_mutex};
+        event_names[event] = std::move(name);
+    }
     return event;
 }
 
 void ServiceContext::CloseEvent(Kernel::KEvent* event) {
     if (event) {
+        {
+            std::scoped_lock lk{event_names_mutex};
+            event_names.erase(event);
+        }
         event->GetReadableEvent().Close(kernel);
         event->Close(kernel);
     }
 }
 
+std::string ServiceContext::GetEventName(const Kernel::KEvent* event) {
+    std::scoped_lock lk{event_names_mutex};
+    const auto it = event_names.find(event);
+    return it == event_names.end() ? std::string{} : it->second;
+}
+
 } // namespace Service::KernelHelpers
diff --git a/src/core/hle/service/kernel_helpers.h b/src/core/hle/service/kernel_helpers.h
index 4e21c8857f..a62dd838aa 100644
--- a/src/core/hle/service/kernel_helpers.h
+++ b/src/core/hle/service/kernel_helpers.h
@@ -29,6 +29,9 @@ public:
 
     void CloseEvent(Kernel::KEvent* event);
 
+    /// Name an event was created with (debugger handle listing); empty when unknown.
+    static std::string GetEventName(const Kernel::KEvent* event);
+
     Kernel::KernelCore& kernel;
     Kernel::KProcess* process{};
     bool process_created{false};