2018-07-25 22:37:00 +02:00
|
|
|
// Copyright 2018 yuzu emulator team
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2020-11-08 21:49:45 +01:00
|
|
|
#include "core/core.h"
|
2018-08-24 00:31:45 +02:00
|
|
|
#include "core/hle/ipc_helpers.h"
|
2019-06-27 01:06:51 +02:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
|
|
|
#include "core/hle/kernel/process.h"
|
2018-08-24 00:31:45 +02:00
|
|
|
#include "core/hle/service/pm/pm.h"
|
2018-07-25 22:37:00 +02:00
|
|
|
#include "core/hle/service/service.h"
|
|
|
|
|
|
|
|
namespace Service::PM {
|
|
|
|
|
2019-06-27 01:05:04 +02:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
constexpr ResultCode ERROR_PROCESS_NOT_FOUND{ErrorModule::PM, 1};
|
|
|
|
|
|
|
|
constexpr u64 NO_PROCESS_FOUND_PID{0};
|
|
|
|
|
2021-04-04 07:22:36 +02:00
|
|
|
std::optional<Kernel::Process*> SearchProcessList(const std::vector<Kernel::Process*>& process_list,
|
|
|
|
std::function<bool(Kernel::Process*)> predicate) {
|
2019-06-27 01:05:04 +02: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-27 01:07:34 +02:00
|
|
|
void GetApplicationPidGeneric(Kernel::HLERequestContext& ctx,
|
2021-04-04 07:22:36 +02:00
|
|
|
const std::vector<Kernel::Process*>& process_list) {
|
2019-06-27 01:07:34 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2019-06-27 01:05:04 +02:00
|
|
|
} // Anonymous namespace
|
|
|
|
|
2018-07-25 22:37:00 +02:00
|
|
|
class BootMode final : public ServiceFramework<BootMode> {
|
|
|
|
public:
|
2020-11-26 21:19:08 +01:00
|
|
|
explicit BootMode(Core::System& system_) : ServiceFramework{system_, "pm:bm"} {
|
2018-07-25 22:37:00 +02:00
|
|
|
static const FunctionInfo functions[] = {
|
2018-08-24 00:31:45 +02:00
|
|
|
{0, &BootMode::GetBootMode, "GetBootMode"},
|
2019-01-28 17:48:08 +01:00
|
|
|
{1, &BootMode::SetMaintenanceBoot, "SetMaintenanceBoot"},
|
2018-07-25 22:37:00 +02:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2018-08-24 00:31:45 +02:00
|
|
|
|
|
|
|
private:
|
|
|
|
void GetBootMode(Kernel::HLERequestContext& ctx) {
|
2018-11-26 07:06:13 +01:00
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
|
2018-08-24 00:31:45 +02:00
|
|
|
IPC::ResponseBuilder rb{ctx, 3};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
2019-01-28 17:44:35 +01:00
|
|
|
rb.PushEnum(boot_mode);
|
2018-08-24 00:31:45 +02:00
|
|
|
}
|
2019-01-28 17:44:35 +01:00
|
|
|
|
2019-01-28 17:48:08 +01:00
|
|
|
void SetMaintenanceBoot(Kernel::HLERequestContext& ctx) {
|
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
|
|
|
|
boot_mode = SystemBootMode::Maintenance;
|
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{ctx, 2};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
}
|
|
|
|
|
2019-01-28 17:44:35 +01:00
|
|
|
SystemBootMode boot_mode = SystemBootMode::Normal;
|
2018-07-25 22:37:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
class DebugMonitor final : public ServiceFramework<DebugMonitor> {
|
|
|
|
public:
|
2020-11-26 21:19:08 +01:00
|
|
|
explicit DebugMonitor(Core::System& system_)
|
|
|
|
: ServiceFramework{system_, "pm:dmnt"}, kernel{system_.Kernel()} {
|
2019-04-10 20:48:37 +02:00
|
|
|
// clang-format off
|
2018-07-25 22:37:00 +02:00
|
|
|
static const FunctionInfo functions[] = {
|
2020-06-29 04:01:34 +02: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 22:37:00 +02:00
|
|
|
};
|
2019-04-10 20:48:37 +02:00
|
|
|
// clang-format on
|
|
|
|
|
2018-07-25 22:37:00 +02:00
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2019-06-27 01:06:51 +02:00
|
|
|
|
|
|
|
private:
|
2020-06-29 04:01:34 +02:00
|
|
|
void GetProcessId(Kernel::HLERequestContext& ctx) {
|
2019-06-27 01:06:51 +02:00
|
|
|
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());
|
|
|
|
}
|
|
|
|
|
2020-06-29 04:01:34 +02:00
|
|
|
void GetApplicationProcessId(Kernel::HLERequestContext& ctx) {
|
2019-06-27 01:07:34 +02:00
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
GetApplicationPidGeneric(ctx, kernel.GetProcessList());
|
|
|
|
}
|
|
|
|
|
2019-06-27 01:06:51 +02:00
|
|
|
const Kernel::KernelCore& kernel;
|
2018-07-25 22:37:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
class Info final : public ServiceFramework<Info> {
|
|
|
|
public:
|
2021-04-04 07:22:36 +02:00
|
|
|
explicit Info(Core::System& system_, const std::vector<Kernel::Process*>& process_list_)
|
2020-11-26 21:19:08 +01:00
|
|
|
: ServiceFramework{system_, "pm:info"}, process_list{process_list_} {
|
2018-07-25 22:37:00 +02:00
|
|
|
static const FunctionInfo functions[] = {
|
2019-06-27 01:05:04 +02:00
|
|
|
{0, &Info::GetTitleId, "GetTitleId"},
|
2018-07-25 22:37:00 +02:00
|
|
|
};
|
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2019-06-27 01:05:04 +02:00
|
|
|
|
|
|
|
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());
|
|
|
|
}
|
|
|
|
|
2021-04-04 07:22:36 +02:00
|
|
|
const std::vector<Kernel::Process*>& process_list;
|
2018-07-25 22:37:00 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
class Shell final : public ServiceFramework<Shell> {
|
|
|
|
public:
|
2020-11-26 21:19:08 +01:00
|
|
|
explicit Shell(Core::System& system_)
|
|
|
|
: ServiceFramework{system_, "pm:shell"}, kernel{system_.Kernel()} {
|
2019-04-10 20:48:37 +02:00
|
|
|
// clang-format off
|
2018-07-25 22:37:00 +02:00
|
|
|
static const FunctionInfo functions[] = {
|
2020-06-29 04:01:34 +02:00
|
|
|
{0, nullptr, "LaunchProgram"},
|
|
|
|
{1, nullptr, "TerminateProcess"},
|
|
|
|
{2, nullptr, "TerminateProgram"},
|
|
|
|
{3, nullptr, "GetProcessEventHandle"},
|
|
|
|
{4, nullptr, "GetProcessEventInfo"},
|
2018-07-25 22:37:00 +02:00
|
|
|
{5, nullptr, "NotifyBootFinished"},
|
2020-06-29 04:01:34 +02:00
|
|
|
{6, &Shell::GetApplicationProcessIdForShell, "GetApplicationProcessIdForShell"},
|
2018-07-25 22:37:00 +02:00
|
|
|
{7, nullptr, "BoostSystemMemoryResourceLimit"},
|
2020-06-29 04:01:34 +02:00
|
|
|
{8, nullptr, "BoostApplicationThreadResourceLimit"},
|
2019-11-12 14:54:58 +01:00
|
|
|
{9, nullptr, "GetBootFinishedEventHandle"},
|
2018-07-25 22:37:00 +02:00
|
|
|
};
|
2019-04-10 20:48:37 +02:00
|
|
|
// clang-format on
|
|
|
|
|
2018-07-25 22:37:00 +02:00
|
|
|
RegisterHandlers(functions);
|
|
|
|
}
|
2019-06-27 01:07:34 +02:00
|
|
|
|
|
|
|
private:
|
2020-06-29 04:01:34 +02:00
|
|
|
void GetApplicationProcessIdForShell(Kernel::HLERequestContext& ctx) {
|
2019-06-27 01:07:34 +02:00
|
|
|
LOG_DEBUG(Service_PM, "called");
|
|
|
|
GetApplicationPidGeneric(ctx, kernel.GetProcessList());
|
|
|
|
}
|
|
|
|
|
|
|
|
const Kernel::KernelCore& kernel;
|
2018-07-25 22:37:00 +02:00
|
|
|
};
|
|
|
|
|
2019-06-27 01:06:51 +02:00
|
|
|
void InstallInterfaces(Core::System& system) {
|
2020-11-26 21:19:08 +01: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-27 01:06:51 +02:00
|
|
|
->InstallAsService(system.ServiceManager());
|
2020-11-26 21:19:08 +01:00
|
|
|
std::make_shared<Shell>(system)->InstallAsService(system.ServiceManager());
|
2018-07-25 22:37:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Service::PM
|