From ec43f604e12e1dc304621d86300015120eb326af Mon Sep 17 00:00:00 2001 From: pineappleEA Date: Wed, 12 Jan 2022 07:07:47 +0100 Subject: [PATCH] early-access version 2389 --- CMakeLists.txt | 8 +- README.md | 2 +- externals/CMakeLists.txt | 4 - src/CMakeLists.txt | 5 +- src/core/hle/kernel/k_page_table.cpp | 103 ++++++++++++++------------ src/core/hle/kernel/k_page_table.h | 7 +- src/core/hle/kernel/k_process.cpp | 12 +-- src/core/hle/kernel/kernel.cpp | 31 ++++++-- src/core/hle/kernel/physical_core.cpp | 18 +++-- src/core/hle/kernel/svc.cpp | 8 +- src/core/hle/service/ldr/ldr.cpp | 38 +++++----- src/tests/CMakeLists.txt | 2 +- 12 files changed, 143 insertions(+), 95 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 47bd282fb..4bf55d664 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -35,6 +35,8 @@ option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF) option(YUZU_USE_BUNDLED_OPUS "Compile bundled opus" ON) +option(YUZU_TESTS "Compile tests" ON) + # Default to a Release build get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE) @@ -168,7 +170,6 @@ macro(yuzu_find_packages) # Capitalization matters here. We need the naming to match the generated paths from Conan set(REQUIRED_LIBS # Cmake Pkg Prefix Version Conan Pkg - "Catch2 2.13.7 catch2/2.13.7" "fmt 8.0.1 fmt/8.1.1" "lz4 1.8 lz4/1.9.2" "nlohmann_json 3.8 nlohmann_json/3.8.0" @@ -177,6 +178,11 @@ macro(yuzu_find_packages) # can't use opus until AVX check is fixed: https://github.com/yuzu-emu/yuzu/pull/4068 #"opus 1.3 opus/1.3.1" ) + if (YUZU_TESTS) + list(APPEND REQUIRED_LIBS + "Catch2 2.13.7 catch2/2.13.7" + ) + endif() foreach(PACKAGE ${REQUIRED_LIBS}) string(REGEX REPLACE "[ \t\r\n]+" ";" PACKAGE_SPLIT ${PACKAGE}) diff --git a/README.md b/README.md index 9a239cf1f..791a5ba8c 100755 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ yuzu emulator early access ============= -This is the source code for early-access 2388. +This is the source code for early-access 2389. ## Legal Notice diff --git a/externals/CMakeLists.txt b/externals/CMakeLists.txt index 158113516..82e8ef18c 100755 --- a/externals/CMakeLists.txt +++ b/externals/CMakeLists.txt @@ -13,10 +13,6 @@ if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64) target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES) endif() -# Catch -add_library(catch-single-include INTERFACE) -target_include_directories(catch-single-include INTERFACE catch/single_include) - # Dynarmic if (ARCHITECTURE_x86_64) set(DYNARMIC_TESTS OFF) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 7ed0ac5ab..19f7ba339 100755 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -153,7 +153,10 @@ add_subdirectory(audio_core) add_subdirectory(video_core) add_subdirectory(input_common) add_subdirectory(shader_recompiler) -add_subdirectory(tests) + +if (YUZU_TESTS) + add_subdirectory(tests) +endif() if (ENABLE_SDL2) add_subdirectory(yuzu_cmd) diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp index 6077985b5..27d86c9a4 100755 --- a/src/core/hle/kernel/k_page_table.cpp +++ b/src/core/hle/kernel/k_page_table.cpp @@ -298,7 +298,7 @@ ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemory return ResultSuccess; } -ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) { +ResultCode KPageTable::MapCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) { std::lock_guard lock{page_table_lock}; const std::size_t num_pages{size / PageSize}; @@ -307,7 +307,7 @@ ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std: KMemoryPermission perm{}; CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, nullptr, src_addr, size, KMemoryState::All, KMemoryState::Normal, KMemoryPermission::All, - KMemoryPermission::ReadAndWrite, KMemoryAttribute::Mask, + KMemoryPermission::UserReadWrite, KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); if (IsRegionMapped(dst_addr, size)) { @@ -335,7 +335,7 @@ ResultCode KPageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std: return ResultSuccess; } -ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) { +ResultCode KPageTable::UnmapCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) { std::lock_guard lock{page_table_lock}; if (!size) { @@ -361,7 +361,7 @@ ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, st block_manager->Update(dst_addr, num_pages, KMemoryState::Free); block_manager->Update(src_addr, num_pages, KMemoryState::Normal, - KMemoryPermission::ReadAndWrite); + KMemoryPermission::UserReadWrite); system.InvalidateCpuInstructionCacheRange(dst_addr, size); @@ -416,7 +416,7 @@ void KPageTable::MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr star } const std::size_t num_pages{std::min(src_num_pages, dst_num_pages)}; - Operate(dst_addr, num_pages, KMemoryPermission::ReadAndWrite, OperationType::Map, + Operate(dst_addr, num_pages, KMemoryPermission::UserReadWrite, OperationType::Map, map_addr); dst_addr += num_pages * PageSize; @@ -470,7 +470,7 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) { const std::size_t num_pages{size / PageSize}; block_manager->Update(addr, num_pages, KMemoryState::Free, KMemoryPermission::None, KMemoryAttribute::None, KMemoryState::Normal, - KMemoryPermission::ReadAndWrite, KMemoryAttribute::None); + KMemoryPermission::UserReadWrite, KMemoryAttribute::None); return ResultSuccess; } @@ -554,7 +554,7 @@ ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) { KMemoryState src_state{}; CASCADE_CODE(CheckMemoryState( &src_state, nullptr, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias, - KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::ReadAndWrite, + KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::UserReadWrite, KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); if (IsRegionMapped(dst_addr, size)) { @@ -568,13 +568,13 @@ ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) { { auto block_guard = detail::ScopeExit([&] { - Operate(src_addr, num_pages, KMemoryPermission::ReadAndWrite, + Operate(src_addr, num_pages, KMemoryPermission::UserReadWrite, OperationType::ChangePermissions); }); CASCADE_CODE(Operate(src_addr, num_pages, KMemoryPermission::None, OperationType::ChangePermissions)); - CASCADE_CODE(MapPages(dst_addr, page_linked_list, KMemoryPermission::ReadAndWrite)); + CASCADE_CODE(MapPages(dst_addr, page_linked_list, KMemoryPermission::UserReadWrite)); block_guard.Cancel(); } @@ -582,7 +582,7 @@ ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) { block_manager->Update(src_addr, num_pages, src_state, KMemoryPermission::None, KMemoryAttribute::Locked); block_manager->Update(dst_addr, num_pages, KMemoryState::Stack, - KMemoryPermission::ReadAndWrite); + KMemoryPermission::UserReadWrite); return ResultSuccess; } @@ -617,13 +617,13 @@ ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) { auto block_guard = detail::ScopeExit([&] { MapPages(dst_addr, dst_pages, dst_perm); }); CASCADE_CODE(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap)); - CASCADE_CODE(Operate(src_addr, num_pages, KMemoryPermission::ReadAndWrite, + CASCADE_CODE(Operate(src_addr, num_pages, KMemoryPermission::UserReadWrite, OperationType::ChangePermissions)); block_guard.Cancel(); } - block_manager->Update(src_addr, num_pages, src_state, KMemoryPermission::ReadAndWrite); + block_manager->Update(src_addr, num_pages, src_state, KMemoryPermission::UserReadWrite); block_manager->Update(dst_addr, num_pages, KMemoryState::Free); return ResultSuccess; @@ -713,50 +713,61 @@ ResultCode KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, } ResultCode KPageTable::SetProcessMemoryPermission(VAddr addr, std::size_t size, - KMemoryPermission perm) { + Svc::MemoryPermission svc_perm) { + const size_t num_pages = size / PageSize; + // Lock the table. std::lock_guard lock{page_table_lock}; - KMemoryState prev_state{}; - KMemoryPermission prev_perm{}; + // Verify we can change the memory permission. + KMemoryState old_state; + KMemoryPermission old_perm; + size_t num_allocator_blocks; + R_TRY(this->CheckMemoryState(std::addressof(old_state), std::addressof(old_perm), nullptr, + std::addressof(num_allocator_blocks), addr, size, + KMemoryState::FlagCode, KMemoryState::FlagCode, + KMemoryPermission::None, KMemoryPermission::None, + KMemoryAttribute::All, KMemoryAttribute::None)); - CASCADE_CODE(CheckMemoryState( - &prev_state, &prev_perm, nullptr, nullptr, addr, size, KMemoryState::FlagCode, - KMemoryState::FlagCode, KMemoryPermission::None, KMemoryPermission::None, - KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); + // Determine new perm/state. + const KMemoryPermission new_perm = ConvertToKMemoryPermission(svc_perm); + KMemoryState new_state = old_state; + const bool is_w = (new_perm & KMemoryPermission::UserWrite) == KMemoryPermission::UserWrite; + const bool is_x = (new_perm & KMemoryPermission::UserExecute) == KMemoryPermission::UserExecute; + const bool was_x = + (old_perm & KMemoryPermission::UserExecute) == KMemoryPermission::UserExecute; + ASSERT(!(is_w && is_x)); - KMemoryState state{prev_state}; - - // Ensure state is mutable if permission allows write - if ((perm & KMemoryPermission::Write) != KMemoryPermission::None) { - if (prev_state == KMemoryState::Code) { - state = KMemoryState::CodeData; - } else if (prev_state == KMemoryState::AliasCode) { - state = KMemoryState::AliasCodeData; - } else { + if (is_w) { + switch (old_state) { + case KMemoryState::Code: + new_state = KMemoryState::CodeData; + break; + case KMemoryState::AliasCode: + new_state = KMemoryState::AliasCodeData; + break; + default: UNREACHABLE(); } } - // Return early if there is nothing to change - if (state == prev_state && perm == prev_perm) { - return ResultSuccess; - } + // Succeed if there's nothing to do. + R_SUCCEED_IF(old_perm == new_perm && old_state == new_state); - if ((prev_perm & KMemoryPermission::Execute) != (perm & KMemoryPermission::Execute)) { + // Perform mapping operation. + const auto operation = + was_x ? OperationType::ChangePermissionsAndRefresh : OperationType::ChangePermissions; + R_TRY(Operate(addr, num_pages, new_perm, operation)); + + // Update the blocks. + block_manager->Update(addr, num_pages, new_state, new_perm, KMemoryAttribute::None); + + // Ensure cache coherency, if we're setting pages as executable. + if (is_x) { // Memory execution state is changing, invalidate CPU cache range system.InvalidateCpuInstructionCacheRange(addr, size); } - const std::size_t num_pages{size / PageSize}; - const OperationType operation{(perm & KMemoryPermission::Execute) != KMemoryPermission::None - ? OperationType::ChangePermissionsAndRefresh - : OperationType::ChangePermissions}; - - CASCADE_CODE(Operate(addr, num_pages, perm, operation)); - - block_manager->Update(addr, num_pages, state, perm); - return ResultSuccess; } @@ -785,7 +796,7 @@ ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemo &state, nullptr, &attribute, nullptr, addr, size, KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, KMemoryPermission::All, - KMemoryPermission::ReadAndWrite, KMemoryAttribute::Mask, KMemoryAttribute::None, + KMemoryPermission::UserReadWrite, KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); block_manager->Update(addr, size / PageSize, state, perm, attribute | KMemoryAttribute::Locked); @@ -805,7 +816,7 @@ ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) { KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::Mask, KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped)); - block_manager->Update(addr, size / PageSize, state, KMemoryPermission::ReadAndWrite); + block_manager->Update(addr, size / PageSize, state, KMemoryPermission::UserReadWrite); return ResultSuccess; } @@ -906,7 +917,7 @@ ResultCode KPageTable::SetHeapSize(VAddr* out, std::size_t size) { R_TRY(this->CheckMemoryState(std::addressof(num_allocator_blocks), heap_region_start + size, GetHeapSize() - size, KMemoryState::All, KMemoryState::Normal, - KMemoryPermission::All, KMemoryPermission::ReadAndWrite, + KMemoryPermission::All, KMemoryPermission::UserReadWrite, KMemoryAttribute::All, KMemoryAttribute::None)); // Unmap the end of the heap. @@ -981,7 +992,7 @@ ResultCode KPageTable::SetHeapSize(VAddr* out, std::size_t size) { // Apply the memory block update. block_manager->Update(current_heap_end, num_pages, KMemoryState::Normal, - KMemoryPermission::ReadAndWrite, KMemoryAttribute::None); + KMemoryPermission::UserReadWrite, KMemoryAttribute::None); // Update the current heap end. current_heap_end = heap_region_start + size; diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h index 9235b822a..274644181 100755 --- a/src/core/hle/kernel/k_page_table.h +++ b/src/core/hle/kernel/k_page_table.h @@ -31,8 +31,8 @@ public: KMemoryManager::Pool pool); ResultCode MapProcessCode(VAddr addr, std::size_t pages_count, KMemoryState state, KMemoryPermission perm); - ResultCode MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size); - ResultCode UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size); + ResultCode MapCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size); + ResultCode UnmapCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size); ResultCode UnmapProcessMemory(VAddr dst_addr, std::size_t size, KPageTable& src_page_table, VAddr src_addr); ResultCode MapPhysicalMemory(VAddr addr, std::size_t size); @@ -43,7 +43,8 @@ public: ResultCode MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state, KMemoryPermission perm); ResultCode UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state); - ResultCode SetProcessMemoryPermission(VAddr addr, std::size_t size, KMemoryPermission perm); + ResultCode SetProcessMemoryPermission(VAddr addr, std::size_t size, + Svc::MemoryPermission svc_perm); KMemoryInfo QueryInfo(VAddr addr); ResultCode ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm); ResultCode ResetTransferMemory(VAddr addr, std::size_t size); diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp index bf98a51e2..cca405fed 100755 --- a/src/core/hle/kernel/k_process.cpp +++ b/src/core/hle/kernel/k_process.cpp @@ -509,7 +509,7 @@ VAddr KProcess::CreateTLSRegion() { const VAddr tls_page_addr{page_table ->AllocateAndMapMemory(1, PageSize, true, start, size / PageSize, KMemoryState::ThreadLocal, - KMemoryPermission::ReadAndWrite, + KMemoryPermission::UserReadWrite, tls_map_addr) .ValueOr(0)}; @@ -541,16 +541,16 @@ void KProcess::FreeTLSRegion(VAddr tls_address) { void KProcess::LoadModule(CodeSet code_set, VAddr base_addr) { const auto ReprotectSegment = [&](const CodeSet::Segment& segment, - KMemoryPermission permission) { + Svc::MemoryPermission permission) { page_table->SetProcessMemoryPermission(segment.addr + base_addr, segment.size, permission); }; kernel.System().Memory().WriteBlock(*this, base_addr, code_set.memory.data(), code_set.memory.size()); - ReprotectSegment(code_set.CodeSegment(), KMemoryPermission::ReadAndExecute); - ReprotectSegment(code_set.RODataSegment(), KMemoryPermission::Read); - ReprotectSegment(code_set.DataSegment(), KMemoryPermission::ReadAndWrite); + ReprotectSegment(code_set.CodeSegment(), Svc::MemoryPermission::ReadExecute); + ReprotectSegment(code_set.RODataSegment(), Svc::MemoryPermission::Read); + ReprotectSegment(code_set.DataSegment(), Svc::MemoryPermission::ReadWrite); } bool KProcess::IsSignaled() const { @@ -587,7 +587,7 @@ ResultCode KProcess::AllocateMainThreadStack(std::size_t stack_size) { CASCADE_RESULT(main_thread_stack_top, page_table->AllocateAndMapMemory( main_thread_stack_size / PageSize, PageSize, false, start, size / PageSize, - KMemoryState::Stack, KMemoryPermission::ReadAndWrite)); + KMemoryState::Stack, KMemoryPermission::UserReadWrite)); main_thread_stack_top += main_thread_stack_size; diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index a561b62c0..071a018e7 100755 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -121,7 +121,7 @@ struct KernelCore::Impl { object_list_container.Finalize(); // Ensures all service threads gracefully shutdown. - service_threads.clear(); + ClearServiceThreads(); next_object_id = 0; next_kernel_process_id = KProcess::InitialKIPIDMin; @@ -713,11 +713,32 @@ struct KernelCore::Impl { return port; } + std::weak_ptr CreateServiceThread(KernelCore& kernel, + const std::string& name) { + std::lock_guard lk(service_threads_lock); + auto service_thread = std::make_shared(kernel, 1, name); + service_threads.emplace(service_thread); + return service_thread; + } + + void ReleaseServiceThread(std::weak_ptr service_thread) { + std::lock_guard lk(service_threads_lock); + if (auto strong_ptr = service_thread.lock()) { + service_threads.erase(strong_ptr); + } + } + + void ClearServiceThreads() { + std::lock_guard lk(service_threads_lock); + service_threads.clear(); + } + std::mutex server_ports_lock; std::mutex server_sessions_lock; std::mutex registered_objects_lock; std::mutex registered_in_use_objects_lock; std::mutex dummy_thread_lock; + std::mutex service_threads_lock; std::atomic next_object_id{0}; std::atomic next_kernel_process_id{KProcess::InitialKIPIDMin}; @@ -1117,15 +1138,11 @@ void KernelCore::ExitSVCProfile() { } std::weak_ptr KernelCore::CreateServiceThread(const std::string& name) { - auto service_thread = std::make_shared(*this, 1, name); - impl->service_threads.emplace(service_thread); - return service_thread; + return impl->CreateServiceThread(*this, name); } void KernelCore::ReleaseServiceThread(std::weak_ptr service_thread) { - if (auto strong_ptr = service_thread.lock()) { - impl->service_threads.erase(strong_ptr); - } + impl->ReleaseServiceThread(service_thread); } Init::KSlabResourceCounts& KernelCore::SlabResourceCounts() { diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp index 7f02d9471..7477668e4 100755 --- a/src/core/hle/kernel/physical_core.cpp +++ b/src/core/hle/kernel/physical_core.cpp @@ -16,17 +16,25 @@ namespace Kernel { PhysicalCore::PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_, Core::CPUInterrupts& interrupts_) : core_index{core_index_}, system{system_}, scheduler{scheduler_}, - interrupts{interrupts_}, guard{std::make_unique()} {} + interrupts{interrupts_}, guard{std::make_unique()} { +#ifdef ARCHITECTURE_x86_64 + // TODO(bunnei): Initialization relies on a core being available. We may later replace this with + // a 32-bit instance of Dynarmic. This should be abstracted out to a CPU manager. + auto& kernel = system.Kernel(); + arm_interface = std::make_unique( + system, interrupts, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index); +#else +#error Platform not supported yet. +#endif +} PhysicalCore::~PhysicalCore() = default; void PhysicalCore::Initialize([[maybe_unused]] bool is_64_bit) { #ifdef ARCHITECTURE_x86_64 auto& kernel = system.Kernel(); - if (is_64_bit) { - arm_interface = std::make_unique( - system, interrupts, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index); - } else { + if (!is_64_bit) { + // We already initialized a 64-bit core, replace with a 32-bit one. arm_interface = std::make_unique( system, interrupts, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index); } diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp index 4362508a3..c7f5140f4 100755 --- a/src/core/hle/kernel/svc.cpp +++ b/src/core/hle/kernel/svc.cpp @@ -1309,6 +1309,8 @@ static ResultCode SetProcessMemoryPermission(Core::System& system, Handle proces R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize); R_UNLESS(size > 0, ResultInvalidSize); R_UNLESS((address < address + size), ResultInvalidCurrentMemory); + R_UNLESS(address == static_cast(address), ResultInvalidCurrentMemory); + R_UNLESS(size == static_cast(size), ResultInvalidCurrentMemory); // Validate the memory permission. R_UNLESS(IsValidProcessMemoryPermission(perm), ResultInvalidNewMemoryPermission); @@ -1323,7 +1325,7 @@ static ResultCode SetProcessMemoryPermission(Core::System& system, Handle proces R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory); // Set the memory permission. - return page_table.SetProcessMemoryPermission(address, size, ConvertToKMemoryPermission(perm)); + return page_table.SetProcessMemoryPermission(address, size, perm); } static ResultCode MapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle, @@ -1626,7 +1628,7 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand return ResultInvalidMemoryRegion; } - return page_table.MapProcessCodeMemory(dst_address, src_address, size); + return page_table.MapCodeMemory(dst_address, src_address, size); } static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_handle, @@ -1694,7 +1696,7 @@ static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_ha return ResultInvalidMemoryRegion; } - return page_table.UnmapProcessCodeMemory(dst_address, src_address, size); + return page_table.UnmapCodeMemory(dst_address, src_address, size); } /// Exits the current process diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp index 3782703d2..9fc7bb1b1 100755 --- a/src/core/hle/service/ldr/ldr.cpp +++ b/src/core/hle/service/ldr/ldr.cpp @@ -14,6 +14,7 @@ #include "core/hle/kernel/k_page_table.h" #include "core/hle/kernel/k_system_control.h" #include "core/hle/kernel/svc_results.h" +#include "core/hle/kernel/svc_types.h" #include "core/hle/service/ldr/ldr.h" #include "core/hle/service/service.h" #include "core/loader/nro.h" @@ -325,7 +326,7 @@ public: for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) { auto& page_table{process->PageTable()}; const VAddr addr{GetRandomMapRegion(page_table, size)}; - const ResultCode result{page_table.MapProcessCodeMemory(addr, baseAddress, size)}; + const ResultCode result{page_table.MapCodeMemory(addr, baseAddress, size)}; if (result == Kernel::ResultInvalidCurrentMemory) { continue; @@ -351,12 +352,12 @@ public: if (bss_size) { auto block_guard = detail::ScopeExit([&] { - page_table.UnmapProcessCodeMemory(addr + nro_size, bss_addr, bss_size); - page_table.UnmapProcessCodeMemory(addr, nro_addr, nro_size); + page_table.UnmapCodeMemory(addr + nro_size, bss_addr, bss_size); + page_table.UnmapCodeMemory(addr, nro_addr, nro_size); }); const ResultCode result{ - page_table.MapProcessCodeMemory(addr + nro_size, bss_addr, bss_size)}; + page_table.MapCodeMemory(addr + nro_size, bss_addr, bss_size)}; if (result == Kernel::ResultInvalidCurrentMemory) { continue; @@ -397,12 +398,12 @@ public: nro_header.segment_headers[DATA_INDEX].memory_size); CASCADE_CODE(process->PageTable().SetProcessMemoryPermission( - text_start, ro_start - text_start, Kernel::KMemoryPermission::ReadAndExecute)); + text_start, ro_start - text_start, Kernel::Svc::MemoryPermission::ReadExecute)); CASCADE_CODE(process->PageTable().SetProcessMemoryPermission( - ro_start, data_start - ro_start, Kernel::KMemoryPermission::Read)); + ro_start, data_start - ro_start, Kernel::Svc::MemoryPermission::Read)); return process->PageTable().SetProcessMemoryPermission( - data_start, bss_end_addr - data_start, Kernel::KMemoryPermission::ReadAndWrite); + data_start, bss_end_addr - data_start, Kernel::Svc::MemoryPermission::ReadWrite); } void LoadModule(Kernel::HLERequestContext& ctx) { @@ -530,16 +531,19 @@ public: ResultCode UnmapNro(const NROInfo& info) { // Each region must be unmapped separately to validate memory state auto& page_table{system.CurrentProcess()->PageTable()}; - CASCADE_CODE(page_table.UnmapProcessCodeMemory(info.nro_address + info.text_size + - info.ro_size + info.data_size, - info.bss_address, info.bss_size)); - CASCADE_CODE(page_table.UnmapProcessCodeMemory( - info.nro_address + info.text_size + info.ro_size, - info.src_addr + info.text_size + info.ro_size, info.data_size)); - CASCADE_CODE(page_table.UnmapProcessCodeMemory( - info.nro_address + info.text_size, info.src_addr + info.text_size, info.ro_size)); - CASCADE_CODE( - page_table.UnmapProcessCodeMemory(info.nro_address, info.src_addr, info.text_size)); + + if (info.bss_size != 0) { + CASCADE_CODE(page_table.UnmapCodeMemory(info.nro_address + info.text_size + + info.ro_size + info.data_size, + info.bss_address, info.bss_size)); + } + + CASCADE_CODE(page_table.UnmapCodeMemory(info.nro_address + info.text_size + info.ro_size, + info.src_addr + info.text_size + info.ro_size, + info.data_size)); + CASCADE_CODE(page_table.UnmapCodeMemory(info.nro_address + info.text_size, + info.src_addr + info.text_size, info.ro_size)); + CASCADE_CODE(page_table.UnmapCodeMemory(info.nro_address, info.src_addr, info.text_size)); return ResultSuccess; } diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt index 4a20c0768..a69ccb264 100755 --- a/src/tests/CMakeLists.txt +++ b/src/tests/CMakeLists.txt @@ -16,6 +16,6 @@ add_executable(tests create_target_directory_groups(tests) target_link_libraries(tests PRIVATE common core input_common) -target_link_libraries(tests PRIVATE ${PLATFORM_LIBRARIES} catch-single-include Threads::Threads) +target_link_libraries(tests PRIVATE ${PLATFORM_LIBRARIES} Catch2::Catch2 Threads::Threads) add_test(NAME tests COMMAND tests)