From 7fc1e86bf5c23d24ca4ba1419d78f328bd923800 Mon Sep 17 00:00:00 2001 From: Michael Scire Date: Sun, 29 Mar 2020 15:24:40 -0700 Subject: [PATCH] stratosphere: fix building with latest libnx --- .../include/vapours/results/pm_results.hpp | 2 +- .../creport/source/creport_threads.cpp | 6 +- stratosphere/fatal/source/fatal_debug.cpp | 6 +- .../pm/source/impl/pm_process_info.cpp | 2 +- .../pm/source/impl/pm_process_info.hpp | 12 +- .../pm/source/impl/pm_process_manager.cpp | 50 +++---- .../pm/source/impl/pm_process_manager.hpp | 2 +- .../pm/source/impl/pm_resource_manager.cpp | 127 +++++++++--------- .../pm/source/impl/pm_resource_manager.hpp | 2 +- .../pm/source/pm_debug_monitor_service.cpp | 2 +- .../pm/source/pm_debug_monitor_service.hpp | 2 +- stratosphere/pm/source/pm_main.cpp | 6 +- 12 files changed, 109 insertions(+), 110 deletions(-) diff --git a/libraries/libvapours/include/vapours/results/pm_results.hpp b/libraries/libvapours/include/vapours/results/pm_results.hpp index 46d06c27a..84d7dfc1b 100644 --- a/libraries/libvapours/include/vapours/results/pm_results.hpp +++ b/libraries/libvapours/include/vapours/results/pm_results.hpp @@ -23,7 +23,7 @@ namespace ams::pm { R_DEFINE_ERROR_RESULT(ProcessNotFound, 1); R_DEFINE_ERROR_RESULT(AlreadyStarted, 2); - R_DEFINE_ERROR_RESULT(NotExited, 3); + R_DEFINE_ERROR_RESULT(NotTerminated, 3); R_DEFINE_ERROR_RESULT(DebugHookInUse, 4); R_DEFINE_ERROR_RESULT(ApplicationRunning, 5); R_DEFINE_ERROR_RESULT(InvalidSize, 6); diff --git a/stratosphere/creport/source/creport_threads.cpp b/stratosphere/creport/source/creport_threads.cpp index e8da71a6e..175c2d49b 100644 --- a/stratosphere/creport/source/creport_threads.cpp +++ b/stratosphere/creport/source/creport_threads.cpp @@ -246,17 +246,17 @@ namespace ams::creport { this->thread_count = 0; /* Get thread list. */ - u32 num_threads; + s32 num_threads; u64 thread_ids[ThreadCountMax]; { - if (R_FAILED(svcGetThreadList(&num_threads, thread_ids, ThreadCountMax, debug_handle))) { + if (R_FAILED(svc::GetThreadList(&num_threads, thread_ids, ThreadCountMax, debug_handle))) { return; } num_threads = std::min(size_t(num_threads), ThreadCountMax); } /* Parse thread infos. */ - for (size_t i = 0; i < num_threads; i++) { + for (s32 i = 0; i < num_threads; i++) { if (this->threads[this->thread_count].ReadFromProcess(debug_handle, tls_map, thread_ids[i], is_64_bit)) { this->thread_count++; } diff --git a/stratosphere/fatal/source/fatal_debug.cpp b/stratosphere/fatal/source/fatal_debug.cpp index 85435ddd9..60007e35e 100644 --- a/stratosphere/fatal/source/fatal_debug.cpp +++ b/stratosphere/fatal/source/fatal_debug.cpp @@ -213,14 +213,14 @@ namespace ams::fatal::srv { ThreadContext thread_ctx; { /* We start by trying to get a list of threads. */ - u32 thread_count; + s32 thread_count; u64 thread_ids[0x60]; - if (R_FAILED(svcGetThreadList(&thread_count, thread_ids, 0x60, debug_handle.Get()))) { + if (R_FAILED(svc::GetThreadList(&thread_count, thread_ids, 0x60, debug_handle.Get()))) { return; } /* We need to locate the thread that's called fatal. */ - for (u32 i = 0; i < thread_count; i++) { + for (s32 i = 0; i < thread_count; i++) { const u64 cur_thread_id = thread_ids[i]; if (thread_id_to_tls.find(cur_thread_id) == thread_id_to_tls.end()) { continue; diff --git a/stratosphere/pm/source/impl/pm_process_info.cpp b/stratosphere/pm/source/impl/pm_process_info.cpp index 44c526322..564b3cfac 100644 --- a/stratosphere/pm/source/impl/pm_process_info.cpp +++ b/stratosphere/pm/source/impl/pm_process_info.cpp @@ -17,7 +17,7 @@ namespace ams::pm::impl { - ProcessInfo::ProcessInfo(Handle h, os::ProcessId pid, ldr::PinId pin, const ncm::ProgramLocation &l, const cfg::OverrideStatus &s) : process_id(pid), pin_id(pin), loc(l), status(s), handle(h), state(ProcessState_Created), flags(0), waitable_holder(h) { + ProcessInfo::ProcessInfo(Handle h, os::ProcessId pid, ldr::PinId pin, const ncm::ProgramLocation &l, const cfg::OverrideStatus &s) : process_id(pid), pin_id(pin), loc(l), status(s), handle(h), state(svc::ProcessState_Created), flags(0), waitable_holder(h) { this->waitable_holder.SetUserData(reinterpret_cast(this)); } diff --git a/stratosphere/pm/source/impl/pm_process_info.hpp b/stratosphere/pm/source/impl/pm_process_info.hpp index 1eb8865b4..bcdbd2139 100644 --- a/stratosphere/pm/source/impl/pm_process_info.hpp +++ b/stratosphere/pm/source/impl/pm_process_info.hpp @@ -43,7 +43,7 @@ namespace ams::pm::impl { const ncm::ProgramLocation loc; const cfg::OverrideStatus status; Handle handle; - ProcessState state; + svc::ProcessState state; u32 flags; os::WaitableHolder waitable_holder; private: @@ -87,20 +87,20 @@ namespace ams::pm::impl { return this->status; } - ProcessState GetState() const { + svc::ProcessState GetState() const { return this->state; } - void SetState(ProcessState state) { + void SetState(svc::ProcessState state) { this->state = state; } bool HasStarted() const { - return this->state != ProcessState_Created && this->state != ProcessState_CreatedAttached; + return this->state != svc::ProcessState_Created && this->state != svc::ProcessState_CreatedAttached; } - bool HasExited() const { - return this->state == ProcessState_Exited; + bool HasTerminated() const { + return this->state == svc::ProcessState_Terminated; } #define DEFINE_FLAG_SET(flag) \ diff --git a/stratosphere/pm/source/impl/pm_process_manager.cpp b/stratosphere/pm/source/impl/pm_process_manager.cpp index de092f277..0a7f7e397 100644 --- a/stratosphere/pm/source/impl/pm_process_manager.cpp +++ b/stratosphere/pm/source/impl/pm_process_manager.cpp @@ -97,7 +97,7 @@ namespace ams::pm::impl { Started = 2, Exception = 3, DebugRunning = 4, - DebugSuspended = 5, + DebugBreak = 5, }; enum class ProcessEventDeprecated { @@ -105,7 +105,7 @@ namespace ams::pm::impl { Exception = 1, Exited = 2, DebugRunning = 3, - DebugSuspended = 4, + DebugBreak = 4, Started = 5, }; @@ -124,8 +124,8 @@ namespace ams::pm::impl { return static_cast(ProcessEventDeprecated::Exception); case ProcessEvent::DebugRunning: return static_cast(ProcessEventDeprecated::DebugRunning); - case ProcessEvent::DebugSuspended: - return static_cast(ProcessEventDeprecated::DebugSuspended); + case ProcessEvent::DebugBreak: + return static_cast(ProcessEventDeprecated::DebugBreak); AMS_UNREACHABLE_DEFAULT_CASE(); } } @@ -263,7 +263,7 @@ namespace ams::pm::impl { Result StartProcess(ProcessInfo *process_info, const ldr::ProgramInfo *program_info) { R_TRY(svcStartProcess(process_info->GetHandle(), program_info->main_thread_priority, program_info->default_cpu_id, program_info->main_thread_stack_size)); - process_info->SetState(ProcessState_Running); + process_info->SetState(svc::ProcessState_Running); return ResultSuccess(); } @@ -372,25 +372,25 @@ namespace ams::pm::impl { svcResetSignal(process_info->GetHandle()); /* Update the process's state. */ - const ProcessState old_state = process_info->GetState(); + const svc::ProcessState old_state = process_info->GetState(); { - u64 tmp = 0; - R_ABORT_UNLESS(svcGetProcessInfo(&tmp, process_info->GetHandle(), ProcessInfoType_ProcessState)); - process_info->SetState(static_cast(tmp)); + s64 tmp = 0; + R_ABORT_UNLESS(svc::GetProcessInfo(&tmp, process_info->GetHandle(), svc::ProcessInfoType_ProcessState)); + process_info->SetState(static_cast(tmp)); } - const ProcessState new_state = process_info->GetState(); + const svc::ProcessState new_state = process_info->GetState(); /* If we're transitioning away from crashed, clear waiting attached. */ - if (old_state == ProcessState_Crashed && new_state != ProcessState_Crashed) { + if (old_state == svc::ProcessState_Crashed && new_state != svc::ProcessState_Crashed) { process_info->ClearExceptionWaitingAttach(); } switch (new_state) { - case ProcessState_Created: - case ProcessState_CreatedAttached: - case ProcessState_Exiting: + case svc::ProcessState_Created: + case svc::ProcessState_CreatedAttached: + case svc::ProcessState_Terminating: break; - case ProcessState_Running: + case svc::ProcessState_Running: if (process_info->ShouldSignalOnDebugEvent()) { process_info->ClearSuspended(); process_info->SetSuspendedStateChanged(); @@ -401,18 +401,18 @@ namespace ams::pm::impl { g_process_event.Signal(); } break; - case ProcessState_Crashed: + case svc::ProcessState_Crashed: process_info->SetExceptionOccurred(); g_process_event.Signal(); break; - case ProcessState_RunningAttached: + case svc::ProcessState_RunningAttached: if (process_info->ShouldSignalOnDebugEvent()) { process_info->ClearSuspended(); process_info->SetSuspendedStateChanged(); g_process_event.Signal(); } break; - case ProcessState_Exited: + case svc::ProcessState_Terminated: /* Free process resources, unlink from waitable manager. */ process_info->Cleanup(); @@ -438,7 +438,7 @@ namespace ams::pm::impl { } } break; - case ProcessState_DebugSuspended: + case svc::ProcessState_DebugBreak: if (process_info->ShouldSignalOnDebugEvent()) { process_info->SetSuspended(); process_info->SetSuspendedStateChanged(); @@ -535,7 +535,7 @@ namespace ams::pm::impl { if (process.HasSuspendedStateChanged()) { process.ClearSuspendedStateChanged(); if (process.IsSuspended()) { - out->event = GetProcessEventValue(ProcessEvent::DebugSuspended); + out->event = GetProcessEventValue(ProcessEvent::DebugBreak); } else { out->event = GetProcessEventValue(ProcessEvent::DebugRunning); } @@ -548,7 +548,7 @@ namespace ams::pm::impl { out->process_id = process.GetProcessId(); return ResultSuccess(); } - if (hos::GetVersion() < hos::Version_500 && process.ShouldSignalOnExit() && process.HasExited()) { + if (hos::GetVersion() < hos::Version_500 && process.ShouldSignalOnExit() && process.HasTerminated()) { out->event = GetProcessEventValue(ProcessEvent::Exited); out->process_id = process.GetProcessId(); return ResultSuccess(); @@ -579,8 +579,8 @@ namespace ams::pm::impl { ProcessListAccessor list(g_process_list); auto process_info = list->Find(process_id); - R_UNLESS(process_info != nullptr, pm::ResultProcessNotFound()); - R_UNLESS(process_info->HasExited(), pm::ResultNotExited()); + R_UNLESS(process_info != nullptr, pm::ResultProcessNotFound()); + R_UNLESS(process_info->HasTerminated(), pm::ResultNotTerminated()); CleanupProcessInfo(list, process_info); return ResultSuccess(); @@ -725,8 +725,8 @@ namespace ams::pm::impl { return resource::BoostApplicationThreadResourceLimit(); } - Result AtmosphereGetCurrentLimitInfo(u64 *out_cur_val, u64 *out_lim_val, u32 group, u32 resource) { - return resource::GetResourceLimitValues(out_cur_val, out_lim_val, static_cast(group), static_cast(resource)); + Result AtmosphereGetCurrentLimitInfo(s64 *out_cur_val, s64 *out_lim_val, u32 group, u32 resource) { + return resource::GetResourceLimitValues(out_cur_val, out_lim_val, static_cast(group), static_cast(resource)); } } diff --git a/stratosphere/pm/source/impl/pm_process_manager.hpp b/stratosphere/pm/source/impl/pm_process_manager.hpp index ab80175b7..72b64e24a 100644 --- a/stratosphere/pm/source/impl/pm_process_manager.hpp +++ b/stratosphere/pm/source/impl/pm_process_manager.hpp @@ -51,6 +51,6 @@ namespace ams::pm::impl { /* Resource Limit API. */ Result BoostSystemMemoryResourceLimit(u64 boost_size); Result BoostApplicationThreadResourceLimit(); - Result AtmosphereGetCurrentLimitInfo(u64 *out_cur_val, u64 *out_lim_val, u32 group, u32 resource); + Result AtmosphereGetCurrentLimitInfo(s64 *out_cur_val, s64 *out_lim_val, u32 group, u32 resource); } diff --git a/stratosphere/pm/source/impl/pm_resource_manager.cpp b/stratosphere/pm/source/impl/pm_resource_manager.cpp index cfff9bbc9..9e7413c29 100644 --- a/stratosphere/pm/source/impl/pm_resource_manager.cpp +++ b/stratosphere/pm/source/impl/pm_resource_manager.cpp @@ -19,14 +19,13 @@ namespace ams::pm::resource { namespace { - constexpr LimitableResource LimitableResources[] = { - LimitableResource_Memory, - LimitableResource_Threads, - LimitableResource_Events, - LimitableResource_TransferMemories, - LimitableResource_Sessions, + constexpr svc::LimitableResource LimitableResources[] = { + svc::LimitableResource_PhysicalMemoryMax, + svc::LimitableResource_ThreadCountMax, + svc::LimitableResource_EventCountMax, + svc::LimitableResource_TransferMemoryCountMax, + svc::LimitableResource_SessionCountMax, }; - constexpr size_t LimitableResource_Count = util::size(LimitableResources); /* Definitions for limit differences over time. */ constexpr size_t ExtraSystemThreadCount400 = 100; @@ -48,27 +47,27 @@ namespace ams::pm::resource { u64 g_system_memory_boost_size = 0; u64 g_extra_application_threads_available = 0; - u64 g_resource_limits[ResourceLimitGroup_Count][LimitableResource_Count] = { + u64 g_resource_limits[ResourceLimitGroup_Count][svc::LimitableResource_Count] = { [ResourceLimitGroup_System] = { - [LimitableResource_Memory] = 0, /* Initialized by more complicated logic later. */ - [LimitableResource_Threads] = 508, - [LimitableResource_Events] = 600, - [LimitableResource_TransferMemories] = 128, - [LimitableResource_Sessions] = 794, + [svc::LimitableResource_PhysicalMemoryMax] = 0, /* Initialized by more complicated logic later. */ + [svc::LimitableResource_ThreadCountMax] = 508, + [svc::LimitableResource_EventCountMax] = 600, + [svc::LimitableResource_TransferMemoryCountMax] = 128, + [svc::LimitableResource_SessionCountMax] = 794, }, [ResourceLimitGroup_Application] = { - [LimitableResource_Memory] = 0, /* Initialized by more complicated logic later. */ - [LimitableResource_Threads] = 96, - [LimitableResource_Events] = 0, - [LimitableResource_TransferMemories] = 32, - [LimitableResource_Sessions] = 1, + [svc::LimitableResource_PhysicalMemoryMax] = 0, /* Initialized by more complicated logic later. */ + [svc::LimitableResource_ThreadCountMax] = 96, + [svc::LimitableResource_EventCountMax] = 0, + [svc::LimitableResource_TransferMemoryCountMax] = 32, + [svc::LimitableResource_SessionCountMax] = 1, }, [ResourceLimitGroup_Applet] = { - [LimitableResource_Memory] = 0, /* Initialized by more complicated logic later. */ - [LimitableResource_Threads] = 96, - [LimitableResource_Events] = 0, - [LimitableResource_TransferMemories] = 32, - [LimitableResource_Sessions] = 5, + [svc::LimitableResource_PhysicalMemoryMax] = 0, /* Initialized by more complicated logic later. */ + [svc::LimitableResource_ThreadCountMax] = 96, + [svc::LimitableResource_EventCountMax] = 0, + [svc::LimitableResource_TransferMemoryCountMax] = 32, + [svc::LimitableResource_SessionCountMax] = 5, }, }; @@ -102,13 +101,13 @@ namespace ams::pm::resource { /* Helpers. */ Result SetMemoryResourceLimitLimitValue(ResourceLimitGroup group, u64 new_memory_limit) { - const u64 old_memory_limit = g_resource_limits[group][LimitableResource_Memory]; - g_resource_limits[group][LimitableResource_Memory] = new_memory_limit; + const u64 old_memory_limit = g_resource_limits[group][svc::LimitableResource_PhysicalMemoryMax]; + g_resource_limits[group][svc::LimitableResource_PhysicalMemoryMax] = new_memory_limit; { /* If we fail, restore the old memory limit. */ - auto limit_guard = SCOPE_GUARD { g_resource_limits[group][LimitableResource_Memory] = old_memory_limit; }; - R_TRY(svcSetResourceLimitLimitValue(GetResourceLimitHandle(group), LimitableResource_Memory, g_resource_limits[group][LimitableResource_Memory])); + auto limit_guard = SCOPE_GUARD { g_resource_limits[group][svc::LimitableResource_PhysicalMemoryMax] = old_memory_limit; }; + R_TRY(svc::SetResourceLimitLimitValue(GetResourceLimitHandle(group), svc::LimitableResource_PhysicalMemoryMax, g_resource_limits[group][svc::LimitableResource_PhysicalMemoryMax])); limit_guard.Cancel(); } @@ -120,12 +119,12 @@ namespace ams::pm::resource { R_TRY(SetMemoryResourceLimitLimitValue(group, new_memory_limit)); /* Set other limit values. */ - for (size_t i = 0; i < LimitableResource_Count; i++) { + for (size_t i = 0; i < svc::LimitableResource_Count; i++) { const auto resource = LimitableResources[i]; - if (resource == LimitableResource_Memory) { + if (resource == svc::LimitableResource_PhysicalMemoryMax) { continue; } - R_TRY(svcSetResourceLimitLimitValue(GetResourceLimitHandle(group), resource, g_resource_limits[group][resource])); + R_TRY(svc::SetResourceLimitLimitValue(GetResourceLimitHandle(group), resource, g_resource_limits[group][resource])); } return ResultSuccess(); } @@ -143,16 +142,16 @@ namespace ams::pm::resource { void WaitResourceAvailable(ResourceLimitGroup group) { const Handle reslimit_hnd = GetResourceLimitHandle(group); - for (size_t i = 0; i < LimitableResource_Count; i++) { + for (size_t i = 0; i < svc::LimitableResource_Count; i++) { const auto resource = LimitableResources[i]; - u64 value = 0; + s64 value = 0; while (true) { - R_ABORT_UNLESS(svcGetResourceLimitCurrentValue(&value, reslimit_hnd, resource)); + R_ABORT_UNLESS(svc::GetResourceLimitCurrentValue(&value, reslimit_hnd, resource)); if (value == 0) { break; } - svcSleepThread(1'000'000ul); + svc::SleepThread(1'000'000ul); } } } @@ -160,11 +159,11 @@ namespace ams::pm::resource { void WaitApplicationMemoryAvailable() { u64 value = 0; while (true) { - R_ABORT_UNLESS(svcGetSystemInfo(&value, SystemInfoType_UsedPhysicalMemorySize, INVALID_HANDLE, PhysicalMemoryInfo_Application)); + R_ABORT_UNLESS(svc::GetSystemInfo(&value, svc::SystemInfoType_UsedPhysicalMemorySize, INVALID_HANDLE, svc::PhysicalMemorySystemInfo_Application)); if (value == 0) { break; } - svcSleepThread(1'000'000ul); + svc::SleepThread(1'000'000ul); } } @@ -176,10 +175,10 @@ namespace ams::pm::resource { for (size_t i = 0; i < ResourceLimitGroup_Count; i++) { if (i == ResourceLimitGroup_System) { u64 value = 0; - R_ABORT_UNLESS(svcGetInfo(&value, InfoType_ResourceLimit, INVALID_HANDLE, 0)); - g_resource_limit_handles[i] = static_cast(value); + R_ABORT_UNLESS(svc::GetInfo(&value, svc::InfoType_ResourceLimit, svc::InvalidHandle, 0)); + g_resource_limit_handles[i] = static_cast(value); } else { - R_ABORT_UNLESS(svcCreateResourceLimit(&g_resource_limit_handles[i])); + R_ABORT_UNLESS(svc::CreateResourceLimit(&g_resource_limit_handles[i])); } } @@ -187,7 +186,7 @@ namespace ams::pm::resource { const auto hos_version = hos::GetVersion(); if (hos_version >= hos::Version_400) { /* 4.0.0 increased the system thread limit. */ - g_resource_limits[ResourceLimitGroup_System][LimitableResource_Threads] += ExtraSystemThreadCount400; + g_resource_limits[ResourceLimitGroup_System][svc::LimitableResource_ThreadCountMax] += ExtraSystemThreadCount400; /* 4.0.0 also took memory away from applet and gave it to system, for the Standard and StandardForSystemDev profiles. */ g_memory_resource_limits[spl::MemoryArrangement_Standard][ResourceLimitGroup_System] += ExtraSystemMemorySize400; g_memory_resource_limits[spl::MemoryArrangement_Standard][ResourceLimitGroup_Applet] -= ExtraSystemMemorySize400; @@ -203,26 +202,26 @@ namespace ams::pm::resource { } if (hos_version >= hos::Version_600) { /* 6.0.0 increased the system event and session limits. */ - g_resource_limits[ResourceLimitGroup_System][LimitableResource_Events] += ExtraSystemEventCount600; - g_resource_limits[ResourceLimitGroup_System][LimitableResource_Sessions] += ExtraSystemSessionCount600; + g_resource_limits[ResourceLimitGroup_System][svc::LimitableResource_EventCountMax] += ExtraSystemEventCount600; + g_resource_limits[ResourceLimitGroup_System][svc::LimitableResource_SessionCountMax] += ExtraSystemSessionCount600; } if (hos_version >= hos::Version_900) { /* 9.2.0 increased the system session limit. */ /* NOTE: We don't currently support detection of minor version, so we will provide this increase on 9.0.0+. */ /* This shouldn't impact any existing behavior in undesirable ways. */ - g_resource_limits[ResourceLimitGroup_System][LimitableResource_Sessions] += ExtraSystemSessionCount920; + g_resource_limits[ResourceLimitGroup_System][svc::LimitableResource_SessionCountMax] += ExtraSystemSessionCount920; } /* 7.0.0+: Calculate the number of extra application threads available. */ if (hos::GetVersion() >= hos::Version_700) { /* See how many threads we have available. */ - u64 total_threads_available = 0; - R_ABORT_UNLESS(svcGetResourceLimitLimitValue(&total_threads_available, GetResourceLimitHandle(ResourceLimitGroup_System), LimitableResource_Threads)); + s64 total_threads_available = 0; + R_ABORT_UNLESS(svc::GetResourceLimitLimitValue(&total_threads_available, GetResourceLimitHandle(ResourceLimitGroup_System), svc::LimitableResource_ThreadCountMax)); /* See how many threads we're expecting. */ - const size_t total_threads_allocated = g_resource_limits[ResourceLimitGroup_System][LimitableResource_Threads] - - g_resource_limits[ResourceLimitGroup_Application][LimitableResource_Threads] - - g_resource_limits[ResourceLimitGroup_Applet][LimitableResource_Threads]; + const s64 total_threads_allocated = g_resource_limits[ResourceLimitGroup_System][svc::LimitableResource_ThreadCountMax] - + g_resource_limits[ResourceLimitGroup_Application][svc::LimitableResource_ThreadCountMax] - + g_resource_limits[ResourceLimitGroup_Applet][svc::LimitableResource_ThreadCountMax]; /* Ensure we don't over-commit threads. */ AMS_ABORT_UNLESS(total_threads_allocated <= total_threads_available); @@ -237,16 +236,16 @@ namespace ams::pm::resource { g_memory_arrangement = spl::MemoryArrangement_Dynamic; /* Get total memory available. */ - u64 total_memory = 0; - R_ABORT_UNLESS(svcGetResourceLimitLimitValue(&total_memory, GetResourceLimitHandle(ResourceLimitGroup_System), LimitableResource_Memory)); + s64 total_memory = 0; + R_ABORT_UNLESS(svc::GetResourceLimitLimitValue(&total_memory, GetResourceLimitHandle(ResourceLimitGroup_System), svc::LimitableResource_PhysicalMemoryMax)); /* Get and save application + applet memory. */ - R_ABORT_UNLESS(svcGetSystemInfo(&g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Application], SystemInfoType_TotalPhysicalMemorySize, INVALID_HANDLE, PhysicalMemoryInfo_Application)); - R_ABORT_UNLESS(svcGetSystemInfo(&g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Applet], SystemInfoType_TotalPhysicalMemorySize, INVALID_HANDLE, PhysicalMemoryInfo_Applet)); + R_ABORT_UNLESS(svc::GetSystemInfo(&g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Application], svc::SystemInfoType_TotalPhysicalMemorySize, svc::InvalidHandle, svc::PhysicalMemorySystemInfo_Application)); + R_ABORT_UNLESS(svc::GetSystemInfo(&g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Applet], svc::SystemInfoType_TotalPhysicalMemorySize, svc::InvalidHandle, svc::PhysicalMemorySystemInfo_Applet)); - const u64 application_size = g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Application]; - const u64 applet_size = g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Applet]; - const u64 reserved_non_system_size = (application_size + applet_size + ReservedMemorySize600); + const s64 application_size = g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Application]; + const s64 applet_size = g_memory_resource_limits[spl::MemoryArrangement_Dynamic][ResourceLimitGroup_Applet]; + const s64 reserved_non_system_size = (application_size + applet_size + ReservedMemorySize600); /* Ensure there's enough memory for the system region. */ AMS_ABORT_UNLESS(reserved_non_system_size < total_memory); @@ -292,11 +291,11 @@ namespace ams::pm::resource { if (hos::GetVersion() >= hos::Version_500) { /* Starting in 5.0.0, PM does not allow for only one of the sets to fail. */ if (boost_size < g_system_memory_boost_size) { - R_TRY(svcSetUnsafeLimit(boost_size)); + R_TRY(svc::SetUnsafeLimit(boost_size)); R_ABORT_UNLESS(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size)); } else { R_TRY(SetMemoryResourceLimitLimitValue(ResourceLimitGroup_Application, new_app_size)); - R_ABORT_UNLESS(svcSetUnsafeLimit(boost_size)); + R_ABORT_UNLESS(svc::SetUnsafeLimit(boost_size)); } } else { const u64 new_sys_size = g_memory_resource_limits[g_memory_arrangement][ResourceLimitGroup_System] + boost_size; @@ -318,11 +317,11 @@ namespace ams::pm::resource { Result BoostApplicationThreadResourceLimit() { std::scoped_lock lk(g_resource_limit_lock); /* Set new limit. */ - const u64 new_thread_count = g_resource_limits[ResourceLimitGroup_Application][LimitableResource_Threads] + g_extra_application_threads_available; - R_TRY(svcSetResourceLimitLimitValue(GetResourceLimitHandle(ResourceLimitGroup_Application), LimitableResource_Threads, new_thread_count)); + const s64 new_thread_count = g_resource_limits[ResourceLimitGroup_Application][svc::LimitableResource_ThreadCountMax] + g_extra_application_threads_available; + R_TRY(svc::SetResourceLimitLimitValue(GetResourceLimitHandle(ResourceLimitGroup_Application), svc::LimitableResource_ThreadCountMax, new_thread_count)); /* Record that we did so. */ - g_resource_limits[ResourceLimitGroup_Application][LimitableResource_Threads] = new_thread_count; + g_resource_limits[ResourceLimitGroup_Application][svc::LimitableResource_ThreadCountMax] = new_thread_count; g_extra_application_threads_available = 0; return ResultSuccess(); @@ -345,14 +344,14 @@ namespace ams::pm::resource { } } - Result GetResourceLimitValues(u64 *out_cur, u64 *out_lim, ResourceLimitGroup group, LimitableResource resource) { + Result GetResourceLimitValues(s64 *out_cur, s64 *out_lim, ResourceLimitGroup group, svc::LimitableResource resource) { /* Do not allow out of bounds access. */ AMS_ABORT_UNLESS(group < ResourceLimitGroup_Count); - AMS_ABORT_UNLESS(resource < LimitableResource_Count); + AMS_ABORT_UNLESS(resource < svc::LimitableResource_Count); const Handle reslimit_hnd = GetResourceLimitHandle(group); - R_TRY(svcGetResourceLimitCurrentValue(out_cur, reslimit_hnd, resource)); - R_TRY(svcGetResourceLimitLimitValue(out_lim, reslimit_hnd, resource)); + R_TRY(svc::GetResourceLimitCurrentValue(out_cur, reslimit_hnd, resource)); + R_TRY(svc::GetResourceLimitLimitValue(out_lim, reslimit_hnd, resource)); return ResultSuccess(); } diff --git a/stratosphere/pm/source/impl/pm_resource_manager.hpp b/stratosphere/pm/source/impl/pm_resource_manager.hpp index b25887f4c..ca51387d1 100644 --- a/stratosphere/pm/source/impl/pm_resource_manager.hpp +++ b/stratosphere/pm/source/impl/pm_resource_manager.hpp @@ -26,6 +26,6 @@ namespace ams::pm::resource { Handle GetResourceLimitHandle(const ldr::ProgramInfo *info); void WaitResourceAvailable(const ldr::ProgramInfo *info); - Result GetResourceLimitValues(u64 *out_cur, u64 *out_lim, ResourceLimitGroup group, LimitableResource resource); + Result GetResourceLimitValues(s64 *out_cur, s64 *out_lim, ResourceLimitGroup group, svc::LimitableResource resource); } diff --git a/stratosphere/pm/source/pm_debug_monitor_service.cpp b/stratosphere/pm/source/pm_debug_monitor_service.cpp index 439ddbcc9..4430fee73 100644 --- a/stratosphere/pm/source/pm_debug_monitor_service.cpp +++ b/stratosphere/pm/source/pm_debug_monitor_service.cpp @@ -58,7 +58,7 @@ namespace ams::pm::dmnt { return impl::AtmosphereGetProcessInfo(out_process_handle.GetHandlePointer(), out_loc.GetPointer(), out_status.GetPointer(), process_id); } - Result DebugMonitorServiceBase::AtmosphereGetCurrentLimitInfo(sf::Out out_cur_val, sf::Out out_lim_val, u32 group, u32 resource) { + Result DebugMonitorServiceBase::AtmosphereGetCurrentLimitInfo(sf::Out out_cur_val, sf::Out out_lim_val, u32 group, u32 resource) { return impl::AtmosphereGetCurrentLimitInfo(out_cur_val.GetPointer(), out_lim_val.GetPointer(), group, resource); } diff --git a/stratosphere/pm/source/pm_debug_monitor_service.hpp b/stratosphere/pm/source/pm_debug_monitor_service.hpp index 699fd16fa..636ab8c12 100644 --- a/stratosphere/pm/source/pm_debug_monitor_service.hpp +++ b/stratosphere/pm/source/pm_debug_monitor_service.hpp @@ -32,7 +32,7 @@ namespace ams::pm::dmnt { /* Atmosphere extension commands. */ virtual Result AtmosphereGetProcessInfo(sf::OutCopyHandle out_process_handle, sf::Out out_loc, sf::Out out_status, os::ProcessId process_id); - virtual Result AtmosphereGetCurrentLimitInfo(sf::Out out_cur_val, sf::Out out_lim_val, u32 group, u32 resource); + virtual Result AtmosphereGetCurrentLimitInfo(sf::Out out_cur_val, sf::Out out_lim_val, u32 group, u32 resource); }; /* This represents modern DebugMonitorService (5.0.0+). */ diff --git a/stratosphere/pm/source/pm_main.cpp b/stratosphere/pm/source/pm_main.cpp index b963dd883..460ad7002 100644 --- a/stratosphere/pm/source/pm_main.cpp +++ b/stratosphere/pm/source/pm_main.cpp @@ -115,10 +115,10 @@ namespace { cfg::GetInitialProcessRange(&min_priv_process_id, &max_priv_process_id); /* Get list of processes, register all privileged ones. */ - u32 num_pids; + s32 num_pids; os::ProcessId pids[ProcessCountMax]; - R_ABORT_UNLESS(svcGetProcessList(&num_pids, reinterpret_cast(pids), ProcessCountMax)); - for (size_t i = 0; i < num_pids; i++) { + R_ABORT_UNLESS(svc::GetProcessList(&num_pids, reinterpret_cast(pids), ProcessCountMax)); + for (s32 i = 0; i < num_pids; i++) { if (min_priv_process_id <= pids[i] && pids[i] <= max_priv_process_id) { RegisterPrivilegedProcess(pids[i]); }