1 files changed, 112 insertions, 12 deletions

diff --git a/src/core/hle/service/pm/pm.cpp b/src/core/hle/service/pm/pm.cpp
index ebcc41a43..fe6b5f798 100644
--- a/src/core/hle/service/pm/pm.cpp
+++ b/src/core/hle/service/pm/pm.cpp
@@ -3,11 +3,44 @@
 // Refer to the license.txt file included.
 
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/service/pm/pm.h"
 #include "core/hle/service/service.h"
 
 namespace Service::PM {
 
+namespace {
+
+constexpr ResultCode ERROR_PROCESS_NOT_FOUND{ErrorModule::PM, 1};
+
+constexpr u64 NO_PROCESS_FOUND_PID{0};
+
+std::optional<Kernel::SharedPtr<Kernel::Process>> SearchProcessList(
+    const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list,
+    std::function<bool(const Kernel::SharedPtr<Kernel::Process>&)> predicate) {
+    const auto iter = std::find_if(process_list.begin(), process_list.end(), predicate);
+
+    if (iter == process_list.end()) {
+        return std::nullopt;
+    }
+
+    return *iter;
+}
+
+void GetApplicationPidGeneric(Kernel::HLERequestContext& ctx,
+                              const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list) {
+    const auto process = SearchProcessList(process_list, [](const auto& process) {
+        return process->GetProcessID() == Kernel::Process::ProcessIDMin;
+    });
+
+    IPC::ResponseBuilder rb{ctx, 4};
+    rb.Push(RESULT_SUCCESS);
+    rb.Push(process.has_value() ? (*process)->GetProcessID() : NO_PROCESS_FOUND_PID);
+}
+
+} // Anonymous namespace
+
 class BootMode final : public ServiceFramework<BootMode> {
 public:
     explicit BootMode() : ServiceFramework{"pm:bm"} {
@@ -41,14 +74,15 @@ private:
 
 class DebugMonitor final : public ServiceFramework<DebugMonitor> {
 public:
-    explicit DebugMonitor() : ServiceFramework{"pm:dmnt"} {
+    explicit DebugMonitor(const Kernel::KernelCore& kernel)
+        : ServiceFramework{"pm:dmnt"}, kernel(kernel) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "GetDebugProcesses"},
             {1, nullptr, "StartDebugProcess"},
-            {2, nullptr, "GetTitlePid"},
+            {2, &DebugMonitor::GetTitlePid, "GetTitlePid"},
             {3, nullptr, "EnableDebugForTitleId"},
-            {4, nullptr, "GetApplicationPid"},
+            {4, &DebugMonitor::GetApplicationPid, "GetApplicationPid"},
             {5, nullptr, "EnableDebugForApplication"},
             {6, nullptr, "DisableDebug"},
         };
@@ -56,21 +90,77 @@ public:
 
         RegisterHandlers(functions);
     }
+
+private:
+    void GetTitlePid(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto title_id = rp.PopRaw<u64>();
+
+        LOG_DEBUG(Service_PM, "called, title_id={:016X}", title_id);
+
+        const auto process =
+            SearchProcessList(kernel.GetProcessList(), [title_id](const auto& process) {
+                return process->GetTitleID() == title_id;
+            });
+
+        if (!process.has_value()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_PROCESS_NOT_FOUND);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push((*process)->GetProcessID());
+    }
+
+    void GetApplicationPid(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_PM, "called");
+        GetApplicationPidGeneric(ctx, kernel.GetProcessList());
+    }
+
+    const Kernel::KernelCore& kernel;
 };
 
 class Info final : public ServiceFramework<Info> {
 public:
-    explicit Info() : ServiceFramework{"pm:info"} {
+    explicit Info(const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list)
+        : ServiceFramework{"pm:info"}, process_list(process_list) {
         static const FunctionInfo functions[] = {
-            {0, nullptr, "GetTitleId"},
+            {0, &Info::GetTitleId, "GetTitleId"},
         };
         RegisterHandlers(functions);
     }
+
+private:
+    void GetTitleId(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto process_id = rp.PopRaw<u64>();
+
+        LOG_DEBUG(Service_PM, "called, process_id={:016X}", process_id);
+
+        const auto process = SearchProcessList(process_list, [process_id](const auto& process) {
+            return process->GetProcessID() == process_id;
+        });
+
+        if (!process.has_value()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_PROCESS_NOT_FOUND);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push((*process)->GetTitleID());
+    }
+
+    const std::vector<Kernel::SharedPtr<Kernel::Process>>& process_list;
 };
 
 class Shell final : public ServiceFramework<Shell> {
 public:
-    explicit Shell() : ServiceFramework{"pm:shell"} {
+    explicit Shell(const Kernel::KernelCore& kernel)
+        : ServiceFramework{"pm:shell"}, kernel(kernel) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, nullptr, "LaunchProcess"},
@@ -79,21 +169,31 @@ public:
             {3, nullptr, "GetProcessEventWaiter"},
             {4, nullptr, "GetProcessEventType"},
             {5, nullptr, "NotifyBootFinished"},
-            {6, nullptr, "GetApplicationPid"},
+            {6, &Shell::GetApplicationPid, "GetApplicationPid"},
             {7, nullptr, "BoostSystemMemoryResourceLimit"},
             {8, nullptr, "EnableAdditionalSystemThreads"},
+            {9, nullptr, "GetUnimplementedEventHandle"},
         };
         // clang-format on
 
         RegisterHandlers(functions);
     }
+
+private:
+    void GetApplicationPid(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_PM, "called");
+        GetApplicationPidGeneric(ctx, kernel.GetProcessList());
+    }
+
+    const Kernel::KernelCore& kernel;
 };
 
-void InstallInterfaces(SM::ServiceManager& sm) {
-    std::make_shared<BootMode>()->InstallAsService(sm);
-    std::make_shared<DebugMonitor>()->InstallAsService(sm);
-    std::make_shared<Info>()->InstallAsService(sm);
-    std::make_shared<Shell>()->InstallAsService(sm);
+void InstallInterfaces(Core::System& system) {
+    std::make_shared<BootMode>()->InstallAsService(system.ServiceManager());
+    std::make_shared<DebugMonitor>(system.Kernel())->InstallAsService(system.ServiceManager());
+    std::make_shared<Info>(system.Kernel().GetProcessList())
+        ->InstallAsService(system.ServiceManager());
+    std::make_shared<Shell>(system.Kernel())->InstallAsService(system.ServiceManager());
 }
 
 } // namespace Service::PM