diff options
53 files changed, 1346 insertions, 444 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 47bd282fb..4bf55d664 100644 --- 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/externals/CMakeLists.txt b/externals/CMakeLists.txt index 158113516..82e8ef18c 100644 --- 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 19d16147d..1bdf70b76 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -151,7 +151,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/common/fiber.cpp b/src/common/fiber.cpp index 62010d762..81b212e4b 100644 --- a/src/common/fiber.cpp +++ b/src/common/fiber.cpp @@ -124,7 +124,10 @@ void Fiber::YieldTo(std::weak_ptr<Fiber> weak_from, Fiber& to) { // "from" might no longer be valid if the thread was killed if (auto from = weak_from.lock()) { - ASSERT(from->impl->previous_fiber != nullptr); + if (from->impl->previous_fiber == nullptr) { + ASSERT_MSG(false, "previous_fiber is nullptr!"); + return; + } from->impl->previous_fiber->impl->context = transfer.fctx; from->impl->previous_fiber->impl->guard.unlock(); from->impl->previous_fiber.reset(); diff --git a/src/common/input.h b/src/common/input.h index f775a4c01..f4f9eb30a 100644 --- a/src/common/input.h +++ b/src/common/input.h @@ -209,6 +209,13 @@ enum class ButtonNames { Triangle, Share, Options, + + // Mouse buttons + ButtonMouseWheel, + ButtonBackward, + ButtonForward, + ButtonTask, + ButtonExtra, }; // Callback data consisting of an input type and the equivalent data status diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index b1a746727..6e8d11919 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -247,6 +247,9 @@ add_library(core STATIC hle/kernel/k_trace.h hle/kernel/k_transfer_memory.cpp hle/kernel/k_transfer_memory.h + hle/kernel/k_worker_task.h + hle/kernel/k_worker_task_manager.cpp + hle/kernel/k_worker_task_manager.h hle/kernel/k_writable_event.cpp hle/kernel/k_writable_event.h hle/kernel/kernel.cpp diff --git a/src/core/hid/emulated_console.cpp b/src/core/hid/emulated_console.cpp index 08f8af551..eef0ff493 100644 --- a/src/core/hid/emulated_console.cpp +++ b/src/core/hid/emulated_console.cpp @@ -158,7 +158,7 @@ void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) { auto& motion = console.motion_state; motion.accel = emulated.GetAcceleration(); motion.gyro = emulated.GetGyroscope(); - motion.rotation = emulated.GetGyroscope(); + motion.rotation = emulated.GetRotations(); motion.orientation = emulated.GetOrientation(); motion.quaternion = emulated.GetQuaternion(); motion.gyro_bias = emulated.GetGyroBias(); diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp index 52a56ef1a..d12037b11 100644 --- a/src/core/hid/emulated_controller.cpp +++ b/src/core/hid/emulated_controller.cpp @@ -145,7 +145,7 @@ void EmulatedController::LoadDevices() { motion_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>); std::transform(trigger_params.begin(), trigger_params.end(), trigger_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>); - std::transform(battery_params.begin(), battery_params.begin(), battery_devices.end(), + std::transform(battery_params.begin(), battery_params.end(), battery_devices.begin(), Common::Input::CreateDevice<Common::Input::InputDevice>); std::transform(output_params.begin(), output_params.end(), output_devices.begin(), Common::Input::CreateDevice<Common::Input::OutputDevice>); @@ -351,6 +351,19 @@ void EmulatedController::DisableConfiguration() { } } +void EmulatedController::EnableSystemButtons() { + system_buttons_enabled = true; +} + +void EmulatedController::DisableSystemButtons() { + system_buttons_enabled = false; +} + +void EmulatedController::ResetSystemButtons() { + controller.home_button_state.home.Assign(false); + controller.capture_button_state.capture.Assign(false); +} + bool EmulatedController::IsConfiguring() const { return is_configuring; } @@ -600,7 +613,16 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback controller.npad_button_state.right_sr.Assign(current_status.value); break; case Settings::NativeButton::Home: + if (!system_buttons_enabled) { + break; + } + controller.home_button_state.home.Assign(current_status.value); + break; case Settings::NativeButton::Screenshot: + if (!system_buttons_enabled) { + break; + } + controller.capture_button_state.capture.Assign(current_status.value); break; } } @@ -1081,6 +1103,20 @@ BatteryValues EmulatedController::GetBatteryValues() const { return controller.battery_values; } +HomeButtonState EmulatedController::GetHomeButtons() const { + if (is_configuring) { + return {}; + } + return controller.home_button_state; +} + +CaptureButtonState EmulatedController::GetCaptureButtons() const { + if (is_configuring) { + return {}; + } + return controller.capture_button_state; +} + NpadButtonState EmulatedController::GetNpadButtons() const { if (is_configuring) { return {}; diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h index c0994ab4d..a63a83cce 100644 --- a/src/core/hid/emulated_controller.h +++ b/src/core/hid/emulated_controller.h @@ -101,6 +101,8 @@ struct ControllerStatus { VibrationValues vibration_values{}; // Data for HID serices + HomeButtonState home_button_state{}; + CaptureButtonState capture_button_state{}; NpadButtonState npad_button_state{}; DebugPadButton debug_pad_button_state{}; AnalogSticks analog_stick_state{}; @@ -198,6 +200,15 @@ public: /// Returns the emulated controller into normal mode, allowing the modification of the HID state void DisableConfiguration(); + /// Enables Home and Screenshot buttons + void EnableSystemButtons(); + + /// Disables Home and Screenshot buttons + void DisableSystemButtons(); + + /// Sets Home and Screenshot buttons to false + void ResetSystemButtons(); + /// Returns true if the emulated controller is in configuring mode bool IsConfiguring() const; @@ -261,7 +272,13 @@ public: /// Returns the latest battery status from the controller with parameters BatteryValues GetBatteryValues() const; - /// Returns the latest status of button input for the npad service + /// Returns the latest status of button input for the hid::HomeButton service + HomeButtonState GetHomeButtons() const; + + /// Returns the latest status of button input for the hid::CaptureButton service + CaptureButtonState GetCaptureButtons() const; + + /// Returns the latest status of button input for the hid::Npad service NpadButtonState GetNpadButtons() const; /// Returns the latest status of button input for the debug pad service @@ -383,6 +400,7 @@ private: NpadStyleTag supported_style_tag{NpadStyleSet::All}; bool is_connected{false}; bool is_configuring{false}; + bool system_buttons_enabled{true}; f32 motion_sensitivity{0.01f}; bool force_update_motion{false}; diff --git a/src/core/hid/hid_types.h b/src/core/hid/hid_types.h index 4eca68533..778b328b9 100644 --- a/src/core/hid/hid_types.h +++ b/src/core/hid/hid_types.h @@ -378,6 +378,26 @@ struct LedPattern { }; }; +struct HomeButtonState { + union { + u64 raw{}; + + // Buttons + BitField<0, 1, u64> home; + }; +}; +static_assert(sizeof(HomeButtonState) == 0x8, "HomeButtonState has incorrect size."); + +struct CaptureButtonState { + union { + u64 raw{}; + + // Buttons + BitField<0, 1, u64> capture; + }; +}; +static_assert(sizeof(CaptureButtonState) == 0x8, "CaptureButtonState has incorrect size."); + struct NpadButtonState { union { NpadButton raw{}; diff --git a/src/core/hid/input_converter.cpp b/src/core/hid/input_converter.cpp index f5acff6e0..860aab400 100644 --- a/src/core/hid/input_converter.cpp +++ b/src/core/hid/input_converter.cpp @@ -114,7 +114,7 @@ Common::Input::MotionStatus TransformToMotion(const Common::Input::CallbackStatu if (TransformToButton(callback).value) { std::random_device device; std::mt19937 gen(device()); - std::uniform_int_distribution<s16> distribution(-1000, 1000); + std::uniform_int_distribution<s16> distribution(-5000, 5000); status.accel.x.raw_value = static_cast<f32>(distribution(gen)) * 0.001f; status.accel.y.raw_value = static_cast<f32>(distribution(gen)) * 0.001f; status.accel.z.raw_value = static_cast<f32>(distribution(gen)) * 0.001f; diff --git a/src/core/hid/motion_input.cpp b/src/core/hid/motion_input.cpp index 43152492e..6e126be19 100644 --- a/src/core/hid/motion_input.cpp +++ b/src/core/hid/motion_input.cpp @@ -10,7 +10,7 @@ namespace Core::HID { MotionInput::MotionInput() { // Initialize PID constants with default values SetPID(0.3f, 0.005f, 0.0f); - SetGyroThreshold(0.001f); + SetGyroThreshold(0.00005f); } void MotionInput::SetPID(f32 new_kp, f32 new_ki, f32 new_kd) { diff --git a/src/core/hle/kernel/k_memory_block.h b/src/core/hle/kernel/k_memory_block.h index 9e51c33ce..dcca47f1b 100644 --- a/src/core/hle/kernel/k_memory_block.h +++ b/src/core/hle/kernel/k_memory_block.h @@ -70,12 +70,12 @@ enum class KMemoryState : u32 { ThreadLocal = static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagMapped | FlagReferenceCounted, - Transferred = static_cast<u32>(Svc::MemoryState::Transferred) | FlagsMisc | - FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc | - FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc, + Transfered = static_cast<u32>(Svc::MemoryState::Transferred) | FlagsMisc | + FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc | + FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc, - SharedTransferred = static_cast<u32>(Svc::MemoryState::SharedTransferred) | FlagsMisc | - FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc, + SharedTransfered = static_cast<u32>(Svc::MemoryState::SharedTransferred) | FlagsMisc | + FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc, SharedCode = static_cast<u32>(Svc::MemoryState::SharedCode) | FlagMapped | FlagReferenceCounted | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc, @@ -93,6 +93,8 @@ enum class KMemoryState : u32 { GeneratedCode = static_cast<u32>(Svc::MemoryState::GeneratedCode) | FlagMapped | FlagReferenceCounted | FlagCanDebug, CodeOut = static_cast<u32>(Svc::MemoryState::CodeOut) | FlagMapped | FlagReferenceCounted, + + Coverage = static_cast<u32>(Svc::MemoryState::Coverage) | FlagMapped, }; DECLARE_ENUM_FLAG_OPERATORS(KMemoryState); @@ -108,8 +110,8 @@ static_assert(static_cast<u32>(KMemoryState::AliasCodeData) == 0x03FFBD09); static_assert(static_cast<u32>(KMemoryState::Ipc) == 0x005C3C0A); static_assert(static_cast<u32>(KMemoryState::Stack) == 0x005C3C0B); static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0040200C); -static_assert(static_cast<u32>(KMemoryState::Transferred) == 0x015C3C0D); -static_assert(static_cast<u32>(KMemoryState::SharedTransferred) == 0x005C380E); +static_assert(static_cast<u32>(KMemoryState::Transfered) == 0x015C3C0D); +static_assert(static_cast<u32>(KMemoryState::SharedTransfered) == 0x005C380E); static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0040380F); static_assert(static_cast<u32>(KMemoryState::Inaccessible) == 0x00000010); static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x005C3811); @@ -117,6 +119,7 @@ static_assert(static_cast<u32>(KMemoryState::NonDeviceIpc) == 0x004C2812); static_assert(static_cast<u32>(KMemoryState::Kernel) == 0x00002013); static_assert(static_cast<u32>(KMemoryState::GeneratedCode) == 0x00402214); static_assert(static_cast<u32>(KMemoryState::CodeOut) == 0x00402015); +static_assert(static_cast<u32>(KMemoryState::Coverage) == 0x00002016); enum class KMemoryPermission : u8 { None = 0, @@ -155,7 +158,13 @@ enum class KMemoryPermission : u8 { DECLARE_ENUM_FLAG_OPERATORS(KMemoryPermission); constexpr KMemoryPermission ConvertToKMemoryPermission(Svc::MemoryPermission perm) { - return static_cast<KMemoryPermission>(perm); + return static_cast<KMemoryPermission>( + (static_cast<KMemoryPermission>(perm) & KMemoryPermission::UserMask) | + KMemoryPermission::KernelRead | + ((static_cast<KMemoryPermission>(perm) & KMemoryPermission::UserWrite) + << KMemoryPermission::KernelShift) | + (perm == Svc::MemoryPermission::None ? KMemoryPermission::NotMapped + : KMemoryPermission::None)); } enum class KMemoryAttribute : u8 { @@ -169,6 +178,8 @@ enum class KMemoryAttribute : u8 { DeviceShared = static_cast<u8>(Svc::MemoryAttribute::DeviceShared), Uncached = static_cast<u8>(Svc::MemoryAttribute::Uncached), + SetMask = Uncached, + IpcAndDeviceMapped = IpcLocked | DeviceShared, LockedAndIpcLocked = Locked | IpcLocked, DeviceSharedAndUncached = DeviceShared | Uncached @@ -215,6 +226,15 @@ struct KMemoryInfo { constexpr VAddr GetLastAddress() const { return GetEndAddress() - 1; } + constexpr KMemoryState GetState() const { + return state; + } + constexpr KMemoryAttribute GetAttribute() const { + return attribute; + } + constexpr KMemoryPermission GetPermission() const { + return perm; + } }; class KMemoryBlock final { diff --git a/src/core/hle/kernel/k_memory_manager.cpp b/src/core/hle/kernel/k_memory_manager.cpp index 0166df0a5..1b44541b1 100644 --- a/src/core/hle/kernel/k_memory_manager.cpp +++ b/src/core/hle/kernel/k_memory_manager.cpp @@ -8,12 +8,16 @@ #include "common/assert.h" #include "common/common_types.h" #include "common/scope_exit.h" +#include "core/core.h" +#include "core/device_memory.h" #include "core/hle/kernel/k_memory_manager.h" #include "core/hle/kernel/k_page_linked_list.h" #include "core/hle/kernel/svc_results.h" namespace Kernel { +KMemoryManager::KMemoryManager(Core::System& system_) : system{system_} {} + std::size_t KMemoryManager::Impl::Initialize(Pool new_pool, u64 start_address, u64 end_address) { const auto size{end_address - start_address}; @@ -81,7 +85,7 @@ VAddr KMemoryManager::AllocateAndOpenContinuous(std::size_t num_pages, std::size } ResultCode KMemoryManager::Allocate(KPageLinkedList& page_list, std::size_t num_pages, Pool pool, - Direction dir) { + Direction dir, u32 heap_fill_value) { ASSERT(page_list.GetNumPages() == 0); // Early return if we're allocating no pages @@ -139,6 +143,12 @@ ResultCode KMemoryManager::Allocate(KPageLinkedList& page_list, std::size_t num_ } } + // Clear allocated memory. + for (const auto& it : page_list.Nodes()) { + std::memset(system.DeviceMemory().GetPointer(it.GetAddress()), heap_fill_value, + it.GetSize()); + } + // Only succeed if we allocated as many pages as we wanted if (num_pages) { return ResultOutOfMemory; @@ -146,11 +156,12 @@ ResultCode KMemoryManager::Allocate(KPageLinkedList& page_list, std::size_t num_ // We succeeded! group_guard.Cancel(); + return ResultSuccess; } ResultCode KMemoryManager::Free(KPageLinkedList& page_list, std::size_t num_pages, Pool pool, - Direction dir) { + Direction dir, u32 heap_fill_value) { // Early return if we're freeing no pages if (!num_pages) { return ResultSuccess; diff --git a/src/core/hle/kernel/k_memory_manager.h b/src/core/hle/kernel/k_memory_manager.h index 39badc5f1..abd6c8ace 100644 --- a/src/core/hle/kernel/k_memory_manager.h +++ b/src/core/hle/kernel/k_memory_manager.h @@ -12,6 +12,10 @@ #include "core/hle/kernel/k_page_heap.h" #include "core/hle/result.h" +namespace Core { +class System; +} + namespace Kernel { class KPageLinkedList; @@ -42,7 +46,7 @@ public: Mask = (0xF << Shift), }; - KMemoryManager() = default; + explicit KMemoryManager(Core::System& system_); constexpr std::size_t GetSize(Pool pool) const { return managers[static_cast<std::size_t>(pool)].GetSize(); @@ -51,10 +55,10 @@ public: void InitializeManager(Pool pool, u64 start_address, u64 end_address); VAddr AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option); - ResultCode Allocate(KPageLinkedList& page_list, std::size_t num_pages, Pool pool, - Direction dir = Direction::FromFront); - ResultCode Free(KPageLinkedList& page_list, std::size_t num_pages, Pool pool, - Direction dir = Direction::FromFront); + ResultCode Allocate(KPageLinkedList& page_list, std::size_t num_pages, Pool pool, Direction dir, + u32 heap_fill_value = 0); + ResultCode Free(KPageLinkedList& page_list, std::size_t num_pages, Pool pool, Direction dir, + u32 heap_fill_value = 0); static constexpr std::size_t MaxManagerCount = 10; @@ -129,6 +133,7 @@ private: }; private: + Core::System& system; std::array<std::mutex, static_cast<std::size_t>(Pool::Count)> pool_locks; std::array<Impl, MaxManagerCount> managers; }; diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp index 4da509224..b650ea31d 100644 --- a/src/core/hle/kernel/k_page_table.cpp +++ b/src/core/hle/kernel/k_page_table.cpp @@ -289,8 +289,8 @@ ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemory } KPageLinkedList page_linked_list; - CASCADE_CODE( - system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool)); + CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool, + allocation_option)); CASCADE_CODE(Operate(addr, num_pages, page_linked_list, OperationType::MapGroup)); block_manager->Update(addr, num_pages, state, perm); @@ -298,16 +298,16 @@ 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}; KMemoryState state{}; KMemoryPermission perm{}; - CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, src_addr, size, KMemoryState::All, - KMemoryState::Normal, KMemoryPermission::All, - KMemoryPermission::ReadAndWrite, KMemoryAttribute::Mask, + CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, nullptr, src_addr, size, + KMemoryState::All, KMemoryState::Normal, KMemoryPermission::All, + 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) { @@ -344,14 +344,14 @@ ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, st const std::size_t num_pages{size / PageSize}; - CASCADE_CODE(CheckMemoryState(nullptr, nullptr, nullptr, src_addr, size, KMemoryState::All, - KMemoryState::Normal, KMemoryPermission::None, + CASCADE_CODE(CheckMemoryState(nullptr, nullptr, nullptr, nullptr, src_addr, size, + KMemoryState::All, KMemoryState::Normal, KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::Mask, KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped)); KMemoryState state{}; CASCADE_CODE(CheckMemoryState( - &state, nullptr, nullptr, dst_addr, PageSize, KMemoryState::FlagCanCodeAlias, + &state, nullptr, nullptr, nullptr, dst_addr, PageSize, KMemoryState::FlagCanCodeAlias, KMemoryState::FlagCanCodeAlias, KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); CASCADE_CODE(CheckMemoryState(dst_addr, size, KMemoryState::All, state, KMemoryPermission::None, @@ -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; @@ -457,8 +457,8 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr addr, std::size_t size) { KPageLinkedList page_linked_list; - CASCADE_CODE( - system.Kernel().MemoryManager().Allocate(page_linked_list, remaining_pages, memory_pool)); + CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_linked_list, remaining_pages, + memory_pool, allocation_option)); // We succeeded, so commit the memory reservation. memory_reservation.Commit(); @@ -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; } @@ -541,7 +541,8 @@ ResultCode KPageTable::UnmapMemory(VAddr addr, std::size_t size) { } const std::size_t num_pages{size / PageSize}; - system.Kernel().MemoryManager().Free(page_linked_list, num_pages, memory_pool); + system.Kernel().MemoryManager().Free(page_linked_list, num_pages, memory_pool, + allocation_option); block_manager->Update(addr, num_pages, KMemoryState::Free); @@ -553,8 +554,8 @@ ResultCode KPageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) { KMemoryState src_state{}; CASCADE_CODE(CheckMemoryState( - &src_state, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias, - KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::ReadAndWrite, + &src_state, nullptr, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias, + KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::UserReadWrite, KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); if (IsRegionMapped(dst_addr, size)) { @@ -568,13 +569,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 +583,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; } @@ -592,13 +593,13 @@ ResultCode KPageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) { KMemoryState src_state{}; CASCADE_CODE(CheckMemoryState( - &src_state, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias, + &src_state, nullptr, nullptr, nullptr, src_addr, size, KMemoryState::FlagCanAlias, KMemoryState::FlagCanAlias, KMemoryPermission::All, KMemoryPermission::None, KMemoryAttribute::Mask, KMemoryAttribute::Locked, KMemoryAttribute::IpcAndDeviceMapped)); KMemoryPermission dst_perm{}; - CASCADE_CODE(CheckMemoryState(nullptr, &dst_perm, nullptr, dst_addr, size, KMemoryState::All, - KMemoryState::Stack, KMemoryPermission::None, + CASCADE_CODE(CheckMemoryState(nullptr, &dst_perm, nullptr, nullptr, dst_addr, size, + KMemoryState::All, KMemoryState::Stack, KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); @@ -617,13 +618,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 +714,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{}; - - CASCADE_CODE(CheckMemoryState( - &prev_state, &prev_perm, nullptr, addr, size, KMemoryState::FlagCode, - KMemoryState::FlagCode, KMemoryPermission::None, KMemoryPermission::None, - KMemoryAttribute::Mask, KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped)); - - KMemoryState state{prev_state}; + // 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)); - // 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 { + // 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)); + + 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); + + // Perform mapping operation. + const auto operation = + was_x ? OperationType::ChangePermissionsAndRefresh : OperationType::ChangePermissions; + R_TRY(Operate(addr, num_pages, new_perm, operation)); - if ((prev_perm & KMemoryPermission::Execute) != (perm & KMemoryPermission::Execute)) { + // 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; } @@ -782,10 +794,10 @@ ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemo KMemoryAttribute attribute{}; CASCADE_CODE(CheckMemoryState( - &state, nullptr, &attribute, addr, size, + &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); @@ -799,13 +811,13 @@ ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) { KMemoryState state{}; CASCADE_CODE( - CheckMemoryState(&state, nullptr, nullptr, addr, size, + CheckMemoryState(&state, nullptr, nullptr, nullptr, addr, size, KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, KMemoryState::FlagCanTransfer | KMemoryState::FlagReferenceCounted, 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; } @@ -820,7 +832,7 @@ ResultCode KPageTable::SetMemoryPermission(VAddr addr, std::size_t size, KMemoryState old_state; KMemoryPermission old_perm; R_TRY(this->CheckMemoryState( - std::addressof(old_state), std::addressof(old_perm), nullptr, addr, size, + std::addressof(old_state), std::addressof(old_perm), nullptr, nullptr, addr, size, KMemoryState::FlagCanReprotect, KMemoryState::FlagCanReprotect, KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::All, KMemoryAttribute::None)); @@ -837,24 +849,36 @@ ResultCode KPageTable::SetMemoryPermission(VAddr addr, std::size_t size, return ResultSuccess; } -ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask, - KMemoryAttribute value) { - std::lock_guard lock{page_table_lock}; +ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr) { + const size_t num_pages = size / PageSize; + ASSERT((static_cast<KMemoryAttribute>(mask) | KMemoryAttribute::SetMask) == + KMemoryAttribute::SetMask); - KMemoryState state{}; - KMemoryPermission perm{}; - KMemoryAttribute attribute{}; + // Lock the table. + std::lock_guard lock{page_table_lock}; - CASCADE_CODE(CheckMemoryState( - &state, &perm, &attribute, addr, size, KMemoryState::FlagCanChangeAttribute, + // Verify we can change the memory attribute. + KMemoryState old_state; + KMemoryPermission old_perm; + KMemoryAttribute old_attr; + size_t num_allocator_blocks; + constexpr auto AttributeTestMask = + ~(KMemoryAttribute::SetMask | KMemoryAttribute::DeviceShared); + R_TRY(this->CheckMemoryState( + std::addressof(old_state), std::addressof(old_perm), std::addressof(old_attr), + std::addressof(num_allocator_blocks), addr, size, KMemoryState::FlagCanChangeAttribute, KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None, - KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None, - KMemoryAttribute::DeviceSharedAndUncached)); + AttributeTestMask, KMemoryAttribute::None, ~AttributeTestMask)); + + // Determine the new attribute. + const auto new_attr = ((old_attr & static_cast<KMemoryAttribute>(~mask)) | + static_cast<KMemoryAttribute>(attr & mask)); - attribute = attribute & ~mask; - attribute = attribute | (mask & value); + // Perform operation. + this->Operate(addr, num_pages, old_perm, OperationType::ChangePermissionsAndRefresh); - block_manager->Update(addr, size / PageSize, state, perm, attribute); + // Update the blocks. + block_manager->Update(addr, num_pages, old_state, old_perm, new_attr); return ResultSuccess; } @@ -894,7 +918,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. @@ -937,7 +961,7 @@ ResultCode KPageTable::SetHeapSize(VAddr* out, std::size_t size) { // Allocate pages for the heap extension. KPageLinkedList page_linked_list; R_TRY(system.Kernel().MemoryManager().Allocate(page_linked_list, allocation_size / PageSize, - memory_pool)); + memory_pool, allocation_option)); // Map the pages. { @@ -969,7 +993,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; @@ -1004,8 +1028,8 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages, CASCADE_CODE(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr)); } else { KPageLinkedList page_group; - CASCADE_CODE( - system.Kernel().MemoryManager().Allocate(page_group, needed_num_pages, memory_pool)); + CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_group, needed_num_pages, + memory_pool, allocation_option)); CASCADE_CODE(Operate(addr, needed_num_pages, page_group, OperationType::MapGroup)); } @@ -1019,7 +1043,7 @@ ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) { KMemoryPermission perm{}; if (const ResultCode result{CheckMemoryState( - nullptr, &perm, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute, + nullptr, &perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute, KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None, KMemoryAttribute::DeviceSharedAndUncached)}; @@ -1042,7 +1066,7 @@ ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size) KMemoryPermission perm{}; if (const ResultCode result{CheckMemoryState( - nullptr, &perm, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute, + nullptr, &perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute, KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None, KMemoryAttribute::DeviceSharedAndUncached)}; @@ -1068,7 +1092,7 @@ ResultCode KPageTable::LockForCodeMemory(VAddr addr, std::size_t size) { KMemoryPermission old_perm{}; if (const ResultCode result{CheckMemoryState( - nullptr, &old_perm, nullptr, addr, size, KMemoryState::FlagCanCodeMemory, + nullptr, &old_perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanCodeMemory, KMemoryState::FlagCanCodeMemory, KMemoryPermission::All, KMemoryPermission::UserReadWrite, KMemoryAttribute::All, KMemoryAttribute::None)}; result.IsError()) { @@ -1095,7 +1119,7 @@ ResultCode KPageTable::UnlockForCodeMemory(VAddr addr, std::size_t size) { KMemoryPermission old_perm{}; if (const ResultCode result{CheckMemoryState( - nullptr, &old_perm, nullptr, addr, size, KMemoryState::FlagCanCodeMemory, + nullptr, &old_perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanCodeMemory, KMemoryState::FlagCanCodeMemory, KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::All, KMemoryAttribute::Locked)}; result.IsError()) { @@ -1225,18 +1249,19 @@ constexpr VAddr KPageTable::GetRegionAddress(KMemoryState state) const { return alias_region_start; case KMemoryState::Stack: return stack_region_start; - case KMemoryState::Io: case KMemoryState::Static: case KMemoryState::ThreadLocal: return kernel_map_region_start; + case KMemoryState::Io: case KMemoryState::Shared: case KMemoryState::AliasCode: case KMemoryState::AliasCodeData: - case KMemoryState::Transferred: - case KMemoryState::SharedTransferred: + case KMemoryState::Transfered: + case KMemoryState::SharedTransfered: case KMemoryState::SharedCode: case KMemoryState::GeneratedCode: case KMemoryState::CodeOut: + case KMemoryState::Coverage: return alias_code_region_start; case KMemoryState::Code: case KMemoryState::CodeData: @@ -1260,18 +1285,19 @@ constexpr std::size_t KPageTable::GetRegionSize(KMemoryState state) const { return alias_region_end - alias_region_start; case KMemoryState::Stack: return stack_region_end - stack_region_start; - case KMemoryState::Io: case KMemoryState::Static: case KMemoryState::ThreadLocal: return kernel_map_region_end - kernel_map_region_start; + case KMemoryState::Io: case KMemoryState::Shared: case KMemoryState::AliasCode: case KMemoryState::AliasCodeData: - case KMemoryState::Transferred: - case KMemoryState::SharedTransferred: + case KMemoryState::Transfered: + case KMemoryState::SharedTransfered: case KMemoryState::SharedCode: case KMemoryState::GeneratedCode: case KMemoryState::CodeOut: + case KMemoryState::Coverage: return alias_code_region_end - alias_code_region_start; case KMemoryState::Code: case KMemoryState::CodeData: @@ -1283,15 +1309,18 @@ constexpr std::size_t KPageTable::GetRegionSize(KMemoryState state) const { } bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) const { - const VAddr end{addr + size}; - const VAddr last{end - 1}; - const VAddr region_start{GetRegionAddress(state)}; - const std::size_t region_size{GetRegionSize(state)}; - const bool is_in_region{region_start <= addr && addr < end && - last <= region_start + region_size - 1}; - const bool is_in_heap{!(end <= heap_region_start || heap_region_end <= addr)}; - const bool is_in_alias{!(end <= alias_region_start || alias_region_end <= addr)}; - + const VAddr end = addr + size; + const VAddr last = end - 1; + + const VAddr region_start = this->GetRegionAddress(state); + const size_t region_size = this->GetRegionSize(state); + + const bool is_in_region = + region_start <= addr && addr < end && last <= region_start + region_size - 1; + const bool is_in_heap = !(end <= heap_region_start || heap_region_end <= addr || + heap_region_start == heap_region_end); + const bool is_in_alias = !(end <= alias_region_start || alias_region_end <= addr || + alias_region_start == alias_region_end); switch (state) { case KMemoryState::Free: case KMemoryState::Kernel: @@ -1305,11 +1334,12 @@ bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) co case KMemoryState::AliasCodeData: case KMemoryState::Stack: case KMemoryState::ThreadLocal: - case KMemoryState::Transferred: - case KMemoryState::SharedTransferred: + case KMemoryState::Transfered: + case KMemoryState::SharedTransfered: case KMemoryState::SharedCode: case KMemoryState::GeneratedCode: case KMemoryState::CodeOut: + case KMemoryState::Coverage: return is_in_region && !is_in_heap && !is_in_alias; case KMemoryState::Normal: ASSERT(is_in_heap); @@ -1324,100 +1354,91 @@ bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) co } } -constexpr ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, - KMemoryState state, KMemoryPermission perm_mask, - KMemoryPermission perm, - KMemoryAttribute attr_mask, - KMemoryAttribute attr) const { - // Validate the states match expectation - if ((info.state & state_mask) != state) { - return ResultInvalidCurrentMemory; - } - if ((info.perm & perm_mask) != perm) { - return ResultInvalidCurrentMemory; - } - if ((info.attribute & attr_mask) != attr) { - return ResultInvalidCurrentMemory; - } +ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, + KMemoryState state, KMemoryPermission perm_mask, + KMemoryPermission perm, KMemoryAttribute attr_mask, + KMemoryAttribute attr) const { + // Validate the states match expectation. + R_UNLESS((info.state & state_mask) == state, ResultInvalidCurrentMemory); + R_UNLESS((info.perm & perm_mask) == perm, ResultInvalidCurrentMemory); + R_UNLESS((info.attribute & attr_mask) == attr, ResultInvalidCurrentMemory); return ResultSuccess; } -ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm, - KMemoryAttribute* out_attr, VAddr addr, std::size_t size, - KMemoryState state_mask, KMemoryState state, - KMemoryPermission perm_mask, KMemoryPermission perm, - KMemoryAttribute attr_mask, KMemoryAttribute attr, - KMemoryAttribute ignore_attr) { - std::lock_guard lock{page_table_lock}; +ResultCode KPageTable::CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr, + std::size_t size, KMemoryState state_mask, + KMemoryState state, KMemoryPermission perm_mask, + KMemoryPermission perm, + KMemoryAttribute attr_mask, + KMemoryAttribute attr) const { + ASSERT(this->IsLockedByCurrentThread()); - // Get information about the first block - const VAddr last_addr{addr + size - 1}; - KMemoryBlockManager::const_iterator it{block_manager->FindIterator(addr)}; - KMemoryInfo info{it->GetMemoryInfo()}; + // Get information about the first block. + const VAddr last_addr = addr + size - 1; + KMemoryBlockManager::const_iterator it = block_manager->FindIterator(addr); + KMemoryInfo info = it->GetMemoryInfo(); - // Validate all blocks in the range have correct state - const KMemoryState first_state{info.state}; - const KMemoryPermission first_perm{info.perm}; - const KMemoryAttribute first_attr{info.attribute}; + // If the start address isn't aligned, we need a block. + const size_t blocks_for_start_align = + (Common::AlignDown(addr, PageSize) != info.GetAddress()) ? 1 : 0; while (true) { - // Validate the current block - if (!(info.state == first_state)) { - return ResultInvalidCurrentMemory; - } - if (!(info.perm == first_perm)) { - return ResultInvalidCurrentMemory; - } - if (!((info.attribute | static_cast<KMemoryAttribute>(ignore_attr)) == - (first_attr | static_cast<KMemoryAttribute>(ignore_attr)))) { - return ResultInvalidCurrentMemory; - } - - // Validate against the provided masks - CASCADE_CODE(CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr)); + // Validate against the provided masks. + R_TRY(this->CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr)); - // Break once we're done + // Break once we're done. if (last_addr <= info.GetLastAddress()) { break; } - // Advance our iterator + // Advance our iterator. it++; ASSERT(it != block_manager->cend()); info = it->GetMemoryInfo(); } - // Write output state - if (out_state) { - *out_state = first_state; - } - if (out_perm) { - *out_perm = first_perm; - } - if (out_attr) { - *out_attr = first_attr & static_cast<KMemoryAttribute>(~ignore_attr); + // If the end address isn't aligned, we need a block. + const size_t blocks_for_end_align = + (Common::AlignUp(addr + size, PageSize) != info.GetEndAddress()) ? 1 : 0; + + if (out_blocks_needed != nullptr) { + *out_blocks_needed = blocks_for_start_align + blocks_for_end_align; } return ResultSuccess; } -ResultCode KPageTable::CheckMemoryState(size_t* out_blocks_needed, VAddr addr, size_t size, - KMemoryState state_mask, KMemoryState state, - KMemoryPermission perm_mask, KMemoryPermission perm, - KMemoryAttribute attr_mask, KMemoryAttribute attr) const { +ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm, + KMemoryAttribute* out_attr, std::size_t* out_blocks_needed, + VAddr addr, std::size_t size, KMemoryState state_mask, + KMemoryState state, KMemoryPermission perm_mask, + KMemoryPermission perm, KMemoryAttribute attr_mask, + KMemoryAttribute attr, KMemoryAttribute ignore_attr) const { + ASSERT(this->IsLockedByCurrentThread()); + // Get information about the first block. const VAddr last_addr = addr + size - 1; - KMemoryBlockManager::const_iterator it{block_manager->FindIterator(addr)}; + KMemoryBlockManager::const_iterator it = block_manager->FindIterator(addr); KMemoryInfo info = it->GetMemoryInfo(); // If the start address isn't aligned, we need a block. const size_t blocks_for_start_align = (Common::AlignDown(addr, PageSize) != info.GetAddress()) ? 1 : 0; + // Validate all blocks in the range have correct state. + const KMemoryState first_state = info.state; + const KMemoryPermission first_perm = info.perm; + const KMemoryAttribute first_attr = info.attribute; while (true) { + // Validate the current block. + R_UNLESS(info.state == first_state, ResultInvalidCurrentMemory); + R_UNLESS(info.perm == first_perm, ResultInvalidCurrentMemory); + R_UNLESS((info.attribute | ignore_attr) == (first_attr | ignore_attr), + ResultInvalidCurrentMemory); + // Validate against the provided masks. - R_TRY(CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr)); + R_TRY(this->CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr)); // Break once we're done. if (last_addr <= info.GetLastAddress()) { @@ -1426,6 +1447,7 @@ ResultCode KPageTable::CheckMemoryState(size_t* out_blocks_needed, VAddr addr, s // Advance our iterator. it++; + ASSERT(it != block_manager->cend()); info = it->GetMemoryInfo(); } @@ -1433,10 +1455,19 @@ ResultCode KPageTable::CheckMemoryState(size_t* out_blocks_needed, VAddr addr, s const size_t blocks_for_end_align = (Common::AlignUp(addr + size, PageSize) != info.GetEndAddress()) ? 1 : 0; + // Write output state. + if (out_state != nullptr) { + *out_state = first_state; + } + if (out_perm != nullptr) { + *out_perm = first_perm; + } + if (out_attr != nullptr) { + *out_attr = static_cast<KMemoryAttribute>(first_attr & ~ignore_attr); + } if (out_blocks_needed != nullptr) { *out_blocks_needed = blocks_for_start_align + blocks_for_end_align; } - return ResultSuccess; } diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h index 564410dca..f67986e91 100644 --- 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,13 +43,13 @@ 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); ResultCode SetMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission perm); - ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask, - KMemoryAttribute value); + ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr); ResultCode SetMaxHeapSize(std::size_t size); ResultCode SetHeapSize(VAddr* out, std::size_t size); ResultVal<VAddr> AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align, @@ -102,28 +102,50 @@ private: constexpr VAddr GetRegionAddress(KMemoryState state) const; constexpr std::size_t GetRegionSize(KMemoryState state) const; - constexpr ResultCode CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, + ResultCode CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr, + std::size_t size, KMemoryState state_mask, KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm, KMemoryAttribute attr_mask, KMemoryAttribute attr) const; + ResultCode CheckMemoryStateContiguous(VAddr addr, std::size_t size, KMemoryState state_mask, + KMemoryState state, KMemoryPermission perm_mask, + KMemoryPermission perm, KMemoryAttribute attr_mask, + KMemoryAttribute attr) const { + return this->CheckMemoryStateContiguous(nullptr, addr, size, state_mask, state, perm_mask, + perm, attr_mask, attr); + } + + ResultCode CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, + KMemoryState state, KMemoryPermission perm_mask, + KMemoryPermission perm, KMemoryAttribute attr_mask, + KMemoryAttribute attr) const; ResultCode CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm, - KMemoryAttribute* out_attr, VAddr addr, std::size_t size, + KMemoryAttribute* out_attr, std::size_t* out_blocks_needed, + VAddr addr, std::size_t size, KMemoryState state_mask, + KMemoryState state, KMemoryPermission perm_mask, + KMemoryPermission perm, KMemoryAttribute attr_mask, + KMemoryAttribute attr, + KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const; + ResultCode CheckMemoryState(std::size_t* out_blocks_needed, VAddr addr, std::size_t size, KMemoryState state_mask, KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm, KMemoryAttribute attr_mask, KMemoryAttribute attr, - KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr); - ResultCode CheckMemoryState(VAddr addr, std::size_t size, KMemoryState state_mask, + KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const { + return CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size, + state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr); + } + ResultCode CheckMemoryState(VAddr addr, size_t size, KMemoryState state_mask, KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm, KMemoryAttribute attr_mask, KMemoryAttribute attr, - KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) { - return CheckMemoryState(nullptr, nullptr, nullptr, addr, size, state_mask, state, perm_mask, - perm, attr_mask, attr, ignore_attr); + KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const { + return this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm, + attr_mask, attr, ignore_attr); + } + + bool IsLockedByCurrentThread() const { + return true; } - ResultCode CheckMemoryState(size_t* out_blocks_needed, VAddr addr, size_t size, - KMemoryState state_mask, KMemoryState state, - KMemoryPermission perm_mask, KMemoryPermission perm, - KMemoryAttribute attr_mask, KMemoryAttribute attr) const; std::recursive_mutex page_table_lock; std::unique_ptr<KMemoryBlockManager> block_manager; @@ -281,6 +303,7 @@ private: bool is_aslr_enabled{}; KMemoryManager::Pool memory_pool{KMemoryManager::Pool::Application}; + KMemoryManager::Direction allocation_option{KMemoryManager::Direction::FromFront}; Common::PageTable page_table_impl; diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp index bf98a51e2..265ac6fa1 100644 --- a/src/core/hle/kernel/k_process.cpp +++ b/src/core/hle/kernel/k_process.cpp @@ -149,6 +149,10 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st return ResultSuccess; } +void KProcess::DoWorkerTaskImpl() { + UNIMPLEMENTED(); +} + KResourceLimit* KProcess::GetResourceLimit() const { return resource_limit; } @@ -477,7 +481,7 @@ void KProcess::Finalize() { } // Perform inherited finalization. - KAutoObjectWithSlabHeapAndContainer<KProcess, KSynchronizationObject>::Finalize(); + KAutoObjectWithSlabHeapAndContainer<KProcess, KWorkerTask>::Finalize(); } /** @@ -509,7 +513,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 +545,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 +591,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/k_process.h b/src/core/hle/kernel/k_process.h index e7c8b5838..c2a672021 100644 --- a/src/core/hle/kernel/k_process.h +++ b/src/core/hle/kernel/k_process.h @@ -15,6 +15,7 @@ #include "core/hle/kernel/k_condition_variable.h" #include "core/hle/kernel/k_handle_table.h" #include "core/hle/kernel/k_synchronization_object.h" +#include "core/hle/kernel/k_worker_task.h" #include "core/hle/kernel/process_capability.h" #include "core/hle/kernel/slab_helpers.h" #include "core/hle/result.h" @@ -62,8 +63,7 @@ enum class ProcessStatus { DebugBreak, }; -class KProcess final - : public KAutoObjectWithSlabHeapAndContainer<KProcess, KSynchronizationObject> { +class KProcess final : public KAutoObjectWithSlabHeapAndContainer<KProcess, KWorkerTask> { KERNEL_AUTOOBJECT_TRAITS(KProcess, KSynchronizationObject); public: @@ -345,6 +345,8 @@ public: bool IsSignaled() const override; + void DoWorkerTaskImpl(); + void PinCurrentThread(s32 core_id); void UnpinCurrentThread(s32 core_id); void UnpinThread(KThread* thread); diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp index 31cec990e..f900b2e7a 100644 --- a/src/core/hle/kernel/k_scheduler.cpp +++ b/src/core/hle/kernel/k_scheduler.cpp @@ -49,8 +49,6 @@ void KScheduler::RescheduleCores(KernelCore& kernel, u64 cores_pending_reschedul if (!must_context_switch || core != current_core) { auto& phys_core = kernel.PhysicalCore(core); phys_core.Interrupt(); - } else { - must_context_switch = true; } cores_pending_reschedule &= ~(1ULL << core); } diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp index 71e029a3f..7a5e6fc08 100644 --- a/src/core/hle/kernel/k_thread.cpp +++ b/src/core/hle/kernel/k_thread.cpp @@ -30,6 +30,7 @@ #include "core/hle/kernel/k_system_control.h" #include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/k_thread_queue.h" +#include "core/hle/kernel/k_worker_task_manager.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/svc_results.h" #include "core/hle/kernel/time_manager.h" @@ -332,7 +333,7 @@ void KThread::Finalize() { } // Perform inherited finalization. - KAutoObjectWithSlabHeapAndContainer<KThread, KSynchronizationObject>::Finalize(); + KSynchronizationObject::Finalize(); } bool KThread::IsSignaled() const { @@ -376,11 +377,28 @@ void KThread::StartTermination() { // Register terminated dpc flag. RegisterDpc(DpcFlag::Terminated); +} + +void KThread::FinishTermination() { + // Ensure that the thread is not executing on any core. + if (parent != nullptr) { + for (std::size_t i = 0; i < static_cast<std::size_t>(Core::Hardware::NUM_CPU_CORES); ++i) { + KThread* core_thread{}; + do { + core_thread = kernel.Scheduler(i).GetCurrentThread(); + } while (core_thread == this); + } + } // Close the thread. this->Close(); } +void KThread::DoWorkerTaskImpl() { + // Finish the termination that was begun by Exit(). + this->FinishTermination(); +} + void KThread::Pin(s32 current_core) { ASSERT(kernel.GlobalSchedulerContext().IsLocked()); @@ -417,12 +435,7 @@ void KThread::Pin(s32 current_core) { static_cast<u32>(ThreadState::SuspendShift))); // Update our state. - const ThreadState old_state = thread_state; - thread_state = static_cast<ThreadState>(GetSuspendFlags() | - static_cast<u32>(old_state & ThreadState::Mask)); - if (thread_state != old_state) { - KScheduler::OnThreadStateChanged(kernel, this, old_state); - } + UpdateState(); } // TODO(bunnei): Update our SVC access permissions. @@ -463,20 +476,13 @@ void KThread::Unpin() { } // Allow performing thread suspension (if termination hasn't been requested). - { + if (!IsTerminationRequested()) { // Update our allow flags. - if (!IsTerminationRequested()) { - suspend_allowed_flags |= (1 << (static_cast<u32>(SuspendType::Thread) + - static_cast<u32>(ThreadState::SuspendShift))); - } + suspend_allowed_flags |= (1 << (static_cast<u32>(SuspendType::Thread) + + static_cast<u32>(ThreadState::SuspendShift))); // Update our state. - const ThreadState old_state = thread_state; - thread_state = static_cast<ThreadState>(GetSuspendFlags() | - static_cast<u32>(old_state & ThreadState::Mask)); - if (thread_state != old_state) { - KScheduler::OnThreadStateChanged(kernel, this, old_state); - } + UpdateState(); } // TODO(bunnei): Update our SVC access permissions. @@ -689,12 +695,7 @@ void KThread::Resume(SuspendType type) { ~(1u << (static_cast<u32>(ThreadState::SuspendShift) + static_cast<u32>(type))); // Update our state. - const ThreadState old_state = thread_state; - thread_state = static_cast<ThreadState>(GetSuspendFlags() | - static_cast<u32>(old_state & ThreadState::Mask)); - if (thread_state != old_state) { - KScheduler::OnThreadStateChanged(kernel, this, old_state); - } + this->UpdateState(); } void KThread::WaitCancel() { @@ -721,19 +722,22 @@ void KThread::TrySuspend() { ASSERT(GetNumKernelWaiters() == 0); // Perform the suspend. - Suspend(); + this->UpdateState(); } -void KThread::Suspend() { +void KThread::UpdateState() { ASSERT(kernel.GlobalSchedulerContext().IsLocked()); - ASSERT(IsSuspendRequested()); // Set our suspend flags in state. const auto old_state = thread_state; - thread_state = static_cast<ThreadState>(GetSuspendFlags()) | (old_state & ThreadState::Mask); + const auto new_state = + static_cast<ThreadState>(this->GetSuspendFlags()) | (old_state & ThreadState::Mask); + thread_state = new_state; // Note the state change in scheduler. - KScheduler::OnThreadStateChanged(kernel, this, old_state); + if (new_state != old_state) { + KScheduler::OnThreadStateChanged(kernel, this, old_state); + } } void KThread::Continue() { @@ -998,13 +1002,16 @@ ResultCode KThread::Run() { // If the current thread has been asked to suspend, suspend it and retry. if (GetCurrentThread(kernel).IsSuspended()) { - GetCurrentThread(kernel).Suspend(); + GetCurrentThread(kernel).UpdateState(); continue; } // If we're not a kernel thread and we've been asked to suspend, suspend ourselves. - if (IsUserThread() && IsSuspended()) { - Suspend(); + if (KProcess* owner = this->GetOwnerProcess(); owner != nullptr) { + if (IsUserThread() && IsSuspended()) { + this->UpdateState(); + } + owner->IncrementThreadCount(); } // Set our state and finish. @@ -1031,9 +1038,16 @@ void KThread::Exit() { // Disallow all suspension. suspend_allowed_flags = 0; + this->UpdateState(); + + // Disallow all suspension. + suspend_allowed_flags = 0; // Start termination. StartTermination(); + + // Register the thread as a work task. + KWorkerTaskManager::AddTask(kernel, KWorkerTaskManager::WorkerType::Exit, this); } } diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h index 83dfde69b..cc427f6cf 100644 --- a/src/core/hle/kernel/k_thread.h +++ b/src/core/hle/kernel/k_thread.h @@ -19,6 +19,7 @@ #include "core/hle/kernel/k_light_lock.h" #include "core/hle/kernel/k_spin_lock.h" #include "core/hle/kernel/k_synchronization_object.h" +#include "core/hle/kernel/k_worker_task.h" #include "core/hle/kernel/slab_helpers.h" #include "core/hle/kernel/svc_common.h" #include "core/hle/kernel/svc_types.h" @@ -100,7 +101,7 @@ enum class ThreadWaitReasonForDebugging : u32 { [[nodiscard]] KThread& GetCurrentThread(KernelCore& kernel); [[nodiscard]] s32 GetCurrentCoreId(KernelCore& kernel); -class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KSynchronizationObject>, +class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KWorkerTask>, public boost::intrusive::list_base_hook<> { KERNEL_AUTOOBJECT_TRAITS(KThread, KSynchronizationObject); @@ -192,9 +193,9 @@ public: void TrySuspend(); - void Continue(); + void UpdateState(); - void Suspend(); + void Continue(); constexpr void SetSyncedIndex(s32 index) { synced_index = index; @@ -385,6 +386,8 @@ public: void OnTimer(); + void DoWorkerTaskImpl(); + static void PostDestroy(uintptr_t arg); [[nodiscard]] static ResultCode InitializeDummyThread(KThread* thread); @@ -679,6 +682,8 @@ private: void StartTermination(); + void FinishTermination(); + [[nodiscard]] ResultCode Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stack_top, s32 prio, s32 virt_core, KProcess* owner, ThreadType type); diff --git a/src/core/hle/kernel/k_worker_task.h b/src/core/hle/kernel/k_worker_task.h new file mode 100644 index 000000000..b7794c6a8 --- /dev/null +++ b/src/core/hle/kernel/k_worker_task.h @@ -0,0 +1,18 @@ +// Copyright 2022 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "core/hle/kernel/k_synchronization_object.h" + +namespace Kernel { + +class KWorkerTask : public KSynchronizationObject { +public: + explicit KWorkerTask(KernelCore& kernel_); + + void DoWorkerTask(); +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_worker_task_manager.cpp b/src/core/hle/kernel/k_worker_task_manager.cpp new file mode 100644 index 000000000..785e08111 --- /dev/null +++ b/src/core/hle/kernel/k_worker_task_manager.cpp @@ -0,0 +1,42 @@ +// Copyright 2022 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include "common/assert.h" +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_thread.h" +#include "core/hle/kernel/k_worker_task.h" +#include "core/hle/kernel/k_worker_task_manager.h" +#include "core/hle/kernel/kernel.h" + +namespace Kernel { + +KWorkerTask::KWorkerTask(KernelCore& kernel_) : KSynchronizationObject{kernel_} {} + +void KWorkerTask::DoWorkerTask() { + if (auto* const thread = this->DynamicCast<KThread*>(); thread != nullptr) { + return thread->DoWorkerTaskImpl(); + } else { + auto* const process = this->DynamicCast<KProcess*>(); + ASSERT(process != nullptr); + + return process->DoWorkerTaskImpl(); + } +} + +KWorkerTaskManager::KWorkerTaskManager() : m_waiting_thread(1, "yuzu:KWorkerTaskManager") {} + +void KWorkerTaskManager::AddTask(KernelCore& kernel, WorkerType type, KWorkerTask* task) { + ASSERT(type <= WorkerType::Count); + kernel.WorkerTaskManager().AddTask(kernel, task); +} + +void KWorkerTaskManager::AddTask(KernelCore& kernel, KWorkerTask* task) { + KScopedSchedulerLock sl(kernel); + m_waiting_thread.QueueWork([task]() { + // Do the task. + task->DoWorkerTask(); + }); +} + +} // namespace Kernel diff --git a/src/core/hle/kernel/k_worker_task_manager.h b/src/core/hle/kernel/k_worker_task_manager.h new file mode 100644 index 000000000..43d1bfcec --- /dev/null +++ b/src/core/hle/kernel/k_worker_task_manager.h @@ -0,0 +1,33 @@ +// Copyright 2022 yuzu Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" +#include "common/thread_worker.h" + +namespace Kernel { + +class KernelCore; +class KWorkerTask; + +class KWorkerTaskManager final { +public: + enum class WorkerType : u32 { + Exit, + Count, + }; + + KWorkerTaskManager(); + + static void AddTask(KernelCore& kernel_, WorkerType type, KWorkerTask* task); + +private: + void AddTask(KernelCore& kernel, KWorkerTask* task); + +private: + Common::ThreadWorker m_waiting_thread; +}; + +} // namespace Kernel diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 1225e1fba..887c1fd27 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -37,6 +37,7 @@ #include "core/hle/kernel/k_shared_memory.h" #include "core/hle/kernel/k_slab_heap.h" #include "core/hle/kernel/k_thread.h" +#include "core/hle/kernel/k_worker_task_manager.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/physical_core.h" #include "core/hle/kernel/service_thread.h" @@ -51,7 +52,8 @@ namespace Kernel { struct KernelCore::Impl { explicit Impl(Core::System& system_, KernelCore& kernel_) - : time_manager{system_}, object_list_container{kernel_}, system{system_} {} + : time_manager{system_}, object_list_container{kernel_}, + service_threads_manager{1, "yuzu:ServiceThreadsManager"}, system{system_} {} void SetMulticore(bool is_multi) { is_multicore = is_multi; @@ -121,7 +123,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; @@ -629,7 +631,7 @@ struct KernelCore::Impl { const auto application_pool = memory_layout.GetKernelApplicationPoolRegionPhysicalExtents(); // Initialize memory managers - memory_manager = std::make_unique<KMemoryManager>(); + memory_manager = std::make_unique<KMemoryManager>(system); memory_manager->InitializeManager(KMemoryManager::Pool::Application, application_pool.GetAddress(), application_pool.GetEndAddress()); @@ -704,6 +706,27 @@ struct KernelCore::Impl { return port; } + std::weak_ptr<Kernel::ServiceThread> CreateServiceThread(KernelCore& kernel, + const std::string& name) { + auto service_thread = std::make_shared<Kernel::ServiceThread>(kernel, 1, name); + + service_threads_manager.QueueWork( + [this, service_thread]() { service_threads.emplace(service_thread); }); + + return service_thread; + } + + void ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread) { + if (auto strong_ptr = service_thread.lock()) { + service_threads_manager.QueueWork( + [this, strong_ptr{std::move(strong_ptr)}]() { service_threads.erase(strong_ptr); }); + } + } + + void ClearServiceThreads() { + service_threads_manager.QueueWork([this]() { service_threads.clear(); }); + } + std::mutex server_ports_lock; std::mutex server_sessions_lock; std::mutex registered_objects_lock; @@ -759,6 +782,7 @@ struct KernelCore::Impl { // Threads used for services std::unordered_set<std::shared_ptr<Kernel::ServiceThread>> service_threads; + Common::ThreadWorker service_threads_manager; std::array<KThread*, Core::Hardware::NUM_CPU_CORES> suspend_threads; std::array<Core::CPUInterruptHandler, Core::Hardware::NUM_CPU_CORES> interrupts{}; @@ -774,6 +798,8 @@ struct KernelCore::Impl { std::array<u64, Core::Hardware::NUM_CPU_CORES> svc_ticks{}; + KWorkerTaskManager worker_task_manager; + // System context Core::System& system; }; @@ -1099,15 +1125,11 @@ void KernelCore::ExitSVCProfile() { } std::weak_ptr<Kernel::ServiceThread> KernelCore::CreateServiceThread(const std::string& name) { - auto service_thread = std::make_shared<Kernel::ServiceThread>(*this, 1, name); - impl->service_threads.emplace(service_thread); - return service_thread; + return impl->CreateServiceThread(*this, name); } void KernelCore::ReleaseServiceThread(std::weak_ptr<Kernel::ServiceThread> service_thread) { - if (auto strong_ptr = service_thread.lock()) { - impl->service_threads.erase(strong_ptr); - } + impl->ReleaseServiceThread(service_thread); } Init::KSlabResourceCounts& KernelCore::SlabResourceCounts() { @@ -1118,6 +1140,14 @@ const Init::KSlabResourceCounts& KernelCore::SlabResourceCounts() const { return impl->slab_resource_counts; } +KWorkerTaskManager& KernelCore::WorkerTaskManager() { + return impl->worker_task_manager; +} + +const KWorkerTaskManager& KernelCore::WorkerTaskManager() const { + return impl->worker_task_manager; +} + bool KernelCore::IsPhantomModeForSingleCore() const { return impl->IsPhantomModeForSingleCore(); } diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index b9b423908..0e04fc3bb 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -52,6 +52,7 @@ class KSharedMemory; class KSharedMemoryInfo; class KThread; class KTransferMemory; +class KWorkerTaskManager; class KWritableEvent; class KCodeMemory; class PhysicalCore; @@ -343,6 +344,12 @@ public: /// Gets the current slab resource counts. const Init::KSlabResourceCounts& SlabResourceCounts() const; + /// Gets the current worker task manager, used for dispatching KThread/KProcess tasks. + KWorkerTaskManager& WorkerTaskManager(); + + /// Gets the current worker task manager, used for dispatching KThread/KProcess tasks. + const KWorkerTaskManager& WorkerTaskManager() const; + private: friend class KProcess; friend class KThread; diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp index 7f02d9471..7477668e4 100644 --- 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<Common::SpinLock>()} {} + interrupts{interrupts_}, guard{std::make_unique<Common::SpinLock>()} { +#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<Core::ARM_Dynarmic_64>( + 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<Core::ARM_Dynarmic_64>( - 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<Core::ARM_Dynarmic_32>( 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 250ef9042..c7f5140f4 100644 --- a/src/core/hle/kernel/svc.cpp +++ b/src/core/hle/kernel/svc.cpp @@ -168,6 +168,9 @@ constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) { static ResultCode SetMemoryPermission(Core::System& system, VAddr address, u64 size, MemoryPermission perm) { + LOG_DEBUG(Kernel_SVC, "called, address=0x{:016X}, size=0x{:X}, perm=0x{:08X", address, size, + perm); + // Validate address / size. R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress); R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize); @@ -186,46 +189,33 @@ static ResultCode SetMemoryPermission(Core::System& system, VAddr address, u64 s } static ResultCode SetMemoryAttribute(Core::System& system, VAddr address, u64 size, u32 mask, - u32 attribute) { + u32 attr) { LOG_DEBUG(Kernel_SVC, "called, address=0x{:016X}, size=0x{:X}, mask=0x{:08X}, attribute=0x{:08X}", address, - size, mask, attribute); - - if (!Common::Is4KBAligned(address)) { - LOG_ERROR(Kernel_SVC, "Address not page aligned (0x{:016X})", address); - return ResultInvalidAddress; - } + size, mask, attr); - if (size == 0 || !Common::Is4KBAligned(size)) { - LOG_ERROR(Kernel_SVC, "Invalid size (0x{:X}). Size must be non-zero and page aligned.", - size); - return ResultInvalidAddress; - } - - if (!IsValidAddressRange(address, size)) { - LOG_ERROR(Kernel_SVC, "Address range overflowed (Address: 0x{:016X}, Size: 0x{:016X})", - address, size); - return ResultInvalidCurrentMemory; - } + // Validate address / size. + R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress); + R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize); + R_UNLESS(size > 0, ResultInvalidSize); + R_UNLESS((address < address + size), ResultInvalidCurrentMemory); - const auto attributes{static_cast<MemoryAttribute>(mask | attribute)}; - if (attributes != static_cast<MemoryAttribute>(mask) || - (attributes | MemoryAttribute::Uncached) != MemoryAttribute::Uncached) { - LOG_ERROR(Kernel_SVC, - "Memory attribute doesn't match the given mask (Attribute: 0x{:X}, Mask: {:X}", - attribute, mask); - return ResultInvalidCombination; - } + // Validate the attribute and mask. + constexpr u32 SupportedMask = static_cast<u32>(MemoryAttribute::Uncached); + R_UNLESS((mask | attr) == mask, ResultInvalidCombination); + R_UNLESS((mask | attr | SupportedMask) == SupportedMask, ResultInvalidCombination); + // Validate that the region is in range for the current process. auto& page_table{system.Kernel().CurrentProcess()->PageTable()}; + R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory); - return page_table.SetMemoryAttribute(address, size, static_cast<KMemoryAttribute>(mask), - static_cast<KMemoryAttribute>(attribute)); + // Set the memory attribute. + return page_table.SetMemoryAttribute(address, size, mask, attr); } static ResultCode SetMemoryAttribute32(Core::System& system, u32 address, u32 size, u32 mask, - u32 attribute) { - return SetMemoryAttribute(system, address, size, mask, attribute); + u32 attr) { + return SetMemoryAttribute(system, address, size, mask, attr); } /// Maps a memory range into a different range. @@ -1319,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<uintptr_t>(address), ResultInvalidCurrentMemory); + R_UNLESS(size == static_cast<size_t>(size), ResultInvalidCurrentMemory); // Validate the memory permission. R_UNLESS(IsValidProcessMemoryPermission(perm), ResultInvalidNewMemoryPermission); @@ -1333,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, @@ -1636,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, @@ -1704,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/kernel/svc_types.h b/src/core/hle/kernel/svc_types.h index ec463b97c..365e22e4e 100644 --- a/src/core/hle/kernel/svc_types.h +++ b/src/core/hle/kernel/svc_types.h @@ -32,6 +32,7 @@ enum class MemoryState : u32 { Kernel = 0x13, GeneratedCode = 0x14, CodeOut = 0x15, + Coverage = 0x16, }; DECLARE_ENUM_FLAG_OPERATORS(MemoryState); diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp index 6e12381fb..a2bf7defb 100644 --- a/src/core/hle/service/hid/hid.cpp +++ b/src/core/hle/service/hid/hid.cpp @@ -37,7 +37,8 @@ namespace Service::HID { // Period time is obtained by measuring the number of samples in a second on HW using a homebrew constexpr auto pad_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000}; // (4ms, 250Hz) constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz) -constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000}; // (5ms, 200Hz) +// TODO: Correct update rate for motion is 5ms. Check why some games don't behave at that speed +constexpr auto motion_update_ns = std::chrono::nanoseconds{10 * 1000 * 1000}; // (10ms, 100Hz) constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000; IAppletResource::IAppletResource(Core::System& system_, @@ -1175,7 +1176,8 @@ void Hid::SetNpadAnalogStickUseCenterClamp(Kernel::HLERequestContext& ctx) { const auto parameters{rp.PopRaw<Parameters>()}; - applet_resource->GetController<Controller_NPad>(HidController::NPad) + GetAppletResource() + ->GetController<Controller_NPad>(HidController::NPad) .SetAnalogStickUseCenterClamp(parameters.analog_stick_use_center_clamp); LOG_WARNING(Service_HID, diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp index 3782703d2..9fc7bb1b1 100644 --- 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/input_common/drivers/mouse.cpp b/src/input_common/drivers/mouse.cpp index aa69216c8..d8ae7f0c1 100644 --- a/src/input_common/drivers/mouse.cpp +++ b/src/input_common/drivers/mouse.cpp @@ -16,6 +16,7 @@ constexpr int mouse_axis_x = 0; constexpr int mouse_axis_y = 1; constexpr int wheel_axis_x = 2; constexpr int wheel_axis_y = 3; +constexpr int motion_wheel_y = 4; constexpr int touch_axis_x = 10; constexpr int touch_axis_y = 11; constexpr PadIdentifier identifier = { @@ -30,8 +31,9 @@ Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_)) PreSetAxis(identifier, mouse_axis_y); PreSetAxis(identifier, wheel_axis_x); PreSetAxis(identifier, wheel_axis_y); + PreSetAxis(identifier, motion_wheel_y); PreSetAxis(identifier, touch_axis_x); - PreSetAxis(identifier, touch_axis_x); + PreSetAxis(identifier, touch_axis_y); update_thread = std::jthread([this](std::stop_token stop_token) { UpdateThread(stop_token); }); } @@ -48,6 +50,8 @@ void Mouse::UpdateThread(std::stop_token stop_token) { SetAxis(identifier, mouse_axis_y, -last_mouse_change.y * sensitivity); } + SetAxis(identifier, motion_wheel_y, 0.0f); + if (mouse_panning_timout++ > 20) { StopPanning(); } @@ -136,6 +140,7 @@ void Mouse::MouseWheelChange(int x, int y) { wheel_position.y += y; SetAxis(identifier, wheel_axis_x, static_cast<f32>(wheel_position.x)); SetAxis(identifier, wheel_axis_y, static_cast<f32>(wheel_position.y)); + SetAxis(identifier, motion_wheel_y, static_cast<f32>(y) / 100.0f); } void Mouse::ReleaseAllButtons() { @@ -171,13 +176,39 @@ AnalogMapping Mouse::GetAnalogMappingForDevice( return mapping; } +Common::Input::ButtonNames Mouse::GetUIButtonName(const Common::ParamPackage& params) const { + const auto button = static_cast<MouseButton>(params.Get("button", 0)); + switch (button) { + case MouseButton::Left: + return Common::Input::ButtonNames::ButtonLeft; + case MouseButton::Right: + return Common::Input::ButtonNames::ButtonRight; + case MouseButton::Wheel: + return Common::Input::ButtonNames::ButtonMouseWheel; + case MouseButton::Backward: + return Common::Input::ButtonNames::ButtonBackward; + case MouseButton::Forward: + return Common::Input::ButtonNames::ButtonForward; + case MouseButton::Task: + return Common::Input::ButtonNames::ButtonTask; + case MouseButton::Extra: + return Common::Input::ButtonNames::ButtonExtra; + case MouseButton::Undefined: + default: + return Common::Input::ButtonNames::Undefined; + } +} + Common::Input::ButtonNames Mouse::GetUIName(const Common::ParamPackage& params) const { if (params.Has("button")) { - return Common::Input::ButtonNames::Value; + return GetUIButtonName(params); } if (params.Has("axis")) { return Common::Input::ButtonNames::Value; } + if (params.Has("axis_x") && params.Has("axis_y") && params.Has("axis_z")) { + return Common::Input::ButtonNames::Engine; + } return Common::Input::ButtonNames::Invalid; } diff --git a/src/input_common/drivers/mouse.h b/src/input_common/drivers/mouse.h index 040446178..c5833b8ed 100644 --- a/src/input_common/drivers/mouse.h +++ b/src/input_common/drivers/mouse.h @@ -69,6 +69,8 @@ private: void UpdateThread(std::stop_token stop_token); void StopPanning(); + Common::Input::ButtonNames GetUIButtonName(const Common::ParamPackage& params) const; + Common::Vec2<int> mouse_origin; Common::Vec2<int> last_mouse_position; Common::Vec2<float> last_mouse_change; diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp index 0cda9df62..ed6281772 100644 --- a/src/input_common/drivers/sdl_driver.cpp +++ b/src/input_common/drivers/sdl_driver.cpp @@ -198,9 +198,15 @@ public: if (sdl_controller) { switch (SDL_GameControllerGetType(sdl_controller.get())) { case SDL_CONTROLLER_TYPE_XBOX360: - return "XBox 360 Controller"; + return "Xbox 360 Controller"; case SDL_CONTROLLER_TYPE_XBOXONE: - return "XBox One Controller"; + return "Xbox One Controller"; + case SDL_CONTROLLER_TYPE_PS3: + return "DualShock 3 Controller"; + case SDL_CONTROLLER_TYPE_PS4: + return "DualShock 4 Controller"; + case SDL_CONTROLLER_TYPE_PS5: + return "DualSense Controller"; default: break; } @@ -663,6 +669,7 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding() const { {Settings::NativeButton::SL, SDL_CONTROLLER_BUTTON_LEFTSHOULDER}, {Settings::NativeButton::SR, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER}, {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE}, + {Settings::NativeButton::Screenshot, SDL_CONTROLLER_BUTTON_MISC1}, }; } @@ -699,6 +706,7 @@ ButtonBindings SDLDriver::GetNintendoButtonBinding( {Settings::NativeButton::SL, sl_button}, {Settings::NativeButton::SR, sr_button}, {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE}, + {Settings::NativeButton::Screenshot, SDL_CONTROLLER_BUTTON_MISC1}, }; } diff --git a/src/input_common/drivers/sdl_driver.h b/src/input_common/drivers/sdl_driver.h index e9a5d2e26..4cde3606f 100644 --- a/src/input_common/drivers/sdl_driver.h +++ b/src/input_common/drivers/sdl_driver.h @@ -24,7 +24,7 @@ namespace InputCommon { class SDLJoystick; using ButtonBindings = - std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 17>; + std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 18>; using ZButtonBindings = std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerAxis>, 2>; diff --git a/src/input_common/drivers/tas_input.cpp b/src/input_common/drivers/tas_input.cpp index d78228b50..944e141bf 100644 --- a/src/input_common/drivers/tas_input.cpp +++ b/src/input_common/drivers/tas_input.cpp @@ -23,7 +23,7 @@ enum class Tas::TasAxis : u8 { }; // Supported keywords and buttons from a TAS file -constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_button = { +constexpr std::array<std::pair<std::string_view, TasButton>, 18> text_to_tas_button = { std::pair{"KEY_A", TasButton::BUTTON_A}, {"KEY_B", TasButton::BUTTON_B}, {"KEY_X", TasButton::BUTTON_X}, @@ -40,8 +40,9 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_but {"KEY_DDOWN", TasButton::BUTTON_DOWN}, {"KEY_SL", TasButton::BUTTON_SL}, {"KEY_SR", TasButton::BUTTON_SR}, - {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE}, - {"KEY_HOME", TasButton::BUTTON_HOME}, + // These buttons are disabled to avoid TAS input from activating hotkeys + // {"KEY_CAPTURE", TasButton::BUTTON_CAPTURE}, + // {"KEY_HOME", TasButton::BUTTON_HOME}, {"KEY_ZL", TasButton::TRIGGER_ZL}, {"KEY_ZR", TasButton::TRIGGER_ZR}, }; diff --git a/src/input_common/input_engine.cpp b/src/input_common/input_engine.cpp index b57330e51..0508b408d 100644 --- a/src/input_common/input_engine.cpp +++ b/src/input_common/input_engine.cpp @@ -173,7 +173,7 @@ void InputEngine::ResetButtonState() { SetButton(controller.first, button.first, false); } for (const auto& button : controller.second.hat_buttons) { - SetHatButton(controller.first, button.first, false); + SetHatButton(controller.first, button.first, 0); } } } diff --git a/src/input_common/input_mapping.cpp b/src/input_common/input_mapping.cpp index 6e0024b2d..475257f42 100644 --- a/src/input_common/input_mapping.cpp +++ b/src/input_common/input_mapping.cpp @@ -143,6 +143,19 @@ void MappingFactory::RegisterMotion(const MappingData& data) { } new_input.Set("port", static_cast<int>(data.pad.port)); new_input.Set("pad", static_cast<int>(data.pad.pad)); + + // If engine is mouse map the mouse position as 3 axis motion + if (data.engine == "mouse") { + new_input.Set("axis_x", 1); + new_input.Set("invert_x", "-"); + new_input.Set("axis_y", 0); + new_input.Set("axis_z", 4); + new_input.Set("range", 1.0f); + new_input.Set("deadzone", 0.0f); + input_queue.Push(new_input); + return; + } + switch (data.type) { case EngineInputType::Button: case EngineInputType::HatButton: diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt index 4a20c0768..a69ccb264 100644 --- 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) diff --git a/src/video_core/command_classes/codecs/codec.h b/src/video_core/command_classes/codecs/codec.h index 13ed88382..de5672155 100644 --- a/src/video_core/command_classes/codecs/codec.h +++ b/src/video_core/command_classes/codecs/codec.h @@ -66,7 +66,7 @@ private: bool initialized{}; NvdecCommon::VideoCodec current_codec{NvdecCommon::VideoCodec::None}; - AVCodec* av_codec{nullptr}; + const AVCodec* av_codec{nullptr}; AVCodecContext* av_codec_ctx{nullptr}; AVBufferRef* av_gpu_decoder{nullptr}; diff --git a/src/video_core/host_shaders/astc_decoder.comp b/src/video_core/host_shaders/astc_decoder.comp index f34c5f5d9..3a10578cb 100644 --- a/src/video_core/host_shaders/astc_decoder.comp +++ b/src/video_core/host_shaders/astc_decoder.comp @@ -155,9 +155,6 @@ uint SwizzleOffset(uvec2 pos) { // Replicates low num_bits such that [(to_bit - 1):(to_bit - 1 - from_bit)] // is the same as [(num_bits - 1):0] and repeats all the way down. uint Replicate(uint val, uint num_bits, uint to_bit) { - if (num_bits == 0 || to_bit == 0) { - return 0; - } const uint v = val & uint((1 << num_bits) - 1); uint res = v; uint reslen = num_bits; @@ -187,42 +184,57 @@ uint ReplicateBitTo9(uint value) { return REPLICATE_1_BIT_TO_9_TABLE[value]; } -uint FastReplicateTo8(uint value, uint num_bits) { - switch (num_bits) { - case 1: - return REPLICATE_1_BIT_TO_8_TABLE[value]; - case 2: - return REPLICATE_2_BIT_TO_8_TABLE[value]; - case 3: - return REPLICATE_3_BIT_TO_8_TABLE[value]; - case 4: - return REPLICATE_4_BIT_TO_8_TABLE[value]; - case 5: - return REPLICATE_5_BIT_TO_8_TABLE[value]; - case 6: - return REPLICATE_6_BIT_TO_8_TABLE[value]; - case 7: - return REPLICATE_7_BIT_TO_8_TABLE[value]; - case 8: +uint FastReplicate(uint value, uint num_bits, uint to_bit) { + if (num_bits == 0) { + return 0; + } + if (num_bits == to_bit) { return value; } - return Replicate(value, num_bits, 8); + if (to_bit == 6) { + switch (num_bits) { + case 1: + return REPLICATE_1_BIT_TO_6_TABLE[value]; + case 2: + return REPLICATE_2_BIT_TO_6_TABLE[value]; + case 3: + return REPLICATE_3_BIT_TO_6_TABLE[value]; + case 4: + return REPLICATE_4_BIT_TO_6_TABLE[value]; + case 5: + return REPLICATE_5_BIT_TO_6_TABLE[value]; + default: + break; + } + } else { /* if (to_bit == 8) */ + switch (num_bits) { + case 1: + return REPLICATE_1_BIT_TO_8_TABLE[value]; + case 2: + return REPLICATE_2_BIT_TO_8_TABLE[value]; + case 3: + return REPLICATE_3_BIT_TO_8_TABLE[value]; + case 4: + return REPLICATE_4_BIT_TO_8_TABLE[value]; + case 5: + return REPLICATE_5_BIT_TO_8_TABLE[value]; + case 6: + return REPLICATE_6_BIT_TO_8_TABLE[value]; + case 7: + return REPLICATE_7_BIT_TO_8_TABLE[value]; + default: + break; + } + } + return Replicate(value, num_bits, to_bit); +} + +uint FastReplicateTo8(uint value, uint num_bits) { + return FastReplicate(value, num_bits, 8); } uint FastReplicateTo6(uint value, uint num_bits) { - switch (num_bits) { - case 1: - return REPLICATE_1_BIT_TO_6_TABLE[value]; - case 2: - return REPLICATE_2_BIT_TO_6_TABLE[value]; - case 3: - return REPLICATE_3_BIT_TO_6_TABLE[value]; - case 4: - return REPLICATE_4_BIT_TO_6_TABLE[value]; - case 5: - return REPLICATE_5_BIT_TO_6_TABLE[value]; - } - return Replicate(value, num_bits, 6); + return FastReplicate(value, num_bits, 6); } uint Div3Floor(uint v) { diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp index 3d78efddc..153702c0b 100644 --- a/src/video_core/vulkan_common/vulkan_device.cpp +++ b/src/video_core/vulkan_common/vulkan_device.cpp @@ -1038,7 +1038,7 @@ std::vector<const char*> Device::LoadExtensions(bool requires_surface) { } if (has_ext_shader_atomic_int64) { VkPhysicalDeviceShaderAtomicInt64Features atomic_int64; - atomic_int64.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + atomic_int64.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; atomic_int64.pNext = nullptr; features.pNext = &atomic_int64; physical.GetFeatures2KHR(features); diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp index 0f679c37e..33d50667a 100644 --- a/src/yuzu/configuration/config.cpp +++ b/src/yuzu/configuration/config.cpp @@ -66,27 +66,27 @@ const std::array<int, 2> Config::default_stick_mod = { // UISetting::values.shortcuts, which is alphabetically ordered. // clang-format off const std::array<UISettings::Shortcut, 21> Config::default_hotkeys{{ - {QStringLiteral("Capture Screenshot"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"), Qt::WidgetWithChildrenShortcut}}, - {QStringLiteral("Change Docked Mode"), QStringLiteral("Main Window"), {QStringLiteral("F10"), Qt::ApplicationShortcut}}, - {QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"), Qt::WindowShortcut}}, - {QStringLiteral("Decrease Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("-"), Qt::ApplicationShortcut}}, - {QStringLiteral("Exit Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("Esc"), Qt::WindowShortcut}}, - {QStringLiteral("Exit yuzu"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"), Qt::WindowShortcut}}, - {QStringLiteral("Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("F11"), Qt::WindowShortcut}}, - {QStringLiteral("Increase Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("+"), Qt::ApplicationShortcut}}, - {QStringLiteral("Load Amiibo"), QStringLiteral("Main Window"), {QStringLiteral("F2"), Qt::WidgetWithChildrenShortcut}}, - {QStringLiteral("Load File"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"), Qt::WidgetWithChildrenShortcut}}, - {QStringLiteral("Mute Audio"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+M"), Qt::WindowShortcut}}, - {QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), Qt::WindowShortcut}}, - {QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), Qt::WindowShortcut}}, - {QStringLiteral("TAS Start/Stop"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F5"), Qt::ApplicationShortcut}}, - {QStringLiteral("TAS Reset"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F6"), Qt::ApplicationShortcut}}, - {QStringLiteral("TAS Record"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F7"), Qt::ApplicationShortcut}}, - {QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), Qt::WindowShortcut}}, - {QStringLiteral("Toggle Framerate Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"), Qt::ApplicationShortcut}}, - {QStringLiteral("Toggle Mouse Panning"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), Qt::ApplicationShortcut}}, - {QStringLiteral("Toggle Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), Qt::ApplicationShortcut}}, - {QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), Qt::WindowShortcut}}, + {QStringLiteral("Capture Screenshot"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+P"), QStringLiteral("Screenshot"), Qt::WidgetWithChildrenShortcut}}, + {QStringLiteral("Change Docked Mode"), QStringLiteral("Main Window"), {QStringLiteral("F10"), QStringLiteral("Home+X"), Qt::ApplicationShortcut}}, + {QStringLiteral("Continue/Pause Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F4"), QStringLiteral("Home+Plus"), Qt::WindowShortcut}}, + {QStringLiteral("Decrease Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("-"), QStringLiteral(""), Qt::ApplicationShortcut}}, + {QStringLiteral("Exit Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("Esc"), QStringLiteral(""), Qt::WindowShortcut}}, + {QStringLiteral("Exit yuzu"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Q"), QStringLiteral("Home+Minus"), Qt::WindowShortcut}}, + {QStringLiteral("Fullscreen"), QStringLiteral("Main Window"), {QStringLiteral("F11"), QStringLiteral("Home+B"), Qt::WindowShortcut}}, + {QStringLiteral("Increase Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("+"), QStringLiteral(""), Qt::ApplicationShortcut}}, + {QStringLiteral("Load Amiibo"), QStringLiteral("Main Window"), {QStringLiteral("F2"), QStringLiteral("Home+A"), Qt::WidgetWithChildrenShortcut}}, + {QStringLiteral("Load File"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+O"), QStringLiteral(""), Qt::WidgetWithChildrenShortcut}}, + {QStringLiteral("Mute Audio"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+M"), QStringLiteral(""), Qt::WindowShortcut}}, + {QStringLiteral("Restart Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F6"), QStringLiteral(""), Qt::WindowShortcut}}, + {QStringLiteral("Stop Emulation"), QStringLiteral("Main Window"), {QStringLiteral("F5"), QStringLiteral(""), Qt::WindowShortcut}}, + {QStringLiteral("TAS Start/Stop"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F5"), QStringLiteral(""), Qt::ApplicationShortcut}}, + {QStringLiteral("TAS Reset"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F6"), QStringLiteral(""), Qt::ApplicationShortcut}}, + {QStringLiteral("TAS Record"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F7"), QStringLiteral(""), Qt::ApplicationShortcut}}, + {QStringLiteral("Toggle Filter Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F"), QStringLiteral(""), Qt::WindowShortcut}}, + {QStringLiteral("Toggle Framerate Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+U"), QStringLiteral("Home+Y"), Qt::ApplicationShortcut}}, + {QStringLiteral("Toggle Mouse Panning"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+F9"), QStringLiteral(""), Qt::ApplicationShortcut}}, + {QStringLiteral("Toggle Speed Limit"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+Z"), QStringLiteral(""), Qt::ApplicationShortcut}}, + {QStringLiteral("Toggle Status Bar"), QStringLiteral("Main Window"), {QStringLiteral("Ctrl+S"), QStringLiteral(""), Qt::WindowShortcut}}, }}; // clang-format on @@ -679,7 +679,6 @@ void Config::ReadShortcutValues() { qt_config->beginGroup(QStringLiteral("Shortcuts")); for (const auto& [name, group, shortcut] : default_hotkeys) { - const auto& [keyseq, context] = shortcut; qt_config->beginGroup(group); qt_config->beginGroup(name); // No longer using ReadSetting for shortcut.second as it innacurately returns a value of 1 @@ -688,7 +687,10 @@ void Config::ReadShortcutValues() { UISettings::values.shortcuts.push_back( {name, group, - {ReadSetting(QStringLiteral("KeySeq"), keyseq).toString(), shortcut.second}}); + {ReadSetting(QStringLiteral("KeySeq"), shortcut.keyseq).toString(), + ReadSetting(QStringLiteral("Controller_KeySeq"), shortcut.controller_keyseq) + .toString(), + shortcut.context}}); qt_config->endGroup(); qt_config->endGroup(); } @@ -741,7 +743,10 @@ void Config::ReadUIValues() { qt_config->beginGroup(QStringLiteral("UI")); UISettings::values.theme = - ReadSetting(QStringLiteral("theme"), QString::fromUtf8(UISettings::themes[0].second)) + ReadSetting( + QStringLiteral("theme"), + QString::fromUtf8( + UISettings::themes[static_cast<size_t>(UISettings::Theme::DarkColorful)].second)) .toString(); ReadBasicSetting(UISettings::values.enable_discord_presence); ReadBasicSetting(UISettings::values.select_user_on_boot); @@ -1227,8 +1232,10 @@ void Config::SaveShortcutValues() { qt_config->beginGroup(group); qt_config->beginGroup(name); - WriteSetting(QStringLiteral("KeySeq"), shortcut.first, default_hotkey.first); - WriteSetting(QStringLiteral("Context"), shortcut.second, default_hotkey.second); + WriteSetting(QStringLiteral("KeySeq"), shortcut.keyseq, default_hotkey.keyseq); + WriteSetting(QStringLiteral("Controller_KeySeq"), shortcut.controller_keyseq, + default_hotkey.controller_keyseq); + WriteSetting(QStringLiteral("Context"), shortcut.context, default_hotkey.context); qt_config->endGroup(); qt_config->endGroup(); } @@ -1266,8 +1273,10 @@ void Config::SaveSystemValues() { void Config::SaveUIValues() { qt_config->beginGroup(QStringLiteral("UI")); - WriteSetting(QStringLiteral("theme"), UISettings::values.theme, - QString::fromUtf8(UISettings::themes[0].second)); + WriteSetting( + QStringLiteral("theme"), UISettings::values.theme, + QString::fromUtf8( + UISettings::themes[static_cast<size_t>(UISettings::Theme::DarkColorful)].second)); WriteBasicSetting(UISettings::values.enable_discord_presence); WriteBasicSetting(UISettings::values.select_user_on_boot); diff --git a/src/yuzu/configuration/configure_dialog.cpp b/src/yuzu/configuration/configure_dialog.cpp index 642a5f966..464e7a489 100644 --- a/src/yuzu/configuration/configure_dialog.cpp +++ b/src/yuzu/configuration/configure_dialog.cpp @@ -45,7 +45,7 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry, general_tab{std::make_unique<ConfigureGeneral>(system_, this)}, graphics_tab{std::make_unique<ConfigureGraphics>(system_, this)}, graphics_advanced_tab{std::make_unique<ConfigureGraphicsAdvanced>(system_, this)}, - hotkeys_tab{std::make_unique<ConfigureHotkeys>(this)}, + hotkeys_tab{std::make_unique<ConfigureHotkeys>(system_.HIDCore(), this)}, input_tab{std::make_unique<ConfigureInput>(system_, this)}, network_tab{std::make_unique<ConfigureNetwork>(system_, this)}, profile_tab{std::make_unique<ConfigureProfileManager>(system_, this)}, diff --git a/src/yuzu/configuration/configure_hotkeys.cpp b/src/yuzu/configuration/configure_hotkeys.cpp index ed76fe18e..be10e0a31 100644 --- a/src/yuzu/configuration/configure_hotkeys.cpp +++ b/src/yuzu/configuration/configure_hotkeys.cpp @@ -5,15 +5,24 @@ #include <QMenu> #include <QMessageBox> #include <QStandardItemModel> -#include "common/settings.h" +#include <QTimer> + +#include "core/hid/emulated_controller.h" +#include "core/hid/hid_core.h" + #include "ui_configure_hotkeys.h" #include "yuzu/configuration/config.h" #include "yuzu/configuration/configure_hotkeys.h" #include "yuzu/hotkeys.h" #include "yuzu/util/sequence_dialog/sequence_dialog.h" -ConfigureHotkeys::ConfigureHotkeys(QWidget* parent) - : QWidget(parent), ui(std::make_unique<Ui::ConfigureHotkeys>()) { +constexpr int name_column = 0; +constexpr int hotkey_column = 1; +constexpr int controller_column = 2; + +ConfigureHotkeys::ConfigureHotkeys(Core::HID::HIDCore& hid_core, QWidget* parent) + : QWidget(parent), ui(std::make_unique<Ui::ConfigureHotkeys>()), + timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()) { ui->setupUi(this); setFocusPolicy(Qt::ClickFocus); @@ -26,16 +35,24 @@ ConfigureHotkeys::ConfigureHotkeys(QWidget* parent) ui->hotkey_list->setContextMenuPolicy(Qt::CustomContextMenu); ui->hotkey_list->setModel(model); - // TODO(Kloen): Make context configurable as well (hiding the column for now) - ui->hotkey_list->hideColumn(2); - - ui->hotkey_list->setColumnWidth(0, 200); - ui->hotkey_list->resizeColumnToContents(1); + ui->hotkey_list->setColumnWidth(name_column, 200); + ui->hotkey_list->resizeColumnToContents(hotkey_column); connect(ui->button_restore_defaults, &QPushButton::clicked, this, &ConfigureHotkeys::RestoreDefaults); connect(ui->button_clear_all, &QPushButton::clicked, this, &ConfigureHotkeys::ClearAll); + controller = hid_core.GetEmulatedController(Core::HID::NpadIdType::Player1); + + connect(timeout_timer.get(), &QTimer::timeout, [this] { SetPollingResult({}, true); }); + + connect(poll_timer.get(), &QTimer::timeout, [this] { + const auto buttons = controller->GetNpadButtons(); + if (buttons.raw != Core::HID::NpadButton::None) { + SetPollingResult(buttons.raw, false); + return; + } + }); RetranslateUI(); } @@ -49,15 +66,18 @@ void ConfigureHotkeys::Populate(const HotkeyRegistry& registry) { auto* action = new QStandardItem(hotkey.first); auto* keyseq = new QStandardItem(hotkey.second.keyseq.toString(QKeySequence::NativeText)); + auto* controller_keyseq = new QStandardItem(hotkey.second.controller_keyseq); action->setEditable(false); keyseq->setEditable(false); - parent_item->appendRow({action, keyseq}); + controller_keyseq->setEditable(false); + parent_item->appendRow({action, keyseq, controller_keyseq}); } model->appendRow(parent_item); } ui->hotkey_list->expandAll(); - ui->hotkey_list->resizeColumnToContents(0); + ui->hotkey_list->resizeColumnToContents(name_column); + ui->hotkey_list->resizeColumnToContents(hotkey_column); } void ConfigureHotkeys::changeEvent(QEvent* event) { @@ -71,7 +91,7 @@ void ConfigureHotkeys::changeEvent(QEvent* event) { void ConfigureHotkeys::RetranslateUI() { ui->retranslateUi(this); - model->setHorizontalHeaderLabels({tr("Action"), tr("Hotkey"), tr("Context")}); + model->setHorizontalHeaderLabels({tr("Action"), tr("Hotkey"), tr("Controller Hotkey")}); } void ConfigureHotkeys::Configure(QModelIndex index) { @@ -79,7 +99,15 @@ void ConfigureHotkeys::Configure(QModelIndex index) { return; } - index = index.sibling(index.row(), 1); + // Controller configuration is selected + if (index.column() == controller_column) { + ConfigureController(index); + return; + } + + // Swap to the hotkey column + index = index.sibling(index.row(), hotkey_column); + const auto previous_key = model->data(index); SequenceDialog hotkey_dialog{this}; @@ -99,13 +127,113 @@ void ConfigureHotkeys::Configure(QModelIndex index) { model->setData(index, key_sequence.toString(QKeySequence::NativeText)); } } +void ConfigureHotkeys::ConfigureController(QModelIndex index) { + if (timeout_timer->isActive()) { + return; + } + + const auto previous_key = model->data(index); + + input_setter = [this, index, previous_key](const Core::HID::NpadButton button, + const bool cancel) { + if (cancel) { + model->setData(index, previous_key); + return; + } + + const QString button_string = tr("Home+%1").arg(GetButtonName(button)); + + const auto [key_sequence_used, used_action] = IsUsedControllerKey(button_string); + + if (key_sequence_used) { + QMessageBox::warning( + this, tr("Conflicting Key Sequence"), + tr("The entered key sequence is already assigned to: %1").arg(used_action)); + model->setData(index, previous_key); + } else { + model->setData(index, button_string); + } + }; + + model->setData(index, tr("[waiting]")); + timeout_timer->start(2500); // Cancel after 2.5 seconds + poll_timer->start(200); // Check for new inputs every 200ms + // We need to disable configuration to be able to read npad buttons + controller->DisableConfiguration(); + controller->DisableSystemButtons(); +} + +void ConfigureHotkeys::SetPollingResult(Core::HID::NpadButton button, const bool cancel) { + timeout_timer->stop(); + poll_timer->stop(); + // Re-Enable configuration + controller->EnableConfiguration(); + controller->EnableSystemButtons(); + + (*input_setter)(button, cancel); + + input_setter = std::nullopt; +} + +QString ConfigureHotkeys::GetButtonName(Core::HID::NpadButton button) const { + Core::HID::NpadButtonState state{button}; + if (state.a) { + return tr("A"); + } + if (state.b) { + return tr("B"); + } + if (state.x) { + return tr("X"); + } + if (state.y) { + return tr("Y"); + } + if (state.l || state.right_sl || state.left_sl) { + return tr("L"); + } + if (state.r || state.right_sr || state.left_sr) { + return tr("R"); + } + if (state.zl) { + return tr("ZL"); + } + if (state.zr) { + return tr("ZR"); + } + if (state.left) { + return tr("Dpad_Left"); + } + if (state.right) { + return tr("Dpad_Right"); + } + if (state.up) { + return tr("Dpad_Up"); + } + if (state.down) { + return tr("Dpad_Down"); + } + if (state.stick_l) { + return tr("Left_Stick"); + } + if (state.stick_r) { + return tr("Right_Stick"); + } + if (state.minus) { + return tr("Minus"); + } + if (state.plus) { + return tr("Plus"); + } + return tr("Invalid"); +} std::pair<bool, QString> ConfigureHotkeys::IsUsedKey(QKeySequence key_sequence) const { for (int r = 0; r < model->rowCount(); ++r) { const QStandardItem* const parent = model->item(r, 0); for (int r2 = 0; r2 < parent->rowCount(); ++r2) { - const QStandardItem* const key_seq_item = parent->child(r2, 1); + const QStandardItem* const key_seq_item = parent->child(r2, hotkey_column); const auto key_seq_str = key_seq_item->text(); const auto key_seq = QKeySequence::fromString(key_seq_str, QKeySequence::NativeText); @@ -118,12 +246,31 @@ std::pair<bool, QString> ConfigureHotkeys::IsUsedKey(QKeySequence key_sequence) return std::make_pair(false, QString()); } +std::pair<bool, QString> ConfigureHotkeys::IsUsedControllerKey(const QString& key_sequence) const { + for (int r = 0; r < model->rowCount(); ++r) { + const QStandardItem* const parent = model->item(r, 0); + + for (int r2 = 0; r2 < parent->rowCount(); ++r2) { + const QStandardItem* const key_seq_item = parent->child(r2, controller_column); + const auto key_seq_str = key_seq_item->text(); + + if (key_sequence == key_seq_str) { + return std::make_pair(true, parent->child(r2, 0)->text()); + } + } + } + + return std::make_pair(false, QString()); +} + void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) { for (int key_id = 0; key_id < model->rowCount(); key_id++) { const QStandardItem* parent = model->item(key_id, 0); for (int key_column_id = 0; key_column_id < parent->rowCount(); key_column_id++) { - const QStandardItem* action = parent->child(key_column_id, 0); - const QStandardItem* keyseq = parent->child(key_column_id, 1); + const QStandardItem* action = parent->child(key_column_id, name_column); + const QStandardItem* keyseq = parent->child(key_column_id, hotkey_column); + const QStandardItem* controller_keyseq = + parent->child(key_column_id, controller_column); for (auto& [group, sub_actions] : registry.hotkey_groups) { if (group != parent->text()) continue; @@ -131,6 +278,7 @@ void ConfigureHotkeys::ApplyConfiguration(HotkeyRegistry& registry) { if (action_name != action->text()) continue; hotkey.keyseq = QKeySequence(keyseq->text()); + hotkey.controller_keyseq = controller_keyseq->text(); } } } @@ -144,7 +292,12 @@ void ConfigureHotkeys::RestoreDefaults() { const QStandardItem* parent = model->item(r, 0); for (int r2 = 0; r2 < parent->rowCount(); ++r2) { - model->item(r, 0)->child(r2, 1)->setText(Config::default_hotkeys[r2].shortcut.first); + model->item(r, 0) + ->child(r2, hotkey_column) + ->setText(Config::default_hotkeys[r2].shortcut.keyseq); + model->item(r, 0) + ->child(r2, controller_column) + ->setText(Config::default_hotkeys[r2].shortcut.controller_keyseq); } } } @@ -154,7 +307,8 @@ void ConfigureHotkeys::ClearAll() { const QStandardItem* parent = model->item(r, 0); for (int r2 = 0; r2 < parent->rowCount(); ++r2) { - model->item(r, 0)->child(r2, 1)->setText(QString{}); + model->item(r, 0)->child(r2, hotkey_column)->setText(QString{}); + model->item(r, 0)->child(r2, controller_column)->setText(QString{}); } } } @@ -165,28 +319,52 @@ void ConfigureHotkeys::PopupContextMenu(const QPoint& menu_location) { return; } - const auto selected = index.sibling(index.row(), 1); + // Swap to the hotkey column if the controller hotkey column is not selected + if (index.column() != controller_column) { + index = index.sibling(index.row(), hotkey_column); + } + QMenu context_menu; QAction* restore_default = context_menu.addAction(tr("Restore Default")); QAction* clear = context_menu.addAction(tr("Clear")); - connect(restore_default, &QAction::triggered, [this, selected] { - const QKeySequence& default_key_sequence = QKeySequence::fromString( - Config::default_hotkeys[selected.row()].shortcut.first, QKeySequence::NativeText); - const auto [key_sequence_used, used_action] = IsUsedKey(default_key_sequence); - - if (key_sequence_used && - default_key_sequence != QKeySequence(model->data(selected).toString())) { - - QMessageBox::warning( - this, tr("Conflicting Key Sequence"), - tr("The default key sequence is already assigned to: %1").arg(used_action)); - } else { - model->setData(selected, default_key_sequence.toString(QKeySequence::NativeText)); + connect(restore_default, &QAction::triggered, [this, index] { + if (index.column() == controller_column) { + RestoreControllerHotkey(index); + return; } + RestoreHotkey(index); }); - connect(clear, &QAction::triggered, [this, selected] { model->setData(selected, QString{}); }); + connect(clear, &QAction::triggered, [this, index] { model->setData(index, QString{}); }); context_menu.exec(ui->hotkey_list->viewport()->mapToGlobal(menu_location)); } + +void ConfigureHotkeys::RestoreControllerHotkey(QModelIndex index) { + const QString& default_key_sequence = + Config::default_hotkeys[index.row()].shortcut.controller_keyseq; + const auto [key_sequence_used, used_action] = IsUsedControllerKey(default_key_sequence); + + if (key_sequence_used && default_key_sequence != model->data(index).toString()) { + QMessageBox::warning( + this, tr("Conflicting Button Sequence"), + tr("The default button sequence is already assigned to: %1").arg(used_action)); + } else { + model->setData(index, default_key_sequence); + } +} + +void ConfigureHotkeys::RestoreHotkey(QModelIndex index) { + const QKeySequence& default_key_sequence = QKeySequence::fromString( + Config::default_hotkeys[index.row()].shortcut.keyseq, QKeySequence::NativeText); + const auto [key_sequence_used, used_action] = IsUsedKey(default_key_sequence); + + if (key_sequence_used && default_key_sequence != QKeySequence(model->data(index).toString())) { + QMessageBox::warning( + this, tr("Conflicting Key Sequence"), + tr("The default key sequence is already assigned to: %1").arg(used_action)); + } else { + model->setData(index, default_key_sequence.toString(QKeySequence::NativeText)); + } +} diff --git a/src/yuzu/configuration/configure_hotkeys.h b/src/yuzu/configuration/configure_hotkeys.h index a2ec3323e..f943ec538 100644 --- a/src/yuzu/configuration/configure_hotkeys.h +++ b/src/yuzu/configuration/configure_hotkeys.h @@ -7,6 +7,16 @@ #include <memory> #include <QWidget> +namespace Common { +class ParamPackage; +} + +namespace Core::HID { +class HIDCore; +class EmulatedController; +enum class NpadButton : u64; +} // namespace Core::HID + namespace Ui { class ConfigureHotkeys; } @@ -18,7 +28,7 @@ class ConfigureHotkeys : public QWidget { Q_OBJECT public: - explicit ConfigureHotkeys(QWidget* parent = nullptr); + explicit ConfigureHotkeys(Core::HID::HIDCore& hid_core_, QWidget* parent = nullptr); ~ConfigureHotkeys() override; void ApplyConfiguration(HotkeyRegistry& registry); @@ -35,13 +45,24 @@ private: void RetranslateUI(); void Configure(QModelIndex index); + void ConfigureController(QModelIndex index); std::pair<bool, QString> IsUsedKey(QKeySequence key_sequence) const; + std::pair<bool, QString> IsUsedControllerKey(const QString& key_sequence) const; void RestoreDefaults(); void ClearAll(); void PopupContextMenu(const QPoint& menu_location); + void RestoreControllerHotkey(QModelIndex index); + void RestoreHotkey(QModelIndex index); std::unique_ptr<Ui::ConfigureHotkeys> ui; QStandardItemModel* model; + + void SetPollingResult(Core::HID::NpadButton button, bool cancel); + QString GetButtonName(Core::HID::NpadButton button) const; + Core::HID::EmulatedController* controller; + std::unique_ptr<QTimer> timeout_timer; + std::unique_ptr<QTimer> poll_timer; + std::optional<std::function<void(Core::HID::NpadButton, bool)>> input_setter; }; diff --git a/src/yuzu/configuration/configure_input_player.cpp b/src/yuzu/configuration/configure_input_player.cpp index b9342466e..d2132b408 100644 --- a/src/yuzu/configuration/configure_input_player.cpp +++ b/src/yuzu/configuration/configure_input_player.cpp @@ -102,6 +102,16 @@ QString GetButtonName(Common::Input::ButtonNames button_name) { return QObject::tr("Share"); case Common::Input::ButtonNames::Options: return QObject::tr("Options"); + case Common::Input::ButtonNames::ButtonMouseWheel: + return QObject::tr("Wheel", "Indicates the mouse wheel"); + case Common::Input::ButtonNames::ButtonBackward: + return QObject::tr("Backward"); + case Common::Input::ButtonNames::ButtonForward: + return QObject::tr("Forward"); + case Common::Input::ButtonNames::ButtonTask: + return QObject::tr("Task"); + case Common::Input::ButtonNames::ButtonExtra: + return QObject::tr("Extra"); default: return QObject::tr("[undefined]"); } diff --git a/src/yuzu/hotkeys.cpp b/src/yuzu/hotkeys.cpp index e7e58f314..d96497c4e 100644 --- a/src/yuzu/hotkeys.cpp +++ b/src/yuzu/hotkeys.cpp @@ -2,10 +2,13 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. +#include <sstream> #include <QKeySequence> #include <QShortcut> #include <QTreeWidgetItem> #include <QtGlobal> + +#include "core/hid/emulated_controller.h" #include "yuzu/hotkeys.h" #include "yuzu/uisettings.h" @@ -18,8 +21,9 @@ void HotkeyRegistry::SaveHotkeys() { for (const auto& hotkey : group.second) { UISettings::values.shortcuts.push_back( {hotkey.first, group.first, - UISettings::ContextualShortcut(hotkey.second.keyseq.toString(), - hotkey.second.context)}); + UISettings::ContextualShortcut({hotkey.second.keyseq.toString(), + hotkey.second.controller_keyseq, + hotkey.second.context})}); } } } @@ -29,28 +33,49 @@ void HotkeyRegistry::LoadHotkeys() { // beginGroup() for (auto shortcut : UISettings::values.shortcuts) { Hotkey& hk = hotkey_groups[shortcut.group][shortcut.name]; - if (!shortcut.shortcut.first.isEmpty()) { - hk.keyseq = QKeySequence::fromString(shortcut.shortcut.first, QKeySequence::NativeText); - hk.context = static_cast<Qt::ShortcutContext>(shortcut.shortcut.second); + if (!shortcut.shortcut.keyseq.isEmpty()) { + hk.keyseq = + QKeySequence::fromString(shortcut.shortcut.keyseq, QKeySequence::NativeText); + hk.context = static_cast<Qt::ShortcutContext>(shortcut.shortcut.context); + } + if (!shortcut.shortcut.controller_keyseq.isEmpty()) { + hk.controller_keyseq = shortcut.shortcut.controller_keyseq; } if (hk.shortcut) { hk.shortcut->disconnect(); hk.shortcut->setKey(hk.keyseq); } + if (hk.controller_shortcut) { + hk.controller_shortcut->disconnect(); + hk.controller_shortcut->SetKey(hk.controller_keyseq); + } } } QShortcut* HotkeyRegistry::GetHotkey(const QString& group, const QString& action, QWidget* widget) { Hotkey& hk = hotkey_groups[group][action]; - if (!hk.shortcut) + if (!hk.shortcut) { hk.shortcut = new QShortcut(hk.keyseq, widget, nullptr, nullptr, hk.context); + } hk.shortcut->setAutoRepeat(false); return hk.shortcut; } +ControllerShortcut* HotkeyRegistry::GetControllerHotkey(const QString& group, const QString& action, + Core::HID::EmulatedController* controller) { + Hotkey& hk = hotkey_groups[group][action]; + + if (!hk.controller_shortcut) { + hk.controller_shortcut = new ControllerShortcut(controller); + hk.controller_shortcut->SetKey(hk.controller_keyseq); + } + + return hk.controller_shortcut; +} + QKeySequence HotkeyRegistry::GetKeySequence(const QString& group, const QString& action) { return hotkey_groups[group][action].keyseq; } @@ -59,3 +84,131 @@ Qt::ShortcutContext HotkeyRegistry::GetShortcutContext(const QString& group, const QString& action) { return hotkey_groups[group][action].context; } + +ControllerShortcut::ControllerShortcut(Core::HID::EmulatedController* controller) { + emulated_controller = controller; + Core::HID::ControllerUpdateCallback engine_callback{ + .on_change = [this](Core::HID::ControllerTriggerType type) { ControllerUpdateEvent(type); }, + .is_npad_service = false, + }; + callback_key = emulated_controller->SetCallback(engine_callback); + is_enabled = true; +} + +ControllerShortcut::~ControllerShortcut() { + emulated_controller->DeleteCallback(callback_key); +} + +void ControllerShortcut::SetKey(const ControllerButtonSequence& buttons) { + button_sequence = buttons; +} + +void ControllerShortcut::SetKey(const QString& buttons_shortcut) { + ControllerButtonSequence sequence{}; + name = buttons_shortcut.toStdString(); + std::istringstream command_line(buttons_shortcut.toStdString()); + std::string line; + while (std::getline(command_line, line, '+')) { + if (line.empty()) { + continue; + } + if (line == "A") { + sequence.npad.a.Assign(1); + } + if (line == "B") { + sequence.npad.b.Assign(1); + } + if (line == "X") { + sequence.npad.x.Assign(1); + } + if (line == "Y") { + sequence.npad.y.Assign(1); + } + if (line == "L") { + sequence.npad.l.Assign(1); + } + if (line == "R") { + sequence.npad.r.Assign(1); + } + if (line == "ZL") { + sequence.npad.zl.Assign(1); + } + if (line == "ZR") { + sequence.npad.zr.Assign(1); + } + if (line == "Dpad_Left") { + sequence.npad.left.Assign(1); + } + if (line == "Dpad_Right") { + sequence.npad.right.Assign(1); + } + if (line == "Dpad_Up") { + sequence.npad.up.Assign(1); + } + if (line == "Dpad_Down") { + sequence.npad.down.Assign(1); + } + if (line == "Left_Stick") { + sequence.npad.stick_l.Assign(1); + } + if (line == "Right_Stick") { + sequence.npad.stick_r.Assign(1); + } + if (line == "Minus") { + sequence.npad.minus.Assign(1); + } + if (line == "Plus") { + sequence.npad.plus.Assign(1); + } + if (line == "Home") { + sequence.home.home.Assign(1); + } + if (line == "Screenshot") { + sequence.capture.capture.Assign(1); + } + } + + button_sequence = sequence; +} + +ControllerButtonSequence ControllerShortcut::ButtonSequence() const { + return button_sequence; +} + +void ControllerShortcut::SetEnabled(bool enable) { + is_enabled = enable; +} + +bool ControllerShortcut::IsEnabled() const { + return is_enabled; +} + +void ControllerShortcut::ControllerUpdateEvent(Core::HID::ControllerTriggerType type) { + if (!is_enabled) { + return; + } + if (type != Core::HID::ControllerTriggerType::Button) { + return; + } + if (button_sequence.npad.raw == Core::HID::NpadButton::None && + button_sequence.capture.raw == 0 && button_sequence.home.raw == 0) { + return; + } + + const auto player_npad_buttons = + emulated_controller->GetNpadButtons().raw & button_sequence.npad.raw; + const u64 player_capture_buttons = + emulated_controller->GetCaptureButtons().raw & button_sequence.capture.raw; + const u64 player_home_buttons = + emulated_controller->GetHomeButtons().raw & button_sequence.home.raw; + + if (player_npad_buttons == button_sequence.npad.raw && + player_capture_buttons == button_sequence.capture.raw && + player_home_buttons == button_sequence.home.raw && !active) { + // Force user to press the home or capture button again + active = true; + emit Activated(); + return; + } + active = false; +} diff --git a/src/yuzu/hotkeys.h b/src/yuzu/hotkeys.h index 248fadaf3..57a7c7da5 100644 --- a/src/yuzu/hotkeys.h +++ b/src/yuzu/hotkeys.h @@ -5,11 +5,53 @@ #pragma once #include <map> +#include "core/hid/hid_types.h" class QDialog; class QKeySequence; class QSettings; class QShortcut; +class ControllerShortcut; + +namespace Core::HID { +enum class ControllerTriggerType; +class EmulatedController; +} // namespace Core::HID + +struct ControllerButtonSequence { + Core::HID::CaptureButtonState capture{}; + Core::HID::HomeButtonState home{}; + Core::HID::NpadButtonState npad{}; +}; + +class ControllerShortcut : public QObject { + Q_OBJECT + +public: + explicit ControllerShortcut(Core::HID::EmulatedController* controller); + ~ControllerShortcut(); + + void SetKey(const ControllerButtonSequence& buttons); + void SetKey(const QString& buttons_shortcut); + + ControllerButtonSequence ButtonSequence() const; + + void SetEnabled(bool enable); + bool IsEnabled() const; + +Q_SIGNALS: + void Activated(); + +private: + void ControllerUpdateEvent(Core::HID::ControllerTriggerType type); + + bool is_enabled{}; + bool active{}; + int callback_key{}; + ControllerButtonSequence button_sequence{}; + std::string name{}; + Core::HID::EmulatedController* emulated_controller = nullptr; +}; class HotkeyRegistry final { public: @@ -46,6 +88,8 @@ public: * QShortcut's parent. */ QShortcut* GetHotkey(const QString& group, const QString& action, QWidget* widget); + ControllerShortcut* GetControllerHotkey(const QString& group, const QString& action, + Core::HID::EmulatedController* controller); /** * Returns a QKeySequence object whose signal can be connected to QAction::setShortcut. @@ -68,7 +112,9 @@ public: private: struct Hotkey { QKeySequence keyseq; + QString controller_keyseq; QShortcut* shortcut = nullptr; + ControllerShortcut* controller_shortcut = nullptr; Qt::ShortcutContext context = Qt::WindowShortcut; }; diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp index 53f11a9ac..e10eb70a2 100644 --- a/src/yuzu/main.cpp +++ b/src/yuzu/main.cpp @@ -32,6 +32,7 @@ #include "core/hle/service/am/applet_ae.h" #include "core/hle/service/am/applet_oe.h" #include "core/hle/service/am/applets/applets.h" +#include "yuzu/util/controller_navigation.h" // These are wrappers to avoid the calls to CreateDirectory and CreateFile because of the Windows // defines. @@ -966,6 +967,12 @@ void GMainWindow::LinkActionShortcut(QAction* action, const QString& action_name action->setShortcutContext(hotkey_registry.GetShortcutContext(main_window, action_name)); this->addAction(action); + + auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1); + const auto* controller_hotkey = + hotkey_registry.GetControllerHotkey(main_window, action_name, controller); + connect(controller_hotkey, &ControllerShortcut::Activated, this, + [action] { action->trigger(); }); } void GMainWindow::InitializeHotkeys() { @@ -987,8 +994,12 @@ void GMainWindow::InitializeHotkeys() { static const QString main_window = QStringLiteral("Main Window"); const auto connect_shortcut = [&]<typename Fn>(const QString& action_name, const Fn& function) { - const QShortcut* hotkey = hotkey_registry.GetHotkey(main_window, action_name, this); + const auto* hotkey = hotkey_registry.GetHotkey(main_window, action_name, this); + auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1); + const auto* controller_hotkey = + hotkey_registry.GetControllerHotkey(main_window, action_name, controller); connect(hotkey, &QShortcut::activated, this, function); + connect(controller_hotkey, &ControllerShortcut::Activated, this, function); }; connect_shortcut(QStringLiteral("Exit Fullscreen"), [&] { @@ -1165,8 +1176,7 @@ void GMainWindow::ConnectMenuEvents() { connect_menu(ui->action_Single_Window_Mode, &GMainWindow::ToggleWindowMode); connect_menu(ui->action_Display_Dock_Widget_Headers, &GMainWindow::OnDisplayTitleBars); connect_menu(ui->action_Show_Filter_Bar, &GMainWindow::OnToggleFilterBar); - - connect(ui->action_Show_Status_Bar, &QAction::triggered, statusBar(), &QStatusBar::setVisible); + connect_menu(ui->action_Show_Status_Bar, &GMainWindow::OnToggleStatusBar); connect_menu(ui->action_Reset_Window_Size_720, &GMainWindow::ResetWindowSize720); connect_menu(ui->action_Reset_Window_Size_900, &GMainWindow::ResetWindowSize900); @@ -2168,6 +2178,11 @@ void GMainWindow::OnGameListOpenPerGameProperties(const std::string& file) { } void GMainWindow::OnMenuLoadFile() { + if (is_load_file_select_active) { + return; + } + + is_load_file_select_active = true; const QString extensions = QStringLiteral("*.") .append(GameList::supported_file_extensions.join(QStringLiteral(" *."))) @@ -2177,6 +2192,7 @@ void GMainWindow::OnMenuLoadFile() { .arg(extensions); const QString filename = QFileDialog::getOpenFileName( this, tr("Load File"), UISettings::values.roms_path, file_filter); + is_load_file_select_active = false; if (filename.isEmpty()) { return; @@ -2809,6 +2825,11 @@ void GMainWindow::OnTasStartStop() { if (!emulation_running) { return; } + + // Disable system buttons to prevent TAS from executing a hotkey + auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1); + controller->ResetSystemButtons(); + input_subsystem->GetTas()->StartStop(); OnTasStateChanged(); } @@ -2817,12 +2838,34 @@ void GMainWindow::OnTasRecord() { if (!emulation_running) { return; } + if (is_tas_recording_dialog_active) { + return; + } + + // Disable system buttons to prevent TAS from recording a hotkey + auto* controller = system->HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1); + controller->ResetSystemButtons(); + const bool is_recording = input_subsystem->GetTas()->Record(); if (!is_recording) { - const auto res = - QMessageBox::question(this, tr("TAS Recording"), tr("Overwrite file of player 1?"), - QMessageBox::Yes | QMessageBox::No); + is_tas_recording_dialog_active = true; + ControllerNavigation* controller_navigation = + new ControllerNavigation(system->HIDCore(), this); + // Use QMessageBox instead of question so we can link controller navigation + QMessageBox* box_dialog = new QMessageBox(); + box_dialog->setWindowTitle(tr("TAS Recording")); + box_dialog->setText(tr("Overwrite file of player 1?")); + box_dialog->setStandardButtons(QMessageBox::Yes | QMessageBox::No); + box_dialog->setDefaultButton(QMessageBox::Yes); + connect(controller_navigation, &ControllerNavigation::TriggerKeyboardEvent, + [box_dialog](Qt::Key key) { + QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, key, Qt::NoModifier); + QCoreApplication::postEvent(box_dialog, event); + }); + int res = box_dialog->exec(); + controller_navigation->UnloadController(); input_subsystem->GetTas()->SaveRecording(res == QMessageBox::Yes); + is_tas_recording_dialog_active = false; } OnTasStateChanged(); } @@ -2871,10 +2914,15 @@ void GMainWindow::OnLoadAmiibo() { if (emu_thread == nullptr || !emu_thread->IsRunning()) { return; } + if (is_amiibo_file_select_active) { + return; + } + is_amiibo_file_select_active = true; const QString extensions{QStringLiteral("*.bin")}; const QString file_filter = tr("Amiibo File (%1);; All Files (*.*)").arg(extensions); const QString filename = QFileDialog::getOpenFileName(this, tr("Load Amiibo"), {}, file_filter); + is_amiibo_file_select_active = false; if (filename.isEmpty()) { return; @@ -2934,6 +2982,10 @@ void GMainWindow::OnToggleFilterBar() { } } +void GMainWindow::OnToggleStatusBar() { + statusBar()->setVisible(ui->action_Show_Status_Bar->isChecked()); +} + void GMainWindow::OnCaptureScreenshot() { if (emu_thread == nullptr || !emu_thread->IsRunning()) { return; @@ -3626,8 +3678,8 @@ int main(int argc, char* argv[]) { QCoreApplication::setApplicationName(QStringLiteral("yuzu")); #ifdef _WIN32 - // Increases the maximum open file limit to 4096 - _setmaxstdio(4096); + // Increases the maximum open file limit to 8192 + _setmaxstdio(8192); #endif #ifdef __APPLE__ diff --git a/src/yuzu/main.h b/src/yuzu/main.h index 7870bb963..ca4ab9af5 100644 --- a/src/yuzu/main.h +++ b/src/yuzu/main.h @@ -186,6 +186,9 @@ public slots: void OnTasStateChanged(); private: + /// Updates an action's shortcut and text to reflect an updated hotkey from the hotkey registry. + void LinkActionShortcut(QAction* action, const QString& action_name); + void RegisterMetaTypes(); void InitializeWidgets(); @@ -286,6 +289,7 @@ private slots: void OnOpenYuzuFolder(); void OnAbout(); void OnToggleFilterBar(); + void OnToggleStatusBar(); void OnDisplayTitleBars(bool); void InitializeHotkeys(); void ToggleFullscreen(); @@ -303,9 +307,6 @@ private slots: void OnMouseActivity(); private: - /// Updates an action's shortcut and text to reflect an updated hotkey from the hotkey registry. - void LinkActionShortcut(QAction* action, const QString& action_name); - void RemoveBaseContent(u64 program_id, const QString& entry_type); void RemoveUpdateContent(u64 program_id, const QString& entry_type); void RemoveAddOnContent(u64 program_id, const QString& entry_type); @@ -400,6 +401,16 @@ private: // Applets QtSoftwareKeyboardDialog* software_keyboard = nullptr; + + // True if amiibo file select is visible + bool is_amiibo_file_select_active{}; + + // True if load file select is visible + bool is_load_file_select_active{}; + + // True if TAS recording dialog is visible + bool is_tas_recording_dialog_active{}; + #ifdef __linux__ QDBusObjectPath wake_lock{}; #endif diff --git a/src/yuzu/uisettings.h b/src/yuzu/uisettings.h index a610e7e25..f7298ddad 100644 --- a/src/yuzu/uisettings.h +++ b/src/yuzu/uisettings.h @@ -17,7 +17,11 @@ namespace UISettings { -using ContextualShortcut = std::pair<QString, int>; +struct ContextualShortcut { + QString keyseq; + QString controller_keyseq; + int context; +}; struct Shortcut { QString name; @@ -25,6 +29,15 @@ struct Shortcut { ContextualShortcut shortcut; }; +enum class Theme { + Default, + DefaultColorful, + Dark, + DarkColorful, + MidnightBlue, + MidnightBlueColorful, +}; + using Themes = std::array<std::pair<const char*, const char*>, 6>; extern const Themes themes; |