Merge pull request #2611 from DarkLordZach/pm-info-cmd

pm: Implement various pm commands for finding process and title IDs

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

src/core/hle/service/pm/pm.h

@@ -4,8 +4,8 @@
 
 #pragma once
 
-namespace Service::SM {
-class ServiceManager;
+namespace Core {
+class System;
 }
 
 namespace Service::PM {
@@ -16,6 +16,6 @@ enum class SystemBootMode {
 };
 
 /// Registers all PM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager);
+void InstallInterfaces(Core::System& system);
 
 } // namespace Service::PM

src/core/hle/service/service.cpp

@@ -241,7 +241,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
     PCTL::InstallInterfaces(*sm);
     PCV::InstallInterfaces(*sm);
     PlayReport::InstallInterfaces(*sm);
-    PM::InstallInterfaces(*sm);
+    PM::InstallInterfaces(system);
     PSC::InstallInterfaces(*sm);
     PSM::InstallInterfaces(*sm);
     Set::InstallInterfaces(*sm);