nold/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere synced 2024-09-19 22:59:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

PM: Refactor for R_TRY, remove gotos

Browse source
This commit is contained in:
Michael Scire 2019-06-17 15:27:29 -07:00
parent c60ee15449
commit ee40dcd76f
15 changed files with 126 additions and 165 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
stratosphere/libstratosphere

@ -1 +1 @@
Subproject commit b5f1ec02b30a3bbf8a8419f8b0cf3646071ebd2b
Subproject commit 777984476ea7b1da56c9a3fd3f55575a8b899896

2
stratosphere/pm/source/pm_boot2.hpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
class EmbeddedBoot2 {

2
stratosphere/pm/source/pm_boot_mode.cpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <switch.h>
#include <stratosphere.hpp>
#include "pm_boot_mode.hpp"

4
stratosphere/pm/source/pm_boot_mode.hpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <switch.h>
#include <stratosphere.hpp>
@ -23,7 +23,7 @@ enum BootModeCmd {
BootMode_Cmd_SetMaintenanceBoot = 1
};
class BootModeService final : public IServiceObject {
class BootModeService final : public IServiceObject {
private:
/* Actual commands. */
void GetBootMode(Out<u32> out);

18
stratosphere/pm/source/pm_debug_monitor.cpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <switch.h>
#include <stratosphere.hpp>
#include "pm_registration.hpp"
@ -43,7 +43,7 @@ Result DebugMonitorService::LaunchDebugProcess(u64 pid) {
Result DebugMonitorService::GetTitleProcessId(Out<u64> pid, u64 tid) {
std::scoped_lock<ProcessList &> lk(Registration::GetProcessList());
std::shared_ptr<Registration::Process> proc = Registration::GetProcessByTitleId(tid);
if (proc != nullptr) {
pid.SetValue(proc->pid);
@ -58,7 +58,7 @@ Result DebugMonitorService::EnableDebugForTitleId(Out<CopiedHandle> event, u64 t
Result DebugMonitorService::GetApplicationProcessId(Out<u64> pid) {
std::scoped_lock<ProcessList &> lk(Registration::GetProcessList());
std::shared_ptr<Registration::Process> app_proc;
if (Registration::HasApplicationProcess(&app_proc)) {
pid.SetValue(app_proc->pid);
@ -87,22 +87,14 @@ Result DebugMonitorService::AtmosphereGetProcessInfo(Out<CopiedHandle> proc_hand
}
Result DebugMonitorService::AtmosphereGetCurrentLimitInfo(Out<u64> cur_val, Out<u64> lim_val, u32 category, u32 resource) {
Result rc;
if(category > ResourceLimitUtils::ResourceLimitCategory::ResourceLimitCategory_Applet) {
return ResultKernelInvalidEnumValue;
}
Handle limit_h = ResourceLimitUtils::GetResourceLimitHandleByCategory((ResourceLimitUtils::ResourceLimitCategory) category);
rc = svcGetResourceLimitCurrentValue(cur_val.GetPointer(), limit_h, (LimitableResource) resource);
if(R_FAILED(rc)) {
return rc;
}
rc = svcGetResourceLimitLimitValue(lim_val.GetPointer(), limit_h, (LimitableResource) resource);
if(R_FAILED(rc)) {
return rc;
}
R_TRY(svcGetResourceLimitCurrentValue(cur_val.GetPointer(), limit_h, (LimitableResource) resource));
R_TRY(svcGetResourceLimitLimitValue(lim_val.GetPointer(), limit_h, (LimitableResource) resource));
return ResultSuccess;
}

12
stratosphere/pm/source/pm_debug_monitor.hpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <switch.h>
#include <stratosphere.hpp>
@ -28,14 +28,14 @@ enum DmntCmd {
Dmnt_Cmd_EnableDebugForTitleId = 4,
Dmnt_Cmd_GetApplicationProcessId = 5,
Dmnt_Cmd_EnableDebugForApplication = 6,
Dmnt_Cmd_5X_GetDebugProcessIds = 0,
Dmnt_Cmd_5X_LaunchDebugProcess = 1,
Dmnt_Cmd_5X_GetTitleProcessId = 2,
Dmnt_Cmd_5X_EnableDebugForTitleId = 3,
Dmnt_Cmd_5X_GetApplicationProcessId = 4,
Dmnt_Cmd_5X_EnableDebugForApplication = 5,
Dmnt_Cmd_6X_DisableDebug = 6,
Dmnt_Cmd_AtmosphereGetProcessInfo = 65000,
@ -67,7 +67,7 @@ class DebugMonitorService final : public IServiceObject {
MakeServiceCommandMeta<Dmnt_Cmd_EnableDebugForTitleId, &DebugMonitorService::EnableDebugForTitleId, FirmwareVersion_Min, FirmwareVersion_400>(),
MakeServiceCommandMeta<Dmnt_Cmd_GetApplicationProcessId, &DebugMonitorService::GetApplicationProcessId, FirmwareVersion_Min, FirmwareVersion_400>(),
MakeServiceCommandMeta<Dmnt_Cmd_EnableDebugForApplication, &DebugMonitorService::EnableDebugForApplication, FirmwareVersion_Min, FirmwareVersion_400>(),
/* 5.0.0-* */
MakeServiceCommandMeta<Dmnt_Cmd_5X_GetDebugProcessIds, &DebugMonitorService::GetDebugProcessIds, FirmwareVersion_500>(),
MakeServiceCommandMeta<Dmnt_Cmd_5X_LaunchDebugProcess, &DebugMonitorService::LaunchDebugProcess, FirmwareVersion_500>(),
@ -75,10 +75,10 @@ class DebugMonitorService final : public IServiceObject {
MakeServiceCommandMeta<Dmnt_Cmd_5X_EnableDebugForTitleId, &DebugMonitorService::EnableDebugForTitleId, FirmwareVersion_500>(),
MakeServiceCommandMeta<Dmnt_Cmd_5X_GetApplicationProcessId, &DebugMonitorService::GetApplicationProcessId, FirmwareVersion_500>(),
MakeServiceCommandMeta<Dmnt_Cmd_5X_EnableDebugForApplication, &DebugMonitorService::EnableDebugForApplication, FirmwareVersion_500>(),
/* 6.0.0-* */
MakeServiceCommandMeta<Dmnt_Cmd_6X_DisableDebug, &DebugMonitorService::DisableDebug, FirmwareVersion_600>(),
/* Atmosphere extensions. */
MakeServiceCommandMeta<Dmnt_Cmd_AtmosphereGetProcessInfo, &DebugMonitorService::AtmosphereGetProcessInfo>(),
MakeServiceCommandMeta<Dmnt_Cmd_AtmosphereGetCurrentLimitInfo, &DebugMonitorService::AtmosphereGetCurrentLimitInfo>(),

4
stratosphere/pm/source/pm_info.cpp
View file

@ -13,14 +13,14 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <switch.h>
#include "pm_registration.hpp"
#include "pm_info.hpp"
Result InformationService::GetTitleId(Out<u64> tid, u64 pid) {
std::scoped_lock<ProcessList &> lk(Registration::GetProcessList());
std::shared_ptr<Registration::Process> proc = Registration::GetProcess(pid);
if (proc != NULL) {
tid.SetValue(proc->tid_sid.title_id);

2
stratosphere/pm/source/pm_info.hpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <switch.h>
#include <stratosphere.hpp>

2
stratosphere/pm/source/pm_main.cpp
View file

@ -178,7 +178,7 @@ int main(int argc, char **argv)
s_server_manager.AddWaitable(new ServiceServer<DebugMonitorService>("pm:dmnt", 3));
s_server_manager.AddWaitable(new ServiceServer<BootModeService>("pm:bm", 6));
s_server_manager.AddWaitable(new ServiceServer<InformationService>("pm:info", 3));
/* Loop forever, servicing our services. */
s_server_manager.Process();

2
stratosphere/pm/source/pm_process_track.hpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <switch.h>

24
stratosphere/pm/source/pm_process_wait.hpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <mutex>
#include <switch.h>
@ -23,27 +23,27 @@
class ProcessWaiter final : public IWaitable {
public:
std::shared_ptr<Registration::Process> process;
ProcessWaiter(std::shared_ptr<Registration::Process> p) : process(p) {
/* ... */
}
std::shared_ptr<Registration::Process> GetProcess() {
return this->process;
std::shared_ptr<Registration::Process> GetProcess() {
return this->process;
}
/* IWaitable */
/* IWaitable */
Handle GetHandle() override {
return this->process->handle;
}
Result HandleSignaled(u64 timeout) override {
return Registration::HandleSignaledProcess(this->GetProcess());
}
};
class ProcessList final {
private:
private:
HosRecursiveMutex m;
HosRecursiveMutex *GetMutex() {
@ -51,15 +51,15 @@ class ProcessList final {
}
public:
std::vector<std::shared_ptr<Registration::Process>> processes;
void lock() {
GetMutex()->lock();
}
void unlock() {
GetMutex()->unlock();
}
void try_lock() {
GetMutex()->try_lock();
}

132
stratosphere/pm/source/pm_registration.cpp
View file

@ -24,7 +24,7 @@ static ProcessList g_process_list;
static ProcessList g_dead_process_list;
static IEvent *g_process_launch_start_event = nullptr;
static HosSemaphore g_sema_finish_launch;
static HosSignal g_finish_launch_signal;
static HosMutex g_process_launch_mutex;
static Registration::ProcessLaunchState g_process_launch_state;
@ -37,8 +37,6 @@ static IEvent *g_debug_title_event = nullptr;
static IEvent *g_debug_application_event = nullptr;
static IEvent *g_boot_finished_event = nullptr;
static u8 g_ac_buf[4 * sizeof(LoaderProgramInfo)];
ProcessList &Registration::GetProcessList() {
return g_process_list;
}
@ -65,31 +63,29 @@ IWaitable *Registration::GetProcessLaunchStartEvent() {
return g_process_launch_start_event;
}
void Registration::HandleProcessLaunch() {
Result Registration::LaunchProcess(u64 *out_pid, const TidSid tid_sid, const u64 launch_flags) {
LoaderProgramInfo program_info = {0};
Result rc;
u64 launch_flags = g_process_launch_state.launch_flags;
u64 *out_pid = g_process_launch_state.out_pid;
Process new_process = {0};
new_process.tid_sid = g_process_launch_state.tid_sid;
std::memset(g_ac_buf, 0xCC, sizeof(g_ac_buf));
u8 *acid_sac = g_ac_buf, *aci0_sac = acid_sac + sizeof(LoaderProgramInfo), *fac = aci0_sac + sizeof(LoaderProgramInfo), *fah = fac + sizeof(LoaderProgramInfo);
new_process.tid_sid = tid_sid;
/* Clear, get accessors for access controls. */
static u8 s_ac_buf[4 * sizeof(LoaderProgramInfo)];
std::memset(s_ac_buf, 0xCC, sizeof(s_ac_buf));
u8 *acid_sac = s_ac_buf, *aci0_sac = acid_sac + sizeof(LoaderProgramInfo), *fac = aci0_sac + sizeof(LoaderProgramInfo), *fah = fac + sizeof(LoaderProgramInfo);
/* Check that this is a real program. */
if (R_FAILED((rc = ldrPmGetProgramInfo(new_process.tid_sid.title_id, new_process.tid_sid.storage_id, &program_info)))) {
goto HANDLE_PROCESS_LAUNCH_END;
}
R_TRY(ldrPmGetProgramInfo(new_process.tid_sid.title_id, new_process.tid_sid.storage_id, &program_info));
/* Get the resource limit handle, ensure that we can launch the program. */
if ((program_info.application_type & 3) == 1 && HasApplicationProcess(NULL)) {
rc = ResultPmApplicationRunning;
goto HANDLE_PROCESS_LAUNCH_END;
if ((program_info.application_type & 3) == 1 && HasApplicationProcess()) {
return ResultPmApplicationRunning;
}
/* Try to register the title for launch in loader... */
if (R_FAILED((rc = ldrPmRegisterTitle(new_process.tid_sid.title_id, new_process.tid_sid.storage_id, &new_process.ldr_queue_index)))) {
goto HANDLE_PROCESS_LAUNCH_END;
}
R_TRY(ldrPmRegisterTitle(new_process.tid_sid.title_id, new_process.tid_sid.storage_id, &new_process.ldr_queue_index));
auto ldr_register_guard = SCOPE_GUARD {
ldrPmUnregisterTitle(new_process.ldr_queue_index);
};
/* Make sure the previous application is cleaned up. */
if ((program_info.application_type & 3) == 1) {
@ -97,26 +93,32 @@ void Registration::HandleProcessLaunch() {
}
/* Try to create the process... */
if (R_FAILED((rc = ldrPmCreateProcess(LAUNCHFLAGS_ARGLOW(launch_flags) | LAUNCHFLAGS_ARGHIGH(launch_flags), new_process.ldr_queue_index, ResourceLimitUtils::GetResourceLimitHandle(program_info.application_type), &new_process.handle)))) {
goto PROCESS_CREATION_FAILED;
}
R_TRY(ldrPmCreateProcess(LAUNCHFLAGS_ARGLOW(launch_flags) | LAUNCHFLAGS_ARGHIGH(launch_flags), new_process.ldr_queue_index, ResourceLimitUtils::GetResourceLimitHandle(program_info.application_type), &new_process.handle));
auto proc_create_guard = SCOPE_GUARD {
svcCloseHandle(new_process.handle);
new_process.handle = 0;
};
/* Get the new process's id. */
svcGetProcessId(&new_process.pid, new_process.handle);
if (R_FAILED(svcGetProcessId(&new_process.pid, new_process.handle))) {
std::abort();
}
/* Register with FS. */
memcpy(fac, program_info.ac_buffer + program_info.acid_sac_size + program_info.aci0_sac_size, program_info.acid_fac_size);
memcpy(fah, program_info.ac_buffer + program_info.acid_sac_size + program_info.aci0_sac_size + program_info.acid_fac_size, program_info.aci0_fah_size);
if (R_FAILED((rc = fsprRegisterProgram(new_process.pid, new_process.tid_sid.title_id, new_process.tid_sid.storage_id, fah, program_info.aci0_fah_size, fac, program_info.acid_fac_size)))) {
goto FS_REGISTRATION_FAILED;
}
R_TRY(fsprRegisterProgram(new_process.pid, new_process.tid_sid.title_id, new_process.tid_sid.storage_id, fah, program_info.aci0_fah_size, fac, program_info.acid_fac_size));
auto fs_register_guard = SCOPE_GUARD {
fsprUnregisterProgram(new_process.pid);
};
/* Register with SM. */
memcpy(acid_sac, program_info.ac_buffer, program_info.acid_sac_size);
memcpy(aci0_sac, program_info.ac_buffer + program_info.acid_sac_size, program_info.aci0_sac_size);
if (R_FAILED((rc = smManagerRegisterProcess(new_process.pid, acid_sac, program_info.acid_sac_size, aci0_sac, program_info.aci0_sac_size)))) {
goto SM_REGISTRATION_FAILED;
}
R_TRY(smManagerRegisterProcess(new_process.pid, acid_sac, program_info.acid_sac_size, aci0_sac, program_info.aci0_sac_size));
auto sm_register_guard = SCOPE_GUARD {
smManagerUnregisterProcess(new_process.pid);
};
/* Setup process flags. */
if (program_info.application_type & 1) {
@ -134,61 +136,46 @@ void Registration::HandleProcessLaunch() {
/* Add process to the list. */
Registration::AddProcessToList(std::make_shared<Registration::Process>(new_process));
auto reg_list_guard = SCOPE_GUARD {
Registration::RemoveProcessFromList(new_process.pid);
};
/* Signal, if relevant. */
if (new_process.tid_sid.title_id == g_debug_on_launch_tid.load()) {
g_debug_title_event->Signal();
g_debug_on_launch_tid = 0;
rc = ResultSuccess;
} else if ((new_process.flags & PROCESSFLAGS_APPLICATION) && g_debug_next_application.load()) {
g_debug_application_event->Signal();
g_debug_next_application = false;
rc = ResultSuccess;
} else if (LAUNCHFLAGS_STARTSUSPENDED(launch_flags)) {
rc = ResultSuccess;
} else {
rc = svcStartProcess(new_process.handle, program_info.main_thread_priority, program_info.default_cpu_id, program_info.main_thread_stack_size);
if (R_SUCCEEDED(rc)) {
SetProcessState(new_process.pid, ProcessState_Running);
}
} else if (!(LAUNCHFLAGS_STARTSUSPENDED(launch_flags))) {
R_TRY(svcStartProcess(new_process.handle, program_info.main_thread_priority, program_info.default_cpu_id, program_info.main_thread_stack_size));
SetProcessState(new_process.pid, ProcessState_Running);
}
if (R_FAILED(rc)) {
Registration::RemoveProcessFromList(new_process.pid);
smManagerUnregisterProcess(new_process.pid);
}
/* Dismiss scope guards. */
reg_list_guard.Cancel();
sm_register_guard.Cancel();
fs_register_guard.Cancel();
proc_create_guard.Cancel();
ldr_register_guard.Cancel();
SM_REGISTRATION_FAILED:
if (R_FAILED(rc)) {
fsprUnregisterProgram(new_process.pid);
}
/* Set output pid. */
*out_pid = new_process.pid;
FS_REGISTRATION_FAILED:
if (R_FAILED(rc)) {
svcCloseHandle(new_process.handle);
new_process.handle = 0;
}
return ResultSuccess;
}
PROCESS_CREATION_FAILED:
if (R_FAILED(rc)) {
ldrPmUnregisterTitle(new_process.ldr_queue_index);
}
HANDLE_PROCESS_LAUNCH_END:
g_process_launch_state.result = rc;
if (R_SUCCEEDED(rc)) {
*out_pid = new_process.pid;
}
g_sema_finish_launch.Signal();
void Registration::HandleProcessLaunch() {
/* Actually launch process. */
g_process_launch_state.result = LaunchProcess(g_process_launch_state.out_pid, g_process_launch_state.tid_sid, g_process_launch_state.launch_flags);
/* Signal to waiting thread. */
g_finish_launch_signal.Signal();
}
Result Registration::LaunchDebugProcess(u64 pid) {
std::scoped_lock<ProcessList &> lk(GetProcessList());
LoaderProgramInfo program_info = {0};
Result rc;
std::shared_ptr<Registration::Process> proc = GetProcess(pid);
if (proc == NULL) {
@ -200,15 +187,13 @@ Result Registration::LaunchDebugProcess(u64 pid) {
}
/* Check that this is a real program. */
if (R_FAILED((rc = ldrPmGetProgramInfo(proc->tid_sid.title_id, proc->tid_sid.storage_id, &program_info)))) {
return rc;
}
R_TRY(ldrPmGetProgramInfo(proc->tid_sid.title_id, proc->tid_sid.storage_id, &program_info));
if (R_SUCCEEDED((rc = svcStartProcess(proc->handle, program_info.main_thread_priority, program_info.default_cpu_id, program_info.main_thread_stack_size)))) {
proc->state = ProcessState_Running;
}
/* Actually start the process. */
R_TRY(svcStartProcess(proc->handle, program_info.main_thread_priority, program_info.default_cpu_id, program_info.main_thread_stack_size));
return rc;
proc->state = ProcessState_Running;
return ResultSuccess;
}
Result Registration::LaunchProcess(u64 title_id, FsStorageId storage_id, u64 launch_flags, u64 *out_pid) {
@ -220,8 +205,9 @@ Result Registration::LaunchProcess(u64 title_id, FsStorageId storage_id, u64 lau
g_process_launch_state.out_pid = out_pid;
/* Start a launch, and wait for it to exit. */
g_finish_launch_signal.Reset();
g_process_launch_start_event->Signal();
g_sema_finish_launch.Wait();
g_finish_launch_signal.Wait();
return g_process_launch_state.result;
}

7
stratosphere/pm/source/pm_registration.hpp
View file

@ -170,7 +170,10 @@ class Registration {
u64* out_pid;
Result result;
};
private:
static Result LaunchProcess(u64 *out_pid, const TidSid tid_sid, const u64 launch_flags);
public:
/* TODO: Better evaluate public vs private API. */
static void InitializeSystemResources();
static IWaitable *GetProcessLaunchStartEvent();
static ProcessList &GetProcessList();
@ -203,7 +206,7 @@ class Registration {
static void SignalBootFinished();
static bool HasApplicationProcess(std::shared_ptr<Process> *out);
static bool HasApplicationProcess(std::shared_ptr<Process> *out = nullptr);
};
#include "pm_process_wait.hpp"

76
stratosphere/pm/source/pm_resource_limits.cpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <switch.h>
#include <stratosphere.hpp>
@ -81,27 +81,24 @@ static u64 g_system_boost_size = 0;
/* Tries to set Resource limits for a category. */
static Result SetResourceLimits(ResourceLimitUtils::ResourceLimitCategory category, u64 new_memory_size) {
Result rc = ResultSuccess;
u64 old_memory_size = g_resource_limits[category][LimitableResource_Memory];
g_resource_limits[category][LimitableResource_Memory] = new_memory_size;
for (unsigned int r = 0; r < 5; r++) {
if (R_FAILED((rc = svcSetResourceLimitLimitValue(g_resource_limit_handles[category], (LimitableResource)r, g_resource_limits[category][r])))) {
R_TRY_CLEANUP(svcSetResourceLimitLimitValue(g_resource_limit_handles[category], (LimitableResource)r, g_resource_limits[category][r]), {
g_resource_limits[category][LimitableResource_Memory] = old_memory_size;
return rc;
}
});
}
return rc;
return ResultSuccess;
}
static Result SetNewMemoryResourceLimit(ResourceLimitUtils::ResourceLimitCategory category, u64 new_memory_size) {
Result rc = ResultSuccess;
u64 old_memory_size = g_resource_limits[category][LimitableResource_Memory];
g_resource_limits[category][LimitableResource_Memory] = new_memory_size;
if (R_FAILED((rc = svcSetResourceLimitLimitValue(g_resource_limit_handles[category], LimitableResource_Memory, g_resource_limits[category][LimitableResource_Memory])))) {
R_TRY_CLEANUP(svcSetResourceLimitLimitValue(g_resource_limit_handles[category], LimitableResource_Memory, g_resource_limits[category][LimitableResource_Memory]), {
g_resource_limits[category][LimitableResource_Memory] = old_memory_size;
}
return rc;
});
return ResultSuccess;
}
void ResourceLimitUtils::InitializeLimits() {
@ -133,39 +130,39 @@ void ResourceLimitUtils::InitializeLimits() {
memcpy(&g_memory_resource_limits, &g_memory_resource_limits_deprecated, sizeof(g_memory_resource_limits_deprecated));
memcpy(&g_resource_limits, &g_resource_limits_deprecated, sizeof(g_resource_limits));
}
/* 7.0.0+: Nintendo restricts the number of system threads here, from 0x260 -> 0x60. */
/* We will not do this. */
if (GetRuntimeFirmwareVersion() >= FirmwareVersion_600) {
/* NOTE: 5 is a fake type, official code does not do this. */
/* This is done for ease of backwards compatibility. */
g_memory_limit_type = 5;
/* Starting 6.x, 5 MB of memory is always reserved for system. */
const u64 reserved_system_size_6x = 0x500000;
/* Get total memory available. */
u64 total_memory = 0;
if (R_FAILED(svcGetResourceLimitLimitValue(&total_memory, g_resource_limit_handles[0], LimitableResource_Memory))) {
std::abort();
}
/* Get and save application + applet memory. */
if (R_FAILED(svcGetSystemInfo(&g_memory_resource_limits[g_memory_limit_type][1], 0, 0, 0)) ||
R_FAILED(svcGetSystemInfo(&g_memory_resource_limits[g_memory_limit_type][2], 0, 0, 1))) {
std::abort();
}
const u64 application_size = g_memory_resource_limits[g_memory_limit_type][1];
const u64 applet_size = g_memory_resource_limits[g_memory_limit_type][2];
const u64 reserved_nonsys_size = (application_size + applet_size + reserved_system_size_6x);
/* Ensure there's enough memory for system region. */
if (reserved_nonsys_size > total_memory) {
std::abort();
}
/* Set System memory. */
g_memory_resource_limits[g_memory_limit_type][0] = total_memory - (reserved_nonsys_size);
} else {
@ -249,49 +246,32 @@ Handle ResourceLimitUtils::GetResourceLimitHandleByCategory(ResourceLimitCategor
}
Result ResourceLimitUtils::BoostSystemMemoryResourceLimit(u64 boost_size) {
Result rc = ResultSuccess;
if (boost_size > g_memory_resource_limits[g_memory_limit_type][ResourceLimitCategory_Application]) {
return ResultPmInvalidSize;
}
u64 app_size = g_memory_resource_limits[g_memory_limit_type][ResourceLimitCategory_Application] - boost_size;
if (GetRuntimeFirmwareVersion() >= FirmwareVersion_500) {
if (boost_size < g_system_boost_size) {
if (R_FAILED((rc = svcSetUnsafeLimit(boost_size)))) {
return rc;
}
if (R_FAILED((rc = SetNewMemoryResourceLimit(ResourceLimitCategory_Application, app_size)))) {
return rc;
}
R_TRY(svcSetUnsafeLimit(boost_size));
R_TRY(SetNewMemoryResourceLimit(ResourceLimitCategory_Application, app_size));
} else {
if (R_FAILED((rc = SetNewMemoryResourceLimit(ResourceLimitCategory_Application, app_size)))) {
return rc;
}
if (R_FAILED((rc = svcSetUnsafeLimit(boost_size)))) {
return rc;
}
R_TRY(SetNewMemoryResourceLimit(ResourceLimitCategory_Application, app_size));
R_TRY(svcSetUnsafeLimit(boost_size));
}
} else if (GetRuntimeFirmwareVersion() >= FirmwareVersion_400) {
u64 sys_size = g_memory_resource_limits[g_memory_limit_type][ResourceLimitCategory_System] + boost_size;
if (boost_size < g_system_boost_size) {
if (R_FAILED((rc = SetResourceLimits(ResourceLimitCategory_System, sys_size)))) {
return rc;
}
if (R_FAILED((rc = SetResourceLimits(ResourceLimitCategory_Application, app_size)))) {
return rc;
}
R_TRY(SetResourceLimits(ResourceLimitCategory_System, sys_size));
R_TRY(SetResourceLimits(ResourceLimitCategory_Application, app_size));
} else {
if (R_FAILED((rc = SetResourceLimits(ResourceLimitCategory_Application, app_size)))) {
return rc;
}
if (R_FAILED((rc = SetResourceLimits(ResourceLimitCategory_System, sys_size)))) {
return rc;
}
R_TRY(SetResourceLimits(ResourceLimitCategory_Application, app_size));
R_TRY(SetResourceLimits(ResourceLimitCategory_System, sys_size));
}
} else {
rc = ResultKernelConnectionClosed;
return ResultKernelConnectionClosed;
}
if (R_SUCCEEDED(rc)) {
g_system_boost_size = boost_size;
}
return rc;
g_system_boost_size = boost_size;
return ResultSuccess;
}

2
stratosphere/pm/source/pm_resource_limits.hpp
View file

@ -13,7 +13,7 @@
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <switch.h>
#include <stratosphere.hpp>