2018-07-25 16:37:00 -04:00
|
|
|
// Copyright 2018 yuzu emulator team
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2020-11-08 15:49:45 -05:00
|
|
|
#include "core/core.h"
|
2018-08-23 18:31:45 -04:00
|
|
|
#include "core/hle/ipc_helpers.h"
|
2021-04-24 01:04:28 -04:00
|
|
|
#include "core/hle/kernel/k_process.h"
|
2019-06-26 19:06:51 -04:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2018-08-23 18:31:45 -04:00
|
|
|
#include "core/hle/service/pm/pm.h"
|
2018-07-25 16:37:00 -04:00
|
|
|
#include "core/hle/service/service.h"
|
|
|
|
|
|
|
|
namespace Service::PM {
|
|
|
|
|
2019-06-26 19:05:04 -04:00
|
|
|
namespace {
|
|
|
|
|
2021-11-20 19:42:30 -05:00
|
|
|
constexpr ResultCode ResultProcessNotFound{ErrorModule::PM, 1};
|
|
|
|
[[maybe_unused]] constexpr ResultCode ResultAlreadyStarted{ErrorModule::PM, 2};
|
|
|
|
[[maybe_unused]] constexpr ResultCode ResultNotTerminated{ErrorModule::PM, 3};
|
|
|
|
[[maybe_unused]] constexpr ResultCode ResultDebugHookInUse{ErrorModule::PM, 4};
|
|
|
|
[[maybe_unused]] constexpr ResultCode ResultApplicationRunning{ErrorModule::PM, 5};
|
|
|
|
[[maybe_unused]] constexpr ResultCode ResultInvalidSize{ErrorModule::PM, 6};
|
2019-06-26 19:05:04 -04:00
|
|
|
|
|
|
|
constexpr u64 NO_PROCESS_FOUND_PID{0};
|
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
std::optional<Kernel::KProcess*> SearchProcessList(
|
|
|
|
const std::vector<Kernel::KProcess*>& process_list,
|
|
|
|
std::function<bool(Kernel::KProcess*)> predicate) {
|
2019-06-26 19:05:04 -04:00
|
|
|
const auto iter = std::find_if(process_list.begin(), process_list.end(), predicate);
|
|
|
|
|
|
|
|
if (iter == process_list.end()) {
|
|
|
|
return std::nullopt;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *iter;
|
|
|
|
}
|
|
|
|
|
2019-06-26 19:07:34 -04:00
|
|
|
void GetApplicationPidGeneric(Kernel::HLERequestContext& ctx,
|
2021-04-24 01:04:28 -04:00
|
|
|
const std::vector<Kernel::KProcess*>& process_list) {
|
2021-05-16 01:46:30 -04:00
|
|
|
const auto process = SearchProcessList(process_list, [](const auto& proc) {
|
|
|
|
return proc->GetProcessID() == Kernel::KProcess::ProcessIDMin;
|
2019-06-26 19:07:34 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
2021-05-21 01:05:04 -04:00
|
|
|
rb.Push(ResultSuccess);
|
2019-06-26 19:07:34 -04:00
|
|
|
rb.Push(process.has_value() ? (*process)->GetProcessID() : NO_PROCESS_FOUND_PID);
|
|
|
|
}
|
|
|
|
|
2019-06-26 19:05:04 -04:00
|
|
|
} // Anonymous namespace
|
|
|
|
|
2018-07-25 16:37:00 -04:00
|
|
|
class BootMode final : public ServiceFramework<BootMode> {
|
|
|
|
public:
|
2020-11-26 15:19:08 -05:00
|
|
|
explicit BootMode(Core::System& system_) : ServiceFramework{system_, "pm:bm"} {
|
2018-07-25 16:37:00 -04:00
|
|
|
static const FunctionInfo functions[] = {
|
2018-08-23 18:31:45 -04:00
|
|
|
{0, &BootMode::GetBootMode, "GetBootMode"},
|
2019-01-28 11:48:08 -05:00
|
|
|
{1, &BootMode::SetMaintenanceBoot, "SetMaintenanceBoot"},
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2018-08-23 18:31:45 -04:00
|
|
|
|
|
|
|
private:
|
|
|
|
void GetBootMode(Kernel::HLERequestContext& ctx) {
|
2018-11-26 01:06:13 -05:00
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
|
2018-08-23 18:31:45 -04:00
|
|
|
IPC::ResponseBuilder rb{ctx, 3};
|
2021-05-21 01:05:04 -04:00
|
|
|
rb.Push(ResultSuccess);
|
2019-01-28 11:44:35 -05:00
|
|
|
rb.PushEnum(boot_mode);
|
2018-08-23 18:31:45 -04:00
|
|
|
}
|
2019-01-28 11:44:35 -05:00
|
|
|
|
2019-01-28 11:48:08 -05:00
|
|
|
void SetMaintenanceBoot(Kernel::HLERequestContext& ctx) {
|
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
|
|
|
|
boot_mode = SystemBootMode::Maintenance;
|
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2021-05-21 01:05:04 -04:00
|
|
|
rb.Push(ResultSuccess);
|
2019-01-28 11:48:08 -05:00
|
|
|
}
|
|
|
|
|
2019-01-28 11:44:35 -05:00
|
|
|
SystemBootMode boot_mode = SystemBootMode::Normal;
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
class DebugMonitor final : public ServiceFramework<DebugMonitor> {
|
|
|
|
public:
|
2020-11-26 15:19:08 -05:00
|
|
|
explicit DebugMonitor(Core::System& system_)
|
|
|
|
: ServiceFramework{system_, "pm:dmnt"}, kernel{system_.Kernel()} {
|
2019-04-10 14:48:37 -04:00
|
|
|
// clang-format off
|
2018-07-25 16:37:00 -04:00
|
|
|
static const FunctionInfo functions[] = {
|
2020-06-28 22:01:34 -04:00
|
|
|
{0, nullptr, "GetJitDebugProcessIdList"},
|
|
|
|
{1, nullptr, "StartProcess"},
|
|
|
|
{2, &DebugMonitor::GetProcessId, "GetProcessId"},
|
|
|
|
{3, nullptr, "HookToCreateProcess"},
|
|
|
|
{4, &DebugMonitor::GetApplicationProcessId, "GetApplicationProcessId"},
|
|
|
|
{5, nullptr, "HookToCreateApplicationProgress"},
|
|
|
|
{6, nullptr, "ClearHook"},
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
2019-04-10 14:48:37 -04:00
|
|
|
// clang-format on
|
|
|
|
|
2018-07-25 16:37:00 -04:00
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2019-06-26 19:06:51 -04:00
|
|
|
|
|
|
|
private:
|
2020-06-28 22:01:34 -04:00
|
|
|
void GetProcessId(Kernel::HLERequestContext& ctx) {
|
2019-06-26 19:06:51 -04:00
|
|
|
IPC::RequestParser rp{ctx};
|
2021-11-20 19:39:26 -05:00
|
|
|
const auto program_id = rp.PopRaw<u64>();
|
2019-06-26 19:06:51 -04:00
|
|
|
|
2021-11-20 19:39:26 -05:00
|
|
|
LOG_DEBUG(Service_PM, "called, program_id={:016X}", program_id);
|
2019-06-26 19:06:51 -04:00
|
|
|
|
|
|
|
const auto process =
|
2021-11-20 19:39:26 -05:00
|
|
|
SearchProcessList(kernel.GetProcessList(), [program_id](const auto& proc) {
|
|
|
|
return proc->GetProgramID() == program_id;
|
2019-06-26 19:06:51 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
if (!process.has_value()) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2021-11-20 19:42:30 -05:00
|
|
|
rb.Push(ResultProcessNotFound);
|
2019-06-26 19:06:51 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
2021-05-21 01:05:04 -04:00
|
|
|
rb.Push(ResultSuccess);
|
2019-06-26 19:06:51 -04:00
|
|
|
rb.Push((*process)->GetProcessID());
|
|
|
|
}
|
|
|
|
|
2020-06-28 22:01:34 -04:00
|
|
|
void GetApplicationProcessId(Kernel::HLERequestContext& ctx) {
|
2019-06-26 19:07:34 -04:00
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
GetApplicationPidGeneric(ctx, kernel.GetProcessList());
|
|
|
|
}
|
|
|
|
|
2019-06-26 19:06:51 -04:00
|
|
|
const Kernel::KernelCore& kernel;
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
class Info final : public ServiceFramework<Info> {
|
|
|
|
public:
|
2021-04-24 01:04:28 -04:00
|
|
|
explicit Info(Core::System& system_, const std::vector<Kernel::KProcess*>& process_list_)
|
2020-11-26 15:19:08 -05:00
|
|
|
: ServiceFramework{system_, "pm:info"}, process_list{process_list_} {
|
2018-07-25 16:37:00 -04:00
|
|
|
static const FunctionInfo functions[] = {
|
2021-11-20 19:39:26 -05:00
|
|
|
{0, &Info::GetProgramId, "GetProgramId"},
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2019-06-26 19:05:04 -04:00
|
|
|
|
|
|
|
private:
|
2021-11-20 19:39:26 -05:00
|
|
|
void GetProgramId(Kernel::HLERequestContext& ctx) {
|
2019-06-26 19:05:04 -04:00
|
|
|
IPC::RequestParser rp{ctx};
|
|
|
|
const auto process_id = rp.PopRaw<u64>();
|
|
|
|
|
|
|
|
LOG_DEBUG(Service_PM, "called, process_id={:016X}", process_id);
|
|
|
|
|
2021-05-16 01:46:30 -04:00
|
|
|
const auto process = SearchProcessList(process_list, [process_id](const auto& proc) {
|
|
|
|
return proc->GetProcessID() == process_id;
|
2019-06-26 19:05:04 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
if (!process.has_value()) {
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
2021-11-20 19:42:30 -05:00
|
|
|
rb.Push(ResultProcessNotFound);
|
2019-06-26 19:05:04 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 4};
|
2021-05-21 01:05:04 -04:00
|
|
|
rb.Push(ResultSuccess);
|
2021-11-03 14:15:51 -04:00
|
|
|
rb.Push((*process)->GetProgramID());
|
2019-06-26 19:05:04 -04:00
|
|
|
}
|
|
|
|
|
2021-04-24 01:04:28 -04:00
|
|
|
const std::vector<Kernel::KProcess*>& process_list;
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
class Shell final : public ServiceFramework<Shell> {
|
|
|
|
public:
|
2020-11-26 15:19:08 -05:00
|
|
|
explicit Shell(Core::System& system_)
|
|
|
|
: ServiceFramework{system_, "pm:shell"}, kernel{system_.Kernel()} {
|
2019-04-10 14:48:37 -04:00
|
|
|
// clang-format off
|
2018-07-25 16:37:00 -04:00
|
|
|
static const FunctionInfo functions[] = {
|
2020-06-28 22:01:34 -04:00
|
|
|
{0, nullptr, "LaunchProgram"},
|
|
|
|
{1, nullptr, "TerminateProcess"},
|
|
|
|
{2, nullptr, "TerminateProgram"},
|
|
|
|
{3, nullptr, "GetProcessEventHandle"},
|
|
|
|
{4, nullptr, "GetProcessEventInfo"},
|
2018-07-25 16:37:00 -04:00
|
|
|
{5, nullptr, "NotifyBootFinished"},
|
2020-06-28 22:01:34 -04:00
|
|
|
{6, &Shell::GetApplicationProcessIdForShell, "GetApplicationProcessIdForShell"},
|
2018-07-25 16:37:00 -04:00
|
|
|
{7, nullptr, "BoostSystemMemoryResourceLimit"},
|
2020-06-28 22:01:34 -04:00
|
|
|
{8, nullptr, "BoostApplicationThreadResourceLimit"},
|
2019-11-12 08:54:58 -05:00
|
|
|
{9, nullptr, "GetBootFinishedEventHandle"},
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
2019-04-10 14:48:37 -04:00
|
|
|
// clang-format on
|
|
|
|
|
2018-07-25 16:37:00 -04:00
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2019-06-26 19:07:34 -04:00
|
|
|
|
|
|
|
private:
|
2020-06-28 22:01:34 -04:00
|
|
|
void GetApplicationProcessIdForShell(Kernel::HLERequestContext& ctx) {
|
2019-06-26 19:07:34 -04:00
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
GetApplicationPidGeneric(ctx, kernel.GetProcessList());
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::KernelCore& kernel;
|
2018-07-25 16:37:00 -04:00
|
|
|
};
|
|
|
|
|
2019-06-26 19:06:51 -04:00
|
|
|
void InstallInterfaces(Core::System& system) {
|
2020-11-26 15:19:08 -05:00
|
|
|
std::make_shared<BootMode>(system)->InstallAsService(system.ServiceManager());
|
|
|
|
std::make_shared<DebugMonitor>(system)->InstallAsService(system.ServiceManager());
|
|
|
|
std::make_shared<Info>(system, system.Kernel().GetProcessList())
|
2019-06-26 19:06:51 -04:00
|
|
|
->InstallAsService(system.ServiceManager());
|
2020-11-26 15:19:08 -05:00
|
|
|
std::make_shared<Shell>(system)->InstallAsService(system.ServiceManager());
|
2018-07-25 16:37:00 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Service::PM
|