Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-06-30 20:15:29 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

[video_core, hle] remove redundant parent references in system structs (#3908)

Browse source 
reworked a bit to remove references of parent objects and instead pass as arguments to methods to prevent useless reloads

Signed-off-by: lizzie <lizzie@eden-emu.dev>
Co-authored-by: maufeat <sahyno1996@gmail.com>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3908
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: crueter <crueter@eden-emu.dev>
This commit is contained in:
lizzie 2026-06-23 06:31:25 +02:00 • committed by crueter
parent f8facda35f
commit 3aa0d46259
No known key found for this signature in database
GPG key ID: 425ACD2D4830EBC6
307 changed files with 4419 additions and 4477 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/core/hle/service/acc/async_context.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -64,7 +67,7 @@ void IAsyncContext::GetResult(HLERequestContext& ctx) {
void IAsyncContext::MarkComplete() {
is_complete.store(true);
completion_event->Signal();
completion_event->Signal(system.Kernel());
}
} // namespace Service::Account

6
src/core/hle/service/am/applet.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator
@ -52,7 +52,7 @@ void Applet::UpdateSuspensionStateLocked(bool force_message) {
// Signal if the focus state was changed or the process state was changed.
if (update_requested_focus_state || was_changed || force_message) {
lifecycle_manager.SignalSystemEventIfNeeded();
lifecycle_manager.SignalSystemEventIfNeeded(context.kernel);
}
}
@ -76,7 +76,7 @@ void Applet::SetInteractibleLocked(bool interactible) {
void Applet::OnProcessTerminatedLocked() {
is_completed = true;
state_changed_event.Signal();
state_changed_event.Signal(context.kernel);
}
} // namespace Service::AM

14
src/core/hle/service/am/applet_data_broker.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -11,22 +14,23 @@
namespace Service::AM {
AppletStorageChannel::AppletStorageChannel(KernelHelpers::ServiceContext& context)
: m_event(context) {}
: m_event(context)
{}
AppletStorageChannel::~AppletStorageChannel() = default;
void AppletStorageChannel::Push(std::shared_ptr<IStorage> storage) {
void AppletStorageChannel::Push(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage) {
std::scoped_lock lk{m_lock};
m_data.emplace_back(std::move(storage));
m_event.Signal();
m_event.Signal(kernel);
}
Result AppletStorageChannel::Pop(std::shared_ptr<IStorage>* out_storage) {
Result AppletStorageChannel::Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage) {
std::scoped_lock lk{m_lock};
SCOPE_EXIT {
if (m_data.empty()) {
m_event.Clear();
m_event.Clear(kernel);
}
};

7
src/core/hle/service/am/applet_data_broker.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -22,8 +25,8 @@ public:
explicit AppletStorageChannel(KernelHelpers::ServiceContext& ctx);
~AppletStorageChannel();
void Push(std::shared_ptr<IStorage> storage);
Result Pop(std::shared_ptr<IStorage>* out_storage);
void Push(Kernel::KernelCore& kernel, std::shared_ptr<IStorage> storage);
Result Pop(Kernel::KernelCore& kernel, std::shared_ptr<IStorage>* out_storage);
Kernel::KReadableEvent* GetEvent();
private:

31
src/core/hle/service/am/applet_manager.cpp
View file

@ -34,8 +34,7 @@ struct LaunchParameterAccountPreselectedUser {
};
static_assert(sizeof(LaunchParameterAccountPreselectedUser) == 0x88);
AppletStorageChannel& InitializeFakeCallerApplet(Core::System& system,
std::shared_ptr<Applet>& applet) {
AppletStorageChannel& InitializeFakeCallerApplet(Core::System& system, std::shared_ptr<Applet>& applet) {
applet->caller_applet_broker = std::make_shared<AppletDataBroker>(system);
return applet->caller_applet_broker->GetInData();
}
@ -52,7 +51,7 @@ void PushInShowQlaunch(Core::System& system, AppletStorageChannel& channel) {
std::vector<u8> argument_data(sizeof(arguments));
std::memcpy(argument_data.data(), &arguments, sizeof(arguments));
channel.Push(std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(argument_data)));
}
void PushInShowAlbum(Core::System& system, AppletStorageChannel& channel) {
@ -68,8 +67,8 @@ void PushInShowAlbum(Core::System& system, AppletStorageChannel& channel) {
std::vector<u8> argument_data(sizeof(arguments));
std::vector<u8> settings_data{2};
std::memcpy(argument_data.data(), &arguments, sizeof(arguments));
channel.Push(std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(std::make_shared<IStorage>(system, std::move(settings_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(settings_data)));
}
void PushInShowController(Core::System& system, AppletStorageChannel& channel) {
@ -116,9 +115,9 @@ void PushInShowController(Core::System& system, AppletStorageChannel& channel) {
std::memcpy(private_args_data.data(), &private_args, sizeof(private_args));
std::memcpy(user_args_data.data(), &user_args, sizeof(user_args));
channel.Push(std::make_shared<IStorage>(system, std::move(common_args_data)));
channel.Push(std::make_shared<IStorage>(system, std::move(private_args_data)));
channel.Push(std::make_shared<IStorage>(system, std::move(user_args_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(common_args_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(private_args_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(user_args_data)));
}
void PushInShowCabinetData(Core::System& system, AppletStorageChannel& channel) {
@ -146,8 +145,8 @@ void PushInShowCabinetData(Core::System& system, AppletStorageChannel& channel)
std::vector<u8> settings_data(sizeof(amiibo_settings));
std::memcpy(argument_data.data(), &arguments, sizeof(arguments));
std::memcpy(settings_data.data(), &amiibo_settings, sizeof(amiibo_settings));
channel.Push(std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(std::make_shared<IStorage>(system, std::move(settings_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(settings_data)));
}
void PushInShowMiiEditData(Core::System& system, AppletStorageChannel& channel) {
@ -169,7 +168,7 @@ void PushInShowMiiEditData(Core::System& system, AppletStorageChannel& channel)
std::vector<u8> argument_data(sizeof(mii_arguments));
std::memcpy(argument_data.data(), &mii_arguments, sizeof(mii_arguments));
channel.Push(std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(argument_data)));
}
void PushInShowSoftwareKeyboard(Core::System& system, AppletStorageChannel& channel) {
@ -222,9 +221,9 @@ void PushInShowSoftwareKeyboard(Core::System& system, AppletStorageChannel& chan
std::memcpy(work_buffer.data(), initial_string.data(),
swkbd_config.initial_string_length * sizeof(char16_t));
channel.Push(std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(std::make_shared<IStorage>(system, std::move(swkbd_data)));
channel.Push(std::make_shared<IStorage>(system, std::move(work_buffer)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(argument_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(swkbd_data)));
channel.Push(system.Kernel(), std::make_shared<IStorage>(system, std::move(work_buffer)));
}
} // namespace
@ -268,7 +267,7 @@ void AppletManager::SetWindowSystem(WindowSystem* window_system) {
if (Settings::values.enable_overlay && m_window_system->GetOverlayDisplayApplet() == nullptr) {
if (auto overlay_process = CreateProcess(m_system, static_cast<u64>(AppletProgramId::OverlayDisplay), 0, 0)) {
auto overlay_applet = std::make_shared<Applet>(m_system, std::move(overlay_process), false);
auto overlay_applet = std::make_shared<Applet>(m_system, std::make_unique<Service::Process>(*std::move(overlay_process)), false);
overlay_applet->program_id = static_cast<u64>(AppletProgramId::OverlayDisplay);
overlay_applet->applet_id = AppletId::OverlayDisplay;
overlay_applet->type = AppletType::OverlayApplet;
@ -340,7 +339,7 @@ void AppletManager::SetWindowSystem(WindowSystem* window_system) {
}
// Applet was started by frontend, so it is foreground.
applet->lifecycle_manager.SetFocusState(FocusState::InFocus);
applet->lifecycle_manager.SetFocusState(m_system.Kernel(), FocusState::InFocus);
if (applet->applet_id == AppletId::QLaunch) {
applet->lifecycle_manager.SetFocusHandlingMode(false);

71
src/core/hle/service/am/button_poller.cpp
View file

@ -1,9 +1,11 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <thread>
#include "common/thread.h"
#include "core/core.h"
#include "core/hle/service/am/am_types.h"
#include "core/hle/service/am/button_poller.h"
@ -34,16 +36,15 @@ ButtonPressDuration ClassifyPressDuration(std::chrono::steady_clock::time_point
} // namespace
ButtonPoller::ButtonPoller(Core::System& system, WindowSystem& window_system)
: m_window_system(window_system) {
ButtonPoller::ButtonPoller(Core::System& system, WindowSystem& window_system) {
// TODO: am reads this from the home button state in hid, which is controller-agnostic.
Core::HID::ControllerUpdateCallback engine_callback{
.on_change =
[this](Core::HID::ControllerTriggerType type) {
if (type == Core::HID::ControllerTriggerType::Button) {
this->OnButtonStateChanged();
}
},
.on_change = [this, &window_system](Core::HID::ControllerTriggerType type) {
if (type == Core::HID::ControllerTriggerType::Button) {
std::unique_lock lk{m_mutex};
OnButtonStateChanged(window_system);
}
},
.is_npad_service = true,
};
@ -52,25 +53,35 @@ ButtonPoller::ButtonPoller(Core::System& system, WindowSystem& window_system)
m_player1 = system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
m_player1_key = m_player1->SetCallback(engine_callback);
m_thread = std::thread([this] { this->ThreadLoop(); });
m_thread = std::jthread([this, &window_system](std::stop_token stop_token) {
Common::SetCurrentThreadName("ButtonPoller");
while (!stop_token.stop_requested()) {
using namespace std::chrono_literals;
std::unique_lock lk{m_mutex};
m_cv.wait_for(lk, 50ms);
if (stop_token.stop_requested())
break;
OnButtonStateChanged(window_system);
std::this_thread::sleep_for(5ms);
}
});
}
ButtonPoller::~ButtonPoller() {
m_handheld->DeleteCallback(m_handheld_key);
m_player1->DeleteCallback(m_player1_key);
m_stop = true;
m_cv.notify_all();
if (m_thread.joinable()) {
m_thread.request_stop();
m_thread.join();
}
}
void ButtonPoller::OnButtonStateChanged() {
std::lock_guard lk{m_mutex};
const bool home_button =
m_handheld->GetHomeButtons().home.Value() || m_player1->GetHomeButtons().home.Value();
const bool capture_button = m_handheld->GetCaptureButtons().capture.Value() ||
m_player1->GetCaptureButtons().capture.Value();
void ButtonPoller::OnButtonStateChanged(WindowSystem& window_system) {
auto const home_button = m_handheld->GetHomeButtons().home.Value()
|| m_player1->GetHomeButtons().home.Value();
auto const capture_button = m_handheld->GetCaptureButtons().capture.Value()
|| m_player1->GetCaptureButtons().capture.Value();
// Buttons pressed which were not previously pressed
if (home_button && !m_home_button_press_start) {
@ -90,7 +101,7 @@ void ButtonPoller::OnButtonStateChanged() {
if (home_button && m_home_button_press_start && !m_home_button_long_sent) {
const auto duration = ClassifyPressDuration(*m_home_button_press_start);
if (duration != ButtonPressDuration::ShortPressing) {
m_window_system.OnSystemButtonPress(SystemButtonType::HomeButtonLongPressing);
window_system.OnSystemButtonPress(SystemButtonType::HomeButtonLongPressing);
m_home_button_long_sent = true;
}
}
@ -98,7 +109,7 @@ void ButtonPoller::OnButtonStateChanged() {
if (capture_button && m_capture_button_press_start && !m_capture_button_long_sent) {
const auto duration = ClassifyPressDuration(*m_capture_button_press_start);
if (duration != ButtonPressDuration::ShortPressing) {
m_window_system.OnSystemButtonPress(SystemButtonType::CaptureButtonLongPressing);
window_system.OnSystemButtonPress(SystemButtonType::CaptureButtonLongPressing);
m_capture_button_long_sent = true;
}
}
@ -107,9 +118,8 @@ void ButtonPoller::OnButtonStateChanged() {
if (!home_button && m_home_button_press_start) {
if(!m_home_button_long_sent) {
const auto duration = ClassifyPressDuration(*m_home_button_press_start);
m_window_system.OnSystemButtonPress(
duration == ButtonPressDuration::ShortPressing ? SystemButtonType::HomeButtonShortPressing
: SystemButtonType::HomeButtonLongPressing);
window_system.OnSystemButtonPress(duration == ButtonPressDuration::ShortPressing
? SystemButtonType::HomeButtonShortPressing : SystemButtonType::HomeButtonLongPressing);
}
m_home_button_press_start = std::nullopt;
m_home_button_long_sent = false;
@ -117,9 +127,8 @@ void ButtonPoller::OnButtonStateChanged() {
if (!capture_button && m_capture_button_press_start) {
if (!m_capture_button_long_sent) {
const auto duration = ClassifyPressDuration(*m_capture_button_press_start);
m_window_system.OnSystemButtonPress(
duration == ButtonPressDuration::ShortPressing ? SystemButtonType::CaptureButtonShortPressing
: SystemButtonType::CaptureButtonLongPressing);
window_system.OnSystemButtonPress(duration == ButtonPressDuration::ShortPressing
? SystemButtonType::CaptureButtonShortPressing : SystemButtonType::CaptureButtonLongPressing);
}
m_capture_button_press_start = std::nullopt;
m_capture_button_long_sent = false;
@ -130,16 +139,4 @@ void ButtonPoller::OnButtonStateChanged() {
// }
}
void ButtonPoller::ThreadLoop() {
using namespace std::chrono_literals;
std::unique_lock lk{m_mutex};
while (!m_stop) {
m_cv.wait_for(lk, 50ms);
if (m_stop) break;
lk.unlock();
OnButtonStateChanged();
lk.lock();
}
}
} // namespace Service::AM

32
src/core/hle/service/am/button_poller.h
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@ -30,31 +30,23 @@ class ButtonPoller {
public:
explicit ButtonPoller(Core::System& system, WindowSystem& window_system);
~ButtonPoller();
void OnButtonStateChanged(WindowSystem& window_system);
private:
void OnButtonStateChanged();
void ThreadLoop();
private:
WindowSystem& m_window_system;
Core::HID::EmulatedController* m_handheld{};
int m_handheld_key{};
Core::HID::EmulatedController* m_player1{};
int m_player1_key{};
std::mutex m_mutex;
std::condition_variable m_cv;
std::jthread m_thread;
std::optional<std::chrono::steady_clock::time_point> m_home_button_press_start{};
std::optional<std::chrono::steady_clock::time_point> m_capture_button_press_start{};
std::optional<std::chrono::steady_clock::time_point> m_power_button_press_start{};
bool m_home_button_long_sent{};
bool m_capture_button_long_sent{};
bool m_power_button_long_sent{};
std::thread m_thread;
std::atomic<bool> m_stop{false};
std::condition_variable m_cv;
std::mutex m_mutex;
Core::HID::EmulatedController* m_handheld{};
Core::HID::EmulatedController* m_player1{};
int32_t m_handheld_key{};
int32_t m_player1_key{};
bool m_home_button_long_sent : 1 = false;
bool m_capture_button_long_sent : 1 = false;
bool m_power_button_long_sent : 1 = false;
};
} // namespace Service::AM

42
src/core/hle/service/am/event_observer.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -15,18 +18,30 @@ enum class UserDataTag : u32 {
};
EventObserver::EventObserver(Core::System& system, WindowSystem& window_system)
: m_system(system), m_context(system, "am:EventObserver"), m_window_system(window_system),
m_wakeup_event(m_context), m_wakeup_holder(m_wakeup_event.GetHandle()) {
: m_system(system), m_context(system, "am:EventObserver")
, m_window_system(window_system)
, m_wakeup_event(m_context)
, m_wakeup_holder(m_wakeup_event.GetHandle())
{
m_window_system.SetEventObserver(this);
m_wakeup_holder.SetUserData(static_cast<uintptr_t>(UserDataTag::WakeupEvent));
m_wakeup_holder.LinkToMultiWait(std::addressof(m_multi_wait));
m_thread = std::thread([&] { this->ThreadFunc(); });
m_thread = std::thread([this] {
Common::SetCurrentThreadName("am:EventObserver");
while (true) {
auto* signaled_holder = this->WaitSignaled();
if (!signaled_holder) {
break;
}
this->Process(signaled_holder);
}
});
}
EventObserver::~EventObserver() {
// Signal thread and wait for processing to finish.
m_stop_source.request_stop();
m_wakeup_event.Signal();
m_wakeup_event.Signal(m_system.Kernel());
m_thread.join();
// Free remaining owned sessions.
@ -61,11 +76,11 @@ void EventObserver::TrackAppletProcess(Applet& applet) {
}
// Signal wakeup.
m_wakeup_event.Signal();
m_wakeup_event.Signal(m_system.Kernel());
}
void EventObserver::RequestUpdate() {
m_wakeup_event.Signal();
m_wakeup_event.Signal(m_system.Kernel());
}
void EventObserver::LinkDeferred() {
@ -106,7 +121,7 @@ void EventObserver::Process(MultiWaitHolder* holder) {
}
void EventObserver::OnWakeupEvent(MultiWaitHolder* holder) {
m_wakeup_event.Clear();
m_wakeup_event.Clear(m_system.Kernel());
// Perform recalculation.
m_window_system.Update();
@ -146,17 +161,4 @@ void EventObserver::DestroyAppletProcessHolderLocked(ProcessHolder* holder) {
delete holder;
}
void EventObserver::ThreadFunc() {
Common::SetCurrentThreadName("am:EventObserver");
while (true) {
auto* signaled_holder = this->WaitSignaled();
if (!signaled_holder) {
break;
}
this->Process(signaled_holder);
}
}
} // namespace Service::AM

6
src/core/hle/service/am/event_observer.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -41,9 +44,6 @@ private:
private:
void DestroyAppletProcessHolderLocked(ProcessHolder* holder);
private:
void ThreadFunc();
private:
// System reference and context.
Core::System& m_system;

12
src/core/hle/service/am/frontend/applet_general.cpp
View file

@ -20,16 +20,16 @@ namespace Service::AM::Frontend {
constexpr Result ERROR_INVALID_PIN{ErrorModule::PCTL, 221};
static void LogCurrentStorage(std::shared_ptr<Applet> applet, std::string_view prefix) {
static void LogCurrentStorage(Kernel::KernelCore& kernel, std::shared_ptr<Applet> applet, std::string_view prefix) {
std::shared_ptr<IStorage> storage;
while (R_SUCCEEDED(applet->caller_applet_broker->GetInData().Pop(&storage))) {
while (R_SUCCEEDED(applet->caller_applet_broker->GetInData().Pop(kernel, &storage))) {
const auto data = storage->GetData();
LOG_INFO(Service_AM,
"called (STUBBED), during {} received normal data with size={:08X}, data={}",
prefix, data.size(), Common::HexToString(data));
}
while (R_SUCCEEDED(applet->caller_applet_broker->GetInteractiveInData().Pop(&storage))) {
while (R_SUCCEEDED(applet->caller_applet_broker->GetInteractiveInData().Pop(kernel, &storage))) {
const auto data = storage->GetData();
LOG_INFO(Service_AM,
"called (STUBBED), during {} received interactive data with size={:08X}, data={}",
@ -219,7 +219,7 @@ void StubApplet::Initialize() {
LOG_WARNING(Service_AM, "called (STUBBED)");
FrontendApplet::Initialize();
LogCurrentStorage(applet.lock(), "Initialize");
LogCurrentStorage(system.Kernel(), applet.lock(), "Initialize");
}
Result StubApplet::GetStatus() const {
@ -229,7 +229,7 @@ Result StubApplet::GetStatus() const {
void StubApplet::ExecuteInteractive() {
LOG_WARNING(Service_AM, "called (STUBBED)");
LogCurrentStorage(applet.lock(), "ExecuteInteractive");
LogCurrentStorage(system.Kernel(), applet.lock(), "ExecuteInteractive");
PushOutData(std::make_shared<IStorage>(system, std::vector<u8>(0x1000)));
PushInteractiveOutData(std::make_shared<IStorage>(system, std::vector<u8>(0x1000)));
@ -238,7 +238,7 @@ void StubApplet::ExecuteInteractive() {
void StubApplet::Execute() {
LOG_WARNING(Service_AM, "called (STUBBED)");
LogCurrentStorage(applet.lock(), "Execute");
LogCurrentStorage(system.Kernel(), applet.lock(), "Execute");
PushOutData(std::make_shared<IStorage>(system, std::vector<u8>(0x1000)));
PushInteractiveOutData(std::make_shared<IStorage>(system, std::vector<u8>(0x1000)));

12
src/core/hle/service/am/frontend/applets.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include <cstring>
@ -52,22 +52,22 @@ void FrontendApplet::Initialize() {
std::shared_ptr<IStorage> FrontendApplet::PopInData() {
std::shared_ptr<IStorage> ret;
applet.lock()->caller_applet_broker->GetInData().Pop(&ret);
applet.lock()->caller_applet_broker->GetInData().Pop(system.Kernel(), &ret);
return ret;
}
std::shared_ptr<IStorage> FrontendApplet::PopInteractiveInData() {
std::shared_ptr<IStorage> ret;
applet.lock()->caller_applet_broker->GetInteractiveInData().Pop(&ret);
applet.lock()->caller_applet_broker->GetInteractiveInData().Pop(system.Kernel(), &ret);
return ret;
}
void FrontendApplet::PushOutData(std::shared_ptr<IStorage> storage) {
applet.lock()->caller_applet_broker->GetOutData().Push(storage);
applet.lock()->caller_applet_broker->GetOutData().Push(system.Kernel(), storage);
}
void FrontendApplet::PushInteractiveOutData(std::shared_ptr<IStorage> storage) {
applet.lock()->caller_applet_broker->GetInteractiveOutData().Push(storage);
applet.lock()->caller_applet_broker->GetInteractiveOutData().Push(system.Kernel(), storage);
}
void FrontendApplet::Exit() {
@ -75,7 +75,7 @@ void FrontendApplet::Exit() {
std::scoped_lock lk{applet_->lock};
applet_->is_completed = true;
applet_->state_changed_event.Signal();
applet_->state_changed_event.Signal(system.Kernel());
}
FrontendAppletSet::FrontendAppletSet() = default;

38
src/core/hle/service/am/library_applet_storage.cpp
View file

@ -1,7 +1,11 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "core/hle/kernel/k_transfer_memory.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/service/am/am_results.h"
#include "core/hle/service/am/library_applet_storage.h"
#include "core/memory.h"
@ -55,15 +59,18 @@ private:
class TransferMemoryLibraryAppletStorage : public LibraryAppletStorage {
public:
explicit TransferMemoryLibraryAppletStorage(Core::Memory::Memory& memory,
Kernel::KTransferMemory* trmem, bool is_writable,
s64 size)
: m_memory(memory), m_trmem(trmem), m_is_writable(is_writable), m_size(size) {
m_trmem->Open();
explicit TransferMemoryLibraryAppletStorage(Kernel::KernelCore& kernel, Core::Memory::Memory& memory, Kernel::KTransferMemory* trmem, bool is_writable, s64 size)
: m_kernel{kernel}
, m_memory(memory)
, m_trmem(trmem)
, m_is_writable(is_writable)
, m_size(size)
{
m_trmem->Open(m_kernel);
}
~TransferMemoryLibraryAppletStorage() {
m_trmem->Close();
m_trmem->Close(m_kernel);
m_trmem = nullptr;
}
@ -93,6 +100,7 @@ public:
}
protected:
Kernel::KernelCore& m_kernel;
Core::Memory::Memory& m_memory;
Kernel::KTransferMemory* m_trmem;
bool m_is_writable;
@ -101,9 +109,9 @@ protected:
class HandleLibraryAppletStorage : public TransferMemoryLibraryAppletStorage {
public:
explicit HandleLibraryAppletStorage(Core::Memory::Memory& memory,
Kernel::KTransferMemory* trmem, s64 size)
: TransferMemoryLibraryAppletStorage(memory, trmem, true, size) {}
explicit HandleLibraryAppletStorage(Kernel::KernelCore& kernel, Core::Memory::Memory& memory, Kernel::KTransferMemory* trmem, s64 size)
: TransferMemoryLibraryAppletStorage(kernel, memory, trmem, true, size)
{}
~HandleLibraryAppletStorage() = default;
Kernel::KTransferMemory* GetHandle() override {
@ -125,16 +133,12 @@ std::shared_ptr<LibraryAppletStorage> CreateStorage(std::vector<u8>&& data) {
return std::make_shared<BufferLibraryAppletStorage>(std::move(data));
}
std::shared_ptr<LibraryAppletStorage> CreateTransferMemoryStorage(Core::Memory::Memory& memory,
Kernel::KTransferMemory* trmem,
bool is_writable, s64 size) {
return std::make_shared<TransferMemoryLibraryAppletStorage>(memory, trmem, is_writable, size);
std::shared_ptr<LibraryAppletStorage> CreateTransferMemoryStorage(Kernel::KernelCore& kernel, Core::Memory::Memory& memory, Kernel::KTransferMemory* trmem, bool is_writable, s64 size) {
return std::make_shared<TransferMemoryLibraryAppletStorage>(kernel, memory, trmem, is_writable, size);
}
std::shared_ptr<LibraryAppletStorage> CreateHandleStorage(Core::Memory::Memory& memory,
Kernel::KTransferMemory* trmem,
s64 size) {
return std::make_shared<HandleLibraryAppletStorage>(memory, trmem, size);
std::shared_ptr<LibraryAppletStorage> CreateHandleStorage(Kernel::KernelCore& kernel, Core::Memory::Memory& memory, Kernel::KTransferMemory* trmem, s64 size) {
return std::make_shared<HandleLibraryAppletStorage>(kernel, memory, trmem, size);
}
} // namespace Service::AM

11
src/core/hle/service/am/library_applet_storage.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -10,6 +13,7 @@ class Memory;
}
namespace Kernel {
class KernelCore;
class KTransferMemory;
}
@ -27,10 +31,7 @@ public:
};
std::shared_ptr<LibraryAppletStorage> CreateStorage(std::vector<u8>&& data);
std::shared_ptr<LibraryAppletStorage> CreateTransferMemoryStorage(Core::Memory::Memory& memory,
Kernel::KTransferMemory* trmem,
bool is_writable, s64 size);
std::shared_ptr<LibraryAppletStorage> CreateHandleStorage(Core::Memory::Memory& memory,
Kernel::KTransferMemory* trmem, s64 size);
std::shared_ptr<LibraryAppletStorage> CreateTransferMemoryStorage(Kernel::KernelCore& kernel, Core::Memory::Memory& memory, Kernel::KTransferMemory* trmem, bool is_writable, s64 size);
std::shared_ptr<LibraryAppletStorage> CreateHandleStorage(Kernel::KernelCore& kernel, Core::Memory::Memory& memory, Kernel::KTransferMemory* trmem, s64 size);
} // namespace Service::AM

20
src/core/hle/service/am/lifecycle_manager.cpp
View file

@ -28,9 +28,9 @@ Event& LifecycleManager::GetHDCPStateChangedEvent() {
return m_hdcp_state_changed_event;
}
void LifecycleManager::PushUnorderedMessage(AppletMessage message) {
void LifecycleManager::PushUnorderedMessage(Kernel::KernelCore& kernel, AppletMessage message) {
m_unordered_messages.push_back(message);
this->SignalSystemEventIfNeeded();
this->SignalSystemEventIfNeeded(kernel);
}
AppletMessage LifecycleManager::PopMessageInOrderOfPriority() {
@ -144,36 +144,36 @@ bool LifecycleManager::ShouldSignalSystemEvent() {
m_has_album_screen_shot_taken || m_has_album_recording_saved;
}
void LifecycleManager::OnOperationAndPerformanceModeChanged() {
void LifecycleManager::OnOperationAndPerformanceModeChanged(Kernel::KernelCore& kernel) {
if (m_operation_mode_changed_notification_enabled) {
m_has_operation_mode_changed = true;
}
if (m_performance_mode_changed_notification_enabled) {
m_has_performance_mode_changed = true;
}
m_operation_mode_changed_system_event.Signal();
this->SignalSystemEventIfNeeded();
m_operation_mode_changed_system_event.Signal(kernel);
this->SignalSystemEventIfNeeded(kernel);
}
void LifecycleManager::SignalSystemEventIfNeeded() {
void LifecycleManager::SignalSystemEventIfNeeded(Kernel::KernelCore& kernel) {
// Check our cached value for the system event.
const bool applet_message_available = m_applet_message_available;
// If it's not current, we need to do an update, either clearing or signaling.
if (applet_message_available != this->ShouldSignalSystemEvent()) {
if (!applet_message_available) {
m_system_event.Signal();
m_system_event.Signal(kernel);
m_applet_message_available = true;
} else {
m_system_event.Clear();
m_system_event.Clear(kernel);
m_applet_message_available = false;
}
}
}
bool LifecycleManager::PopMessage(AppletMessage* out_message) {
bool LifecycleManager::PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message) {
const auto message = this->PopMessageInOrderOfPriority();
this->SignalSystemEventIfNeeded();
this->SignalSystemEventIfNeeded(kernel);
*out_message = message;
return message != AppletMessage::None;

31
src/core/hle/service/am/lifecycle_manager.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -66,17 +69,17 @@ public:
return m_acknowledged_focus_state;
}
void SetFocusState(FocusState state) {
void SetFocusState(Kernel::KernelCore& kernel, FocusState state) {
if (m_requested_focus_state != state) {
m_has_focus_state_changed = true;
}
m_requested_focus_state = state;
this->SignalSystemEventIfNeeded();
this->SignalSystemEventIfNeeded(kernel);
}
void RequestExit() {
void RequestExit(Kernel::KernelCore& kernel) {
m_has_requested_exit = true;
this->SignalSystemEventIfNeeded();
this->SignalSystemEventIfNeeded(kernel);
}
void RequestResumeNotification() {
@ -89,22 +92,22 @@ public:
}
}
void OnOperationAndPerformanceModeChanged();
void OnOperationAndPerformanceModeChanged(Kernel::KernelCore& kernel);
public:
void SetFocusStateChangedNotificationEnabled(bool enabled) {
void SetFocusStateChangedNotificationEnabled(Kernel::KernelCore& kernel, bool enabled) {
m_focus_state_changed_notification_enabled = enabled;
this->SignalSystemEventIfNeeded();
this->SignalSystemEventIfNeeded(kernel);
}
void SetOperationModeChangedNotificationEnabled(bool enabled) {
void SetOperationModeChangedNotificationEnabled(Kernel::KernelCore& kernel, bool enabled) {
m_operation_mode_changed_notification_enabled = enabled;
this->SignalSystemEventIfNeeded();
this->SignalSystemEventIfNeeded(kernel);
}
void SetPerformanceModeChangedNotificationEnabled(bool enabled) {
void SetPerformanceModeChangedNotificationEnabled(Kernel::KernelCore& kernel, bool enabled) {
m_performance_mode_changed_notification_enabled = enabled;
this->SignalSystemEventIfNeeded();
this->SignalSystemEventIfNeeded(kernel);
}
void SetResumeNotificationEnabled(bool enabled) {
@ -129,11 +132,11 @@ public:
void RemoveForceResumeIfPossible();
bool IsRunnable() const;
bool UpdateRequestedFocusState();
void SignalSystemEventIfNeeded();
void SignalSystemEventIfNeeded(Kernel::KernelCore& kernel);
public:
void PushUnorderedMessage(AppletMessage message);
bool PopMessage(AppletMessage* out_message);
void PushUnorderedMessage(Kernel::KernelCore& kernel, AppletMessage message);
bool PopMessage(Kernel::KernelCore& kernel, AppletMessage* out_message);
private:
FocusState GetFocusStateWhileForegroundObscured() const;

99
src/core/hle/service/am/process_creation.cpp
View file

@ -1,6 +1,10 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include <optional>
#include "core/core.h"
#include "core/file_sys/content_archive.h"
#include "core/file_sys/nca_metadata.h"
@ -16,7 +20,7 @@ namespace Service::AM {
namespace {
FileSys::StorageId GetStorageIdForFrontendSlot(
[[nodiscard]] FileSys::StorageId GetStorageIdForFrontendSlot(
std::optional<FileSys::ContentProviderUnionSlot> slot) {
if (!slot.has_value()) {
return FileSys::StorageId::None;
@ -36,31 +40,23 @@ FileSys::StorageId GetStorageIdForFrontendSlot(
}
}
std::unique_ptr<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader,
Loader::ResultStatus& out_load_result,
Core::System& system, FileSys::VirtualFile file,
u64 program_id, u64 program_index) {
[[nodiscard]] inline std::optional<Process> CreateProcessImpl(std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
// Get the appropriate loader to parse this NCA.
out_loader = Loader::GetLoader(system, file, program_id, program_index);
// Ensure we have a loader which can parse the NCA.
if (!out_loader) {
return nullptr;
if (out_loader) {
// Try to load the process.
auto process = std::make_optional<Process>(system);
if (process->Initialize(*out_loader, out_load_result)) {
return process;
}
}
// Try to load the process.
auto process = std::make_unique<Process>(system);
if (process->Initialize(*out_loader, out_load_result)) {
return process;
}
return nullptr;
return std::nullopt;
}
} // Anonymous namespace
std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id,
u8 minimum_key_generation, u8 maximum_key_generation) {
std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation) {
// Attempt to load program NCA.
FileSys::VirtualFile nca_raw{};
@ -70,7 +66,7 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id,
// Ensure we retrieved a program NCA.
if (!nca_raw) {
return nullptr;
return std::nullopt;
}
// Ensure we have a suitable version.
@ -79,9 +75,8 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id,
if (nca.GetStatus() == Loader::ResultStatus::Success &&
(nca.GetKeyGeneration() < minimum_key_generation ||
nca.GetKeyGeneration() > maximum_key_generation)) {
LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id,
nca.GetKeyGeneration());
return nullptr;
LOG_WARNING(Service_LDR, "Skipping program {:016X} with generation {}", program_id, nca.GetKeyGeneration());
return std::nullopt;
}
}
@ -90,42 +85,32 @@ std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id,
return CreateProcessImpl(loader, status, system, nca_raw, program_id, 0);
}
std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control,
std::unique_ptr<Loader::AppLoader>& out_loader,
Loader::ResultStatus& out_load_result,
Core::System& system, FileSys::VirtualFile file,
u64 program_id, u64 program_index) {
auto process =
CreateProcessImpl(out_loader, out_load_result, system, file, program_id, program_index);
if (!process) {
return nullptr;
std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index) {
if (auto process = CreateProcessImpl(out_loader, out_load_result, system, file, program_id, program_index); process) {
FileSys::NACP nacp;
if (out_loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
out_control = nacp.GetRawBytes();
} else {
out_control.resize(sizeof(FileSys::RawNACP));
std::fill(out_control.begin(), out_control.end(), (u8) 0);
}
auto& storage = system.GetContentProviderUnion();
Service::Glue::ApplicationLaunchProperty launch{};
launch.title_id = process->GetProgramId();
FileSys::PatchManager pm{launch.title_id, system.GetFileSystemController(), storage};
launch.version = pm.GetGameVersion().value_or(0);
// TODO(DarkLordZach): When FSController/Game Card Support is added, if
// current_process_game_card use correct StorageId
launch.base_game_storage_id = GetStorageIdForFrontendSlot(storage.GetSlotForEntry(launch.title_id, FileSys::ContentRecordType::Program));
launch.update_storage_id = GetStorageIdForFrontendSlot(storage.GetSlotForEntry(FileSys::GetUpdateTitleID(launch.title_id), FileSys::ContentRecordType::Program));
system.GetARPManager().Register(launch.title_id, launch, out_control);
return process;
}
FileSys::NACP nacp;
if (out_loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
out_control = nacp.GetRawBytes();
} else {
out_control.resize(sizeof(FileSys::RawNACP));
std::fill(out_control.begin(), out_control.end(), (u8) 0);
}
auto& storage = system.GetContentProviderUnion();
Service::Glue::ApplicationLaunchProperty launch{};
launch.title_id = process->GetProgramId();
FileSys::PatchManager pm{launch.title_id, system.GetFileSystemController(), storage};
launch.version = pm.GetGameVersion().value_or(0);
// TODO(DarkLordZach): When FSController/Game Card Support is added, if
// current_process_game_card use correct StorageId
launch.base_game_storage_id = GetStorageIdForFrontendSlot(
storage.GetSlotForEntry(launch.title_id, FileSys::ContentRecordType::Program));
launch.update_storage_id = GetStorageIdForFrontendSlot(storage.GetSlotForEntry(
FileSys::GetUpdateTitleID(launch.title_id), FileSys::ContentRecordType::Program));
system.GetARPManager().Register(launch.title_id, launch, out_control);
return process;
return std::nullopt;
}
} // namespace Service::AM

12
src/core/hle/service/am/process_creation.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -24,12 +27,7 @@ class Process;
namespace Service::AM {
std::unique_ptr<Process> CreateProcess(Core::System& system, u64 program_id,
u8 minimum_key_generation, u8 maximum_key_generation);
std::unique_ptr<Process> CreateApplicationProcess(std::vector<u8>& out_control,
std::unique_ptr<Loader::AppLoader>& out_loader,
Loader::ResultStatus& out_load_result,
Core::System& system, FileSys::VirtualFile file,
u64 program_id, u64 program_index);
std::optional<Process> CreateProcess(Core::System& system, u64 program_id, u8 minimum_key_generation, u8 maximum_key_generation);
std::optional<Process> CreateApplicationProcess(std::vector<u8>& out_control, std::unique_ptr<Loader::AppLoader>& out_loader, Loader::ResultStatus& out_load_result, Core::System& system, FileSys::VirtualFile file, u64 program_id, u64 program_index);
} // namespace Service::AM

4
src/core/hle/service/am/service/application_accessor.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@ -69,7 +69,7 @@ Result IApplicationAccessor::RequestExit() {
std::scoped_lock lk{m_applet->lock};
if (m_applet->exit_locked) {
m_applet->lifecycle_manager.RequestExit();
m_applet->lifecycle_manager.RequestExit(system.Kernel());
m_applet->UpdateSuspensionStateLocked(true);
} else {
m_applet->process->Terminate();

24
src/core/hle/service/am/service/application_creator.cpp
View file

@ -21,8 +21,7 @@ namespace Service::AM {
namespace {
Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_application_accessor,
Core::System& system, WindowSystem& window_system, u64 program_id) {
Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_application_accessor, Core::System& system, WindowSystem& window_system, u64 program_id) {
FileSys::VirtualFile nca_raw{};
// Get the program NCA from storage.
@ -35,11 +34,10 @@ Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_applicati
std::vector<u8> control;
std::unique_ptr<Loader::AppLoader> loader;
Loader::ResultStatus result;
auto process =
CreateApplicationProcess(control, loader, result, system, nca_raw, program_id, 0);
R_UNLESS(process != nullptr, ResultUnknown);
auto process = CreateApplicationProcess(control, loader, result, system, nca_raw, program_id, 0);
R_UNLESS(process != std::nullopt, ResultUnknown);
const auto applet = std::make_shared<Applet>(system, std::move(process), true);
const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
applet->program_id = program_id;
applet->applet_id = AppletId::Application;
applet->type = AppletType::Application;
@ -47,8 +45,7 @@ Result CreateGuestApplication(SharedPointer<IApplicationAccessor>* out_applicati
window_system.TrackApplet(applet, true);
*out_application_accessor =
std::make_shared<IApplicationAccessor>(system, applet, window_system);
*out_application_accessor = std::make_shared<IApplicationAccessor>(system, applet, window_system);
R_SUCCEED();
}
@ -90,12 +87,10 @@ Result IApplicationCreator::CreateSystemApplication(
std::vector<u8> control;
std::unique_ptr<Loader::AppLoader> loader;
auto process = CreateProcess(system, application_id, 1, 22);
R_UNLESS(process != std::nullopt, ResultUnknown);
auto process =
CreateProcess(system, application_id, 1, 22);
R_UNLESS(process != nullptr, ResultUnknown);
const auto applet = std::make_shared<Applet>(system, std::move(process), true);
const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), true);
applet->program_id = application_id;
applet->applet_id = AppletId::Starter;
applet->type = AppletType::LibraryApplet;
@ -103,8 +98,7 @@ Result IApplicationCreator::CreateSystemApplication(
m_window_system.TrackApplet(applet, true);
*out_application_accessor =
std::make_shared<IApplicationAccessor>(system, applet, m_window_system);
*out_application_accessor = std::make_shared<IApplicationAccessor>(system, applet, m_window_system);
Core::LaunchTimestampCache::SaveLaunchTimestamp(application_id);
R_SUCCEED();
}

16
src/core/hle/service/am/service/common_state_getter.cpp
View file

@ -99,7 +99,7 @@ Result ICommonStateGetter::GetEventHandle(OutCopyHandle<Kernel::KReadableEvent>
Result ICommonStateGetter::ReceiveMessage(Out<AppletMessage> out_applet_message) {
LOG_DEBUG(Service_AM, "called");
if (!m_applet->lifecycle_manager.PopMessage(out_applet_message)) {
if (!m_applet->lifecycle_manager.PopMessage(system.Kernel(), out_applet_message)) {
LOG_ERROR(Service_AM, "Tried to pop message but none was available!");
R_THROW(AM::ResultNoMessages);
}
@ -123,21 +123,21 @@ Result ICommonStateGetter::RequestToAcquireSleepLock() {
LOG_WARNING(Service_AM, "(STUBBED) called");
// Sleep lock is acquired immediately.
m_applet->sleep_lock_event.Signal();
m_applet->sleep_lock_event.Signal(system.Kernel());
R_SUCCEED();
}
Result ICommonStateGetter::ReleaseSleepLock() {
LOG_WARNING(Service_AM, "(STUBBED) called");
m_applet->sleep_lock_event.Clear();
m_applet->sleep_lock_event.Clear(system.Kernel());
R_SUCCEED();
}
Result ICommonStateGetter::ReleaseSleepLockTransiently() {
LOG_WARNING(Service_AM, "(STUBBED) called");
m_applet->sleep_lock_event.Clear();
m_applet->sleep_lock_event.Clear(system.Kernel());
R_SUCCEED();
}
@ -281,25 +281,25 @@ Result ICommonStateGetter::PerformSystemButtonPressingIfInFocus(SystemButtonType
switch (type) {
case SystemButtonType::HomeButtonShortPressing:
if (!m_applet->home_button_short_pressed_blocked) {
m_applet->lifecycle_manager.PushUnorderedMessage(
m_applet->lifecycle_manager.PushUnorderedMessage(system.Kernel(),
AppletMessage::DetectShortPressingHomeButton);
}
break;
case SystemButtonType::HomeButtonLongPressing:
if (!m_applet->home_button_long_pressed_blocked) {
m_applet->lifecycle_manager.PushUnorderedMessage(
m_applet->lifecycle_manager.PushUnorderedMessage(system.Kernel(),
AppletMessage::DetectLongPressingHomeButton);
}
break;
case SystemButtonType::CaptureButtonShortPressing:
if (m_applet->handling_capture_button_short_pressed_message_enabled_for_applet) {
m_applet->lifecycle_manager.PushUnorderedMessage(
m_applet->lifecycle_manager.PushUnorderedMessage(system.Kernel(),
AppletMessage::DetectShortPressingCaptureButton);
}
break;
case SystemButtonType::CaptureButtonLongPressing:
if (m_applet->handling_capture_button_long_pressed_message_enabled_for_applet) {
m_applet->lifecycle_manager.PushUnorderedMessage(
m_applet->lifecycle_manager.PushUnorderedMessage(system.Kernel(),
AppletMessage::DetectLongPressingCaptureButton);
}
break;

14
src/core/hle/service/am/service/library_applet_accessor.cpp
View file

@ -123,7 +123,7 @@ Result ILibraryAppletAccessor::RequestExit() {
LOG_DEBUG(Service_AM, "called");
{
std::scoped_lock lk{m_applet->lock};
m_applet->lifecycle_manager.RequestExit();
m_applet->lifecycle_manager.RequestExit(system.Kernel());
}
FrontendRequestExit();
R_SUCCEED();
@ -157,7 +157,7 @@ Result ILibraryAppletAccessor::PushInData(SharedPointer<IStorage> storage) {
}
}
m_broker->GetInData().Push(storage);
m_broker->GetInData().Push(system.Kernel(), storage);
R_SUCCEED();
}
@ -165,13 +165,13 @@ Result ILibraryAppletAccessor::PopOutData(Out<SharedPointer<IStorage>> out_stora
LOG_DEBUG(Service_AM, "called");
if (auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
caller_applet->lifecycle_manager.GetSystemEvent().Signal();
caller_applet->lifecycle_manager.GetSystemEvent().Signal(system.Kernel());
caller_applet->lifecycle_manager.RequestResumeNotification();
caller_applet->lifecycle_manager.GetSystemEvent().Clear();
caller_applet->lifecycle_manager.GetSystemEvent().Clear(system.Kernel());
caller_applet->lifecycle_manager.UpdateRequestedFocusState();
}
R_TRY(m_broker->GetOutData().Pop(out_storage.Get()));
R_TRY(m_broker->GetOutData().Pop(system.Kernel(), out_storage.Get()));
if (m_applet->applet_id == AppletId::ProfileSelect && *out_storage) {
auto impl = (*out_storage)->GetImpl();
@ -186,14 +186,14 @@ Result ILibraryAppletAccessor::PopOutData(Out<SharedPointer<IStorage>> out_stora
Result ILibraryAppletAccessor::PushInteractiveInData(SharedPointer<IStorage> storage) {
LOG_DEBUG(Service_AM, "called");
m_broker->GetInteractiveInData().Push(storage);
m_broker->GetInteractiveInData().Push(system.Kernel(), storage);
FrontendExecuteInteractive();
R_SUCCEED();
}
Result ILibraryAppletAccessor::PopInteractiveOutData(Out<SharedPointer<IStorage>> out_storage) {
LOG_DEBUG(Service_AM, "called");
R_RETURN(m_broker->GetInteractiveOutData().Pop(out_storage.Get()));
R_RETURN(m_broker->GetInteractiveOutData().Pop(system.Kernel(), out_storage.Get()));
}
Result ILibraryAppletAccessor::GetPopOutDataEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {

43
src/core/hle/service/am/service/library_applet_creator.cpp
View file

@ -122,26 +122,23 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
};
auto process = CreateProcess(system, program_id, Firmware1400, Firmware2200);
if (!process) {
// Couldn't initialize the guest process
return {};
if (process) {
const auto applet = std::make_shared<Applet>(system, std::make_unique<Service::Process>(*std::move(process)), false);
applet->program_id = program_id;
applet->applet_id = applet_id;
applet->type = AppletType::LibraryApplet;
applet->library_applet_mode = mode;
applet->window_visible = mode != LibraryAppletMode::AllForegroundInitiallyHidden;
auto broker = std::make_shared<AppletDataBroker>(system);
applet->caller_applet = caller_applet;
applet->caller_applet_broker = broker;
caller_applet->child_applets.push_back(applet);
window_system.TrackApplet(applet, false);
return std::make_shared<ILibraryAppletAccessor>(system, broker, applet);
}
const auto applet = std::make_shared<Applet>(system, std::move(process), false);
applet->program_id = program_id;
applet->applet_id = applet_id;
applet->type = AppletType::LibraryApplet;
applet->library_applet_mode = mode;
applet->window_visible = mode != LibraryAppletMode::AllForegroundInitiallyHidden;
auto broker = std::make_shared<AppletDataBroker>(system);
applet->caller_applet = caller_applet;
applet->caller_applet_broker = broker;
caller_applet->child_applets.push_back(applet);
window_system.TrackApplet(applet, false);
return std::make_shared<ILibraryAppletAccessor>(system, broker, applet);
// Couldn't initialize the guest process
return {};
}
std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& system,
@ -210,7 +207,7 @@ Result ILibraryAppletCreator::CreateLibraryApplet(
}
// Applet is created, can now be launched.
m_applet->library_applet_launchable_event.Signal();
m_applet->library_applet_launchable_event.Signal(system.Kernel());
*out_library_applet_accessor = library_applet;
R_SUCCEED();
}
@ -236,7 +233,7 @@ Result ILibraryAppletCreator::CreateLibraryAppletEx(
}
// Applet is created, can now be launched.
m_applet->library_applet_launchable_event.Signal();
m_applet->library_applet_launchable_event.Signal(system.Kernel());
*out_library_applet_accessor = library_applet;
R_SUCCEED();
}
@ -269,7 +266,7 @@ Result ILibraryAppletCreator::CreateTransferMemoryStorage(
}
*out_storage = std::make_shared<IStorage>(
system, AM::CreateTransferMemoryStorage(transfer_memory_handle->GetOwner()->GetMemory(),
system, AM::CreateTransferMemoryStorage(system.Kernel(), transfer_memory_handle->GetOwner()->GetMemory(),
transfer_memory_handle.Get(), is_writable, size));
R_SUCCEED();
}
@ -290,7 +287,7 @@ Result ILibraryAppletCreator::CreateHandleStorage(
}
*out_storage = std::make_shared<IStorage>(
system, AM::CreateHandleStorage(transfer_memory_handle->GetOwner()->GetMemory(),
system, AM::CreateHandleStorage(system.Kernel(), transfer_memory_handle->GetOwner()->GetMemory(),
transfer_memory_handle.Get(), size));
R_SUCCEED();
}

8
src/core/hle/service/am/service/library_applet_self_accessor.cpp
View file

@ -93,23 +93,23 @@ ILibraryAppletSelfAccessor::~ILibraryAppletSelfAccessor() = default;
Result ILibraryAppletSelfAccessor::PopInData(Out<SharedPointer<IStorage>> out_storage) {
LOG_INFO(Service_AM, "called");
R_RETURN(m_broker->GetInData().Pop(out_storage));
R_RETURN(m_broker->GetInData().Pop(system.Kernel(), out_storage));
}
Result ILibraryAppletSelfAccessor::PushOutData(SharedPointer<IStorage> storage) {
LOG_INFO(Service_AM, "called");
m_broker->GetOutData().Push(storage);
m_broker->GetOutData().Push(system.Kernel(), storage);
R_SUCCEED();
}
Result ILibraryAppletSelfAccessor::PopInteractiveInData(Out<SharedPointer<IStorage>> out_storage) {
LOG_INFO(Service_AM, "called");
R_RETURN(m_broker->GetInteractiveInData().Pop(out_storage));
R_RETURN(m_broker->GetInteractiveInData().Pop(system.Kernel(), out_storage));
}
Result ILibraryAppletSelfAccessor::PushInteractiveOutData(SharedPointer<IStorage> storage) {
LOG_INFO(Service_AM, "called");
m_broker->GetInteractiveOutData().Push(storage);
m_broker->GetInteractiveOutData().Push(system.Kernel(), storage);
R_SUCCEED();
}

7
src/core/hle/service/am/service/lock_accessor.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -20,7 +23,7 @@ ILockAccessor::ILockAccessor(Core::System& system_)
RegisterHandlers(functions);
m_event.Signal();
m_event.Signal(system.Kernel());
}
ILockAccessor::~ILockAccessor() = default;
@ -55,7 +58,7 @@ Result ILockAccessor::Unlock() {
m_is_locked = false;
}
m_event.Signal();
m_event.Signal(system.Kernel());
R_SUCCEED();
}

8
src/core/hle/service/am/service/self_controller.cpp
View file

@ -151,7 +151,7 @@ Result ISelfController::GetLibraryAppletLaunchableEvent(
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_AM, "(STUBBED) called");
m_applet->library_applet_launchable_event.Signal();
m_applet->library_applet_launchable_event.Signal(system.Kernel());
*out_event = m_applet->library_applet_launchable_event.GetHandle();
R_SUCCEED();
@ -170,7 +170,7 @@ Result ISelfController::SetOperationModeChangedNotification(bool enabled) {
LOG_INFO(Service_AM, "called, enabled={}", enabled);
std::scoped_lock lk{m_applet->lock};
m_applet->lifecycle_manager.SetOperationModeChangedNotificationEnabled(enabled);
m_applet->lifecycle_manager.SetOperationModeChangedNotificationEnabled(system.Kernel(), enabled);
R_SUCCEED();
}
@ -179,7 +179,7 @@ Result ISelfController::SetPerformanceModeChangedNotification(bool enabled) {
LOG_INFO(Service_AM, "called, enabled={}", enabled);
std::scoped_lock lk{m_applet->lock};
m_applet->lifecycle_manager.SetPerformanceModeChangedNotificationEnabled(enabled);
m_applet->lifecycle_manager.SetPerformanceModeChangedNotificationEnabled(system.Kernel(), enabled);
R_SUCCEED();
}
@ -188,7 +188,7 @@ Result ISelfController::SetFocusHandlingMode(bool notify, bool background, bool
LOG_INFO(Service_AM, "called, notify={} background={} suspend={}", notify, background, suspend);
std::scoped_lock lk{m_applet->lock};
m_applet->lifecycle_manager.SetFocusStateChangedNotificationEnabled(notify);
m_applet->lifecycle_manager.SetFocusStateChangedNotificationEnabled(system.Kernel(), notify);
m_applet->lifecycle_manager.SetFocusHandlingMode(suspend);
m_applet->UpdateSuspensionStateLocked(true);

13
src/core/hle/service/am/window_system.cpp
View file

@ -154,7 +154,7 @@ void WindowSystem::OnOperationModeChanged() {
for (const auto& [aruid, applet] : m_applets) {
std::scoped_lock lk2{applet->lock};
applet->lifecycle_manager.OnOperationAndPerformanceModeChanged();
applet->lifecycle_manager.OnOperationAndPerformanceModeChanged(m_system.Kernel());
}
}
@ -163,22 +163,22 @@ void WindowSystem::OnExitRequested() {
for (const auto& [aruid, applet] : m_applets) {
std::scoped_lock lk2{applet->lock};
applet->lifecycle_manager.RequestExit();
applet->lifecycle_manager.RequestExit(m_system.Kernel());
}
}
void WindowSystem::SendButtonAppletMessageLocked(AppletMessage message) {
if (m_home_menu) {
std::scoped_lock lk_home{m_home_menu->lock};
m_home_menu->lifecycle_manager.PushUnorderedMessage(message);
m_home_menu->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), message);
}
if (m_overlay_display) {
std::scoped_lock lk_overlay{m_overlay_display->lock};
m_overlay_display->lifecycle_manager.PushUnorderedMessage(message);
m_overlay_display->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), message);
}
if (m_application) {
std::scoped_lock lk_application{m_application->lock};
m_application->lifecycle_manager.PushUnorderedMessage(message);
m_application->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), message);
}
if (m_event_observer) {
m_event_observer->RequestUpdate();
@ -277,8 +277,7 @@ void WindowSystem::PruneTerminatedAppletsLocked() {
// If we have a home menu, send it the application exited message.
if (m_home_menu) {
m_home_menu->lifecycle_manager.PushUnorderedMessage(
AppletMessage::ApplicationExited);
m_home_menu->lifecycle_manager.PushUnorderedMessage(m_system.Kernel(), AppletMessage::ApplicationExited);
}
}

4
src/core/hle/service/audio/audio_device.cpp
View file

@ -42,7 +42,7 @@ IAudioDevice::IAudioDevice(Core::System& system_, u64 applet_resource_user_id, u
};
RegisterHandlers(functions);
event->Signal();
event->Signal(system.Kernel());
}
IAudioDevice::~IAudioDevice() {
@ -128,7 +128,7 @@ Result IAudioDevice::GetActiveAudioDeviceNameAuto(
Result IAudioDevice::QueryAudioDeviceSystemEvent(OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_DEBUG(Service_Audio, "(STUBBED) called");
event->Signal();
event->Signal(system.Kernel());
*out_event = &event->GetReadableEvent();
R_SUCCEED();
}

7
src/core/hle/service/audio/audio_in.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -37,7 +40,7 @@ IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
RegisterHandlers(functions);
process->Open();
process->Open(system.Kernel());
if (impl->GetSystem()
.Initialize(device_name, in_params, handle, applet_resource_user_id)
@ -49,7 +52,7 @@ IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
IAudioIn::~IAudioIn() {
impl->Free();
service_context.CloseEvent(event);
process->Close();
process->Close(system.Kernel());
}
Result IAudioIn::GetAudioInState(Out<u32> out_state) {

7
src/core/hle/service/audio/audio_out.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -39,13 +42,13 @@ IAudioOut::IAudioOut(Core::System& system_, Manager& manager, size_t session_id,
// clang-format on
RegisterHandlers(functions);
process->Open();
process->Open(system.Kernel());
}
IAudioOut::~IAudioOut() {
impl->Free();
service_context.CloseEvent(event);
process->Close();
process->Close(system.Kernel());
}
Result IAudioOut::GetAudioOutState(Out<u32> out_state) {

6
src/core/hle/service/audio/audio_out_manager.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@ -14,7 +14,9 @@ namespace Service::Audio {
using namespace AudioCore::AudioOut;
IAudioOutManager::IAudioOutManager(Core::System& system_)
: ServiceFramework{system_, "audout:u"}, impl{std::make_unique<Manager>(system_)} {
: ServiceFramework{system_, "audout:u"}
, impl(system_)
{
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IAudioOutManager::ListAudioOuts>, "ListAudioOuts"},

4
src/core/hle/service/audio/audio_out_manager.h
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@ -43,7 +43,7 @@ private:
AudioCore::AudioOut::AudioOutParameter parameter,
InCopyHandle<Kernel::KProcess> process_handle, ClientAppletResourceUserId aruid);
std::unique_ptr<AudioCore::AudioOut::Manager> impl;
std::optional<AudioCore::AudioOut::Manager> impl;
};
} // namespace Service::Audio

6
src/core/hle/service/audio/audio_renderer.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@ -39,7 +39,7 @@ IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
// clang-format on
RegisterHandlers(functions);
process_handle->Open();
process_handle->Open(system_.Kernel());
impl->Initialize(params, transfer_memory, transfer_memory_size, process_handle,
applet_resource_user_id, session_id);
}
@ -47,7 +47,7 @@ IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
IAudioRenderer::~IAudioRenderer() {
impl->Finalize();
service_context.CloseEvent(rendered_event);
process_handle->Close();
process_handle->Close(system.Kernel());
}
Result IAudioRenderer::GetSampleRate(Out<u32> out_sample_rate) {

7
src/core/hle/service/audio/audio_renderer_manager.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -15,7 +18,9 @@ namespace Service::Audio {
using namespace AudioCore::Renderer;
IAudioRendererManager::IAudioRendererManager(Core::System& system_)
: ServiceFramework{system_, "audren:u"}, impl{std::make_unique<Manager>(system_)} {
: ServiceFramework{system_, "audren:u"}
, impl(system_)
{
// clang-format off
static const FunctionInfo functions[] = {
{0, D<&IAudioRendererManager::OpenAudioRenderer>, "OpenAudioRenderer"},

5
src/core/hle/service/audio/audio_renderer_manager.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -30,7 +33,7 @@ private:
Result GetAudioDeviceServiceWithRevisionInfo(Out<SharedPointer<IAudioDevice>> out_audio_device,
u32 revision, ClientAppletResourceUserId aruid);
std::unique_ptr<AudioCore::Renderer::Manager> impl;
std::optional<AudioCore::Renderer::Manager> impl;
u32 num_audio_devices{0};
};

83
src/core/hle/service/bcat/backend/backend.cpp
View file

@ -13,9 +13,9 @@
namespace Service::BCAT {
ProgressServiceBackend::ProgressServiceBackend(Core::System& system, std::string_view event_name)
: service_context{system, "ProgressServiceBackend"} {
update_event = service_context.CreateEvent("ProgressServiceBackend:UpdateEvent:" +
std::string(event_name));
: service_context{system, "ProgressServiceBackend"}
{
update_event = service_context.CreateEvent("ProgressServiceBackend:UpdateEvent:" + std::string(event_name));
}
ProgressServiceBackend::~ProgressServiceBackend() {
@ -30,103 +30,90 @@ DeliveryCacheProgressImpl& ProgressServiceBackend::GetImpl() {
return impl;
}
void ProgressServiceBackend::SetTotalSize(u64 size) {
void ProgressServiceBackend::SetTotalSize(Kernel::KernelCore& kernel, u64 size) {
impl.total_bytes = size;
SignalUpdate();
SignalUpdate(kernel);
}
void ProgressServiceBackend::StartConnecting() {
void ProgressServiceBackend::StartConnecting(Kernel::KernelCore& kernel) {
impl.status = DeliveryCacheProgressStatus::Connecting;
SignalUpdate();
SignalUpdate(kernel);
}
void ProgressServiceBackend::StartProcessingDataList() {
void ProgressServiceBackend::StartProcessingDataList(Kernel::KernelCore& kernel) {
impl.status = DeliveryCacheProgressStatus::ProcessingDataList;
SignalUpdate();
SignalUpdate(kernel);
}
void ProgressServiceBackend::StartDownloadingFile(std::string_view dir_name,
std::string_view file_name, u64 file_size) {
void ProgressServiceBackend::StartDownloadingFile(Kernel::KernelCore& kernel, std::string_view dir_name, std::string_view file_name, u64 file_size) {
impl.status = DeliveryCacheProgressStatus::Downloading;
impl.current_downloaded_bytes = 0;
impl.current_total_bytes = file_size;
std::memcpy(impl.current_directory.data(), dir_name.data(),
std::min<u64>(dir_name.size(), 0x31ull));
std::memcpy(impl.current_file.data(), file_name.data(),
std::min<u64>(file_name.size(), 0x31ull));
SignalUpdate();
std::memcpy(impl.current_directory.data(), dir_name.data(), std::min<u64>(dir_name.size(), 0x31ull));
std::memcpy(impl.current_file.data(), file_name.data(), std::min<u64>(file_name.size(), 0x31ull));
SignalUpdate(kernel);
}
void ProgressServiceBackend::UpdateFileProgress(u64 downloaded) {
void ProgressServiceBackend::UpdateFileProgress(Kernel::KernelCore& kernel, u64 downloaded) {
impl.current_downloaded_bytes = downloaded;
SignalUpdate();
SignalUpdate(kernel);
}
void ProgressServiceBackend::FinishDownloadingFile() {
void ProgressServiceBackend::FinishDownloadingFile(Kernel::KernelCore& kernel) {
impl.total_downloaded_bytes += impl.current_total_bytes;
SignalUpdate();
SignalUpdate(kernel);
}
void ProgressServiceBackend::CommitDirectory(std::string_view dir_name) {
void ProgressServiceBackend::CommitDirectory(Kernel::KernelCore& kernel, std::string_view dir_name) {
impl.status = DeliveryCacheProgressStatus::Committing;
impl.current_file.fill(0);
impl.current_downloaded_bytes = 0;
impl.current_total_bytes = 0;
std::memcpy(impl.current_directory.data(), dir_name.data(),
std::min<u64>(dir_name.size(), 0x31ull));
SignalUpdate();
std::memcpy(impl.current_directory.data(), dir_name.data(), std::min<u64>(dir_name.size(), 0x31ull));
SignalUpdate(kernel);
}
void ProgressServiceBackend::FinishDownload(Result result) {
void ProgressServiceBackend::FinishDownload(Kernel::KernelCore& kernel, Result result) {
impl.total_downloaded_bytes = impl.total_bytes;
impl.status = DeliveryCacheProgressStatus::Done;
impl.result = result;
SignalUpdate();
SignalUpdate(kernel);
}
void ProgressServiceBackend::SignalUpdate() {
update_event->Signal();
void ProgressServiceBackend::SignalUpdate(Kernel::KernelCore& kernel) {
update_event->Signal(kernel);
}
BcatBackend::BcatBackend(DirectoryGetter getter) : dir_getter(std::move(getter)) {}
BcatBackend::~BcatBackend() = default;
NullBcatBackend::NullBcatBackend(DirectoryGetter getter) : BcatBackend(std::move(getter)) {}
NullBcatBackend::~NullBcatBackend() = default;
bool NullBcatBackend::Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id,
title.build_id);
progress.FinishDownload(ResultSuccess);
bool NullBcatBackend::Synchronize(Kernel::KernelCore& kernel, TitleIDVersion title, ProgressServiceBackend& progress) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id, title.build_id);
progress.FinishDownload(kernel, ResultSuccess);
return true;
}
bool NullBcatBackend::SynchronizeDirectory(TitleIDVersion title, std::string name,
ProgressServiceBackend& progress) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}, name={}", title.title_id,
title.build_id, name);
progress.FinishDownload(ResultSuccess);
bool NullBcatBackend::SynchronizeDirectory(Kernel::KernelCore& kernel, TitleIDVersion title, std::string name, ProgressServiceBackend& progress) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}, name={}", title.title_id, title.build_id, name);
progress.FinishDownload(kernel, ResultSuccess);
return true;
}
bool NullBcatBackend::Clear(u64 title_id) {
bool NullBcatBackend::Clear(Kernel::KernelCore& kernel, u64 title_id) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", title_id);
return true;
}
void NullBcatBackend::SetPassphrase(u64 title_id, const Passphrase& passphrase) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id,
Common::HexToString(passphrase));
void NullBcatBackend::SetPassphrase(Kernel::KernelCore& kernel, u64 title_id, const Passphrase& passphrase) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, passphrase={}", title_id, Common::HexToString(passphrase));
}
std::optional<std::vector<u8>> NullBcatBackend::GetLaunchParameter(TitleIDVersion title) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id,
title.build_id);
std::optional<std::vector<u8>> NullBcatBackend::GetLaunchParameter(Kernel::KernelCore& kernel, TitleIDVersion title) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}, build_id={:016X}", title.title_id, title.build_id);
return std::nullopt;
}

54
src/core/hle/service/bcat/backend/backend.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -34,26 +37,26 @@ public:
~ProgressServiceBackend();
// Sets the number of bytes total in the entire download.
void SetTotalSize(u64 size);
void SetTotalSize(Kernel::KernelCore& kernel, u64 size);
// Notifies the application that the backend has started connecting to the server.
void StartConnecting();
void StartConnecting(Kernel::KernelCore& kernel);
// Notifies the application that the backend has begun accumulating and processing metadata.
void StartProcessingDataList();
void StartProcessingDataList(Kernel::KernelCore& kernel);
// Notifies the application that a file is starting to be downloaded.
void StartDownloadingFile(std::string_view dir_name, std::string_view file_name, u64 file_size);
void StartDownloadingFile(Kernel::KernelCore& kernel, std::string_view dir_name, std::string_view file_name, u64 file_size);
// Updates the progress of the current file to the size passed.
void UpdateFileProgress(u64 downloaded);
void UpdateFileProgress(Kernel::KernelCore& kernel, u64 downloaded);
// Notifies the application that the current file has completed download.
void FinishDownloadingFile();
void FinishDownloadingFile(Kernel::KernelCore& kernel);
// Notifies the application that all files in this directory have completed and are being
// finalized.
void CommitDirectory(std::string_view dir_name);
void CommitDirectory(Kernel::KernelCore& kernel, std::string_view dir_name);
// Notifies the application that the operation completed with result code result.
void FinishDownload(Result result);
void FinishDownload(Kernel::KernelCore& kernel, Result result);
private:
explicit ProgressServiceBackend(Core::System& system, std::string_view event_name);
@ -61,7 +64,7 @@ private:
Kernel::KReadableEvent& GetEvent();
DeliveryCacheProgressImpl& GetImpl();
void SignalUpdate();
void SignalUpdate(Kernel::KernelCore& kernel);
KernelHelpers::ServiceContext service_context;
@ -74,25 +77,19 @@ class BcatBackend {
public:
explicit BcatBackend(DirectoryGetter getter);
virtual ~BcatBackend();
// Called when the backend is needed to synchronize the data for the game with title ID and
// version in title. A ProgressServiceBackend object is provided to alert the application of
// status.
virtual bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) = 0;
virtual bool Synchronize(Kernel::KernelCore& kernel, TitleIDVersion title, ProgressServiceBackend& progress) = 0;
// Very similar to Synchronize, but only for the directory provided. Backends should not alter
// the data for any other directories.
virtual bool SynchronizeDirectory(TitleIDVersion title, std::string name,
ProgressServiceBackend& progress) = 0;
virtual bool SynchronizeDirectory(Kernel::KernelCore& kernel, TitleIDVersion title, std::string name, ProgressServiceBackend& progress) = 0;
// Removes all cached data associated with title id provided.
virtual bool Clear(u64 title_id) = 0;
virtual bool Clear(Kernel::KernelCore& kernel, u64 title_id) = 0;
// Sets the BCAT Passphrase to be used with the associated title ID.
virtual void SetPassphrase(u64 title_id, const Passphrase& passphrase) = 0;
virtual void SetPassphrase(Kernel::KernelCore& kernel, u64 title_id, const Passphrase& passphrase) = 0;
// Gets the launch parameter used by AM associated with the title ID and version provided.
virtual std::optional<std::vector<u8>> GetLaunchParameter(TitleIDVersion title) = 0;
virtual std::optional<std::vector<u8>> GetLaunchParameter(Kernel::KernelCore& kernel, TitleIDVersion title) = 0;
protected:
DirectoryGetter dir_getter;
};
@ -103,18 +100,13 @@ public:
explicit NullBcatBackend(DirectoryGetter getter);
~NullBcatBackend() override;
bool Synchronize(TitleIDVersion title, ProgressServiceBackend& progress) override;
bool SynchronizeDirectory(TitleIDVersion title, std::string name,
ProgressServiceBackend& progress) override;
bool Clear(u64 title_id) override;
void SetPassphrase(u64 title_id, const Passphrase& passphrase) override;
std::optional<std::vector<u8>> GetLaunchParameter(TitleIDVersion title) override;
bool Synchronize(Kernel::KernelCore& kernel, TitleIDVersion title, ProgressServiceBackend& progress) override;
bool SynchronizeDirectory(Kernel::KernelCore& kernel, TitleIDVersion title, std::string name, ProgressServiceBackend& progress) override;
bool Clear(Kernel::KernelCore& kernel, u64 title_id) override;
void SetPassphrase(Kernel::KernelCore& kernel, u64 title_id, const Passphrase& passphrase) override;
std::optional<std::vector<u8>> GetLaunchParameter(Kernel::KernelCore& kernel, TitleIDVersion title) override;
};
std::unique_ptr<BcatBackend> CreateBackendFromSettings(Core::System& system,
DirectoryGetter getter);
std::unique_ptr<BcatBackend> CreateBackendFromSettings(Core::System& system, DirectoryGetter getter);
} // namespace Service::BCAT

10
src/core/hle/service/bcat/bcat_service.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@ -70,7 +70,7 @@ Result IBcatService::RequestSyncDeliveryCache(
LOG_DEBUG(Service_BCAT, "called");
auto& progress_backend{GetProgressBackend(SyncType::Normal)};
backend.Synchronize({system.GetApplicationProcessProgramID(),
backend.Synchronize(system.Kernel(), {system.GetApplicationProcessProgramID(),
GetCurrentBuildID(system.GetApplicationProcessBuildID())},
GetProgressBackend(SyncType::Normal));
@ -86,7 +86,7 @@ Result IBcatService::RequestSyncDeliveryCacheWithDirectoryName(
LOG_DEBUG(Service_BCAT, "called, name={}", name);
auto& progress_backend{GetProgressBackend(SyncType::Directory)};
backend.SynchronizeDirectory({system.GetApplicationProcessProgramID(),
backend.SynchronizeDirectory(system.Kernel(), {system.GetApplicationProcessProgramID(),
GetCurrentBuildID(system.GetApplicationProcessBuildID())},
name, progress_backend);
@ -107,7 +107,7 @@ Result IBcatService::SetPassphrase(u64 application_id,
std::memcpy(passphrase.data(), passphrase_buffer.data(),
(std::min)(passphrase.size(), passphrase_buffer.size()));
backend.SetPassphrase(application_id, passphrase);
backend.SetPassphrase(system.Kernel(), application_id, passphrase);
R_SUCCEED();
}
@ -120,7 +120,7 @@ Result IBcatService::ClearDeliveryCacheStorage(u64 application_id) {
LOG_DEBUG(Service_BCAT, "called, title_id={:016X}", application_id);
R_UNLESS(application_id != 0, ResultInvalidArgument);
R_UNLESS(backend.Clear(application_id), FileSys::ResultPermissionDenied);
R_UNLESS(backend.Clear(system.Kernel(), application_id), FileSys::ResultPermissionDenied);
R_SUCCEED();
}

2
src/core/hle/service/friend/friend.cpp
View file

@ -183,7 +183,7 @@ private:
auto& readable_event = completion_event->GetReadableEvent();
IPC::ResponseBuilder rb{ctx, 2, 1};
rb.Push(readable_event.Signal());
rb.Push(readable_event.Signal(system.Kernel()));
rb.PushCopyObjects(readable_event);
}

9
src/core/hle/service/glue/time/alarm_worker.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -28,7 +31,7 @@ void AlarmWorker::Initialize(std::shared_ptr<Service::PSC::Time::ServiceManager>
"Glue:AlarmWorker::AlarmTimer",
[this](s64 time,
std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
m_timer_event->Signal();
m_timer_event->Signal(m_system.Kernel());
return std::nullopt;
});
@ -57,7 +60,7 @@ void AlarmWorker::OnPowerStateChanged() {
s64 closest_time{};
if (!GetClosestAlarmInfo(closest_alarm_info, closest_time)) {
m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);
m_timer_event->Clear();
m_timer_event->Clear(m_system.Kernel());
return;
}
@ -67,7 +70,7 @@ void AlarmWorker::OnPowerStateChanged() {
auto next_time{closest_alarm_info.alert_time - closest_time};
m_system.CoreTiming().UnscheduleEvent(m_timer_timing_event);
m_timer_event->Clear();
m_timer_event->Clear(m_system.Kernel());
m_system.CoreTiming().ScheduleEvent(std::chrono::nanoseconds(next_time),
m_timer_timing_event);

2
src/core/hle/service/glue/time/time_zone.cpp
View file

@ -89,7 +89,7 @@ Result TimeZoneService::SetDeviceLocationName(
std::scoped_lock m{m_list_mutex};
for (auto& operation_event : m_list_nodes) {
operation_event.m_event->Signal();
operation_event.m_event->Signal(m_system.Kernel());
}
R_SUCCEED();
}

31
src/core/hle/service/glue/time/worker.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -30,7 +33,7 @@ TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady
"Time::SteadyClockEvent",
[this](s64 time,
std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
m_timer_steady_clock->Signal();
m_timer_steady_clock->Signal(m_system.Kernel());
return std::nullopt;
});
@ -38,19 +41,19 @@ TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady
"Time::SteadyClockEvent",
[this](s64 time,
std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
m_timer_file_system->Signal();
m_timer_file_system->Signal(m_system.Kernel());
return std::nullopt;
});
}
TimeWorker::~TimeWorker() {
m_local_clock_event->Signal();
m_network_clock_event->Signal();
m_ephemeral_clock_event->Signal();
m_local_clock_event->Signal(m_system.Kernel());
m_network_clock_event->Signal(m_system.Kernel());
m_ephemeral_clock_event->Signal(m_system.Kernel());
std::this_thread::sleep_for(std::chrono::milliseconds(16));
m_thread.request_stop();
m_event->Signal();
m_event->Signal(m_system.Kernel());
m_thread.join();
m_ctx.CloseEvent(m_event);
@ -167,19 +170,19 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
return;
case EventType::PowerStateChange:
m_alarm_worker.GetEvent().Clear();
m_alarm_worker.GetEvent().Clear(m_system.Kernel());
if (m_pm_state_change_handler.m_priority <= 1) {
m_alarm_worker.OnPowerStateChanged();
}
break;
case EventType::SignalAlarms:
m_alarm_worker.GetTimerEvent().Clear();
m_alarm_worker.GetTimerEvent().Clear(m_system.Kernel());
m_time_m->CheckAndSignalAlarms();
break;
case EventType::UpdateLocalSystemClock: {
m_local_clock_event->Clear();
m_local_clock_event->Clear(m_system.Kernel());
Service::PSC::Time::SystemClockContext context{};
R_ASSERT(m_local_clock->GetSystemClockContext(&context));
@ -190,7 +193,7 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
}
case EventType::UpdateNetworkSystemClock: {
m_network_clock_event->Clear();
m_network_clock_event->Clear(m_system.Kernel());
Service::PSC::Time::SystemClockContext context{};
R_ASSERT(m_network_clock->GetSystemClockContext(&context));
@ -218,7 +221,7 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
}
case EventType::UpdateEphemeralSystemClock: {
m_ephemeral_clock_event->Clear();
m_ephemeral_clock_event->Clear(m_system.Kernel());
Service::PSC::Time::SystemClockContext context{};
auto res = m_ephemeral_clock->GetSystemClockContext(&context);
@ -247,20 +250,20 @@ void TimeWorker::ThreadFunc(std::stop_token stop_token) {
}
case EventType::UpdateSteadyClock:
m_timer_steady_clock->Clear();
m_timer_steady_clock->Clear(m_system.Kernel());
m_steady_clock_resource.UpdateTime();
m_time_m->SetStandardSteadyClockBaseTime(m_steady_clock_resource.GetTime());
break;
case EventType::UpdateFileTimestamp:
m_timer_file_system->Clear();
m_timer_file_system->Clear(m_system.Kernel());
m_file_timestamp_worker.SetFilesystemPosixTime();
break;
case EventType::AutoCorrect: {
m_standard_user_auto_correct_clock_event->Clear();
m_standard_user_auto_correct_clock_event->Clear(m_system.Kernel());
bool automatic_correction{};
R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(

77
src/core/hle/service/hid/hid_server.cpp
View file

@ -650,8 +650,7 @@ Result IHidServer::SetSupportedNpadStyleSet(Core::HID::NpadStyleSet supported_st
LOG_DEBUG(Service_HID, "called, supported_style_set={}, applet_resource_user_id={}",
supported_style_set, aruid.pid);
R_TRY(
GetResourceManager()->GetNpad()->SetSupportedNpadStyleSet(aruid.pid, supported_style_set));
R_TRY(GetResourceManager()->GetNpad()->SetSupportedNpadStyleSet(system.Kernel(), aruid.pid, supported_style_set));
Core::HID::NpadStyleTag style_tag{supported_style_set};
const auto revision = GetResourceManager()->GetNpad()->GetRevision(aruid.pid);
@ -667,7 +666,7 @@ Result IHidServer::GetSupportedNpadStyleSet(Out<Core::HID::NpadStyleSet> out_sup
ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->GetSupportedNpadStyleSet(aruid.pid,
R_RETURN(GetResourceManager()->GetNpad()->GetSupportedNpadStyleSet(system.Kernel(), aruid.pid,
*out_supported_style_set));
}
@ -677,7 +676,7 @@ Result IHidServer::SetSupportedNpadIdType(
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
R_RETURN(
GetResourceManager()->GetNpad()->SetSupportedNpadIdType(aruid.pid, supported_npad_list));
GetResourceManager()->GetNpad()->SetSupportedNpadIdType(system.Kernel(), aruid.pid, supported_npad_list));
}
Result IHidServer::ActivateNpad(ClientAppletResourceUserId aruid) {
@ -702,14 +701,13 @@ Result IHidServer::AcquireNpadStyleSetUpdateEventHandle(
LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}, unknown={}", npad_id,
aruid.pid, unknown);
R_RETURN(GetResourceManager()->GetNpad()->AcquireNpadStyleSetUpdateEventHandle(
aruid.pid, out_event, npad_id));
R_RETURN(GetResourceManager()->GetNpad()->AcquireNpadStyleSetUpdateEventHandle(system.Kernel(), aruid.pid, out_event, npad_id));
}
Result IHidServer::DisconnectNpad(Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->DisconnectNpad(aruid.pid, npad_id));
R_RETURN(GetResourceManager()->GetNpad()->DisconnectNpad(system.Kernel(), aruid.pid, npad_id));
}
Result IHidServer::GetPlayerLedPattern(Out<Core::HID::LedPattern> out_led_pattern,
@ -779,7 +777,7 @@ Result IHidServer::SetNpadJoyAssignmentModeSingleByDefault(Core::HID::NpadIdType
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
Core::HID::NpadIdType new_npad_id{};
GetResourceManager()->GetNpad()->SetNpadMode(
GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(),
aruid.pid, new_npad_id, npad_id, NpadJoyDeviceType::Left, NpadJoyAssignmentMode::Single);
R_SUCCEED();
}
@ -791,7 +789,7 @@ Result IHidServer::SetNpadJoyAssignmentModeSingle(Core::HID::NpadIdType npad_id,
npad_id, aruid.pid, npad_joy_device_type);
Core::HID::NpadIdType new_npad_id{};
GetResourceManager()->GetNpad()->SetNpadMode(
GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(),
aruid.pid, new_npad_id, npad_id, npad_joy_device_type, NpadJoyAssignmentMode::Single);
R_SUCCEED();
}
@ -801,7 +799,7 @@ Result IHidServer::SetNpadJoyAssignmentModeDual(Core::HID::NpadIdType npad_id,
LOG_DEBUG(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
Core::HID::NpadIdType new_npad_id{};
GetResourceManager()->GetNpad()->SetNpadMode(aruid.pid, new_npad_id, npad_id, {},
GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(), aruid.pid, new_npad_id, npad_id, {},
NpadJoyAssignmentMode::Dual);
R_SUCCEED();
}
@ -813,7 +811,7 @@ Result IHidServer::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
npad_id_1, npad_id_2, aruid.pid);
R_RETURN(
GetResourceManager()->GetNpad()->MergeSingleJoyAsDualJoy(aruid.pid, npad_id_1, npad_id_2));
GetResourceManager()->GetNpad()->MergeSingleJoyAsDualJoy(system.Kernel(), aruid.pid, npad_id_1, npad_id_2));
}
Result IHidServer::StartLrAssignmentMode(ClientAppletResourceUserId aruid) {
@ -840,67 +838,40 @@ Result IHidServer::SetNpadHandheldActivationMode(ClientAppletResourceUserId arui
ASSERT_MSG(false, "Activation mode should be always None, Single or Dual");
R_SUCCEED();
}
R_RETURN(
GetResourceManager()->GetNpad()->SetNpadHandheldActivationMode(aruid.pid, activation_mode));
R_RETURN(GetResourceManager()->GetNpad()->SetNpadHandheldActivationMode(system.Kernel(), aruid.pid, activation_mode));
}
Result IHidServer::GetNpadHandheldActivationMode(
Out<NpadHandheldActivationMode> out_activation_mode, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->GetNpadHandheldActivationMode(aruid.pid,
*out_activation_mode));
R_RETURN(GetResourceManager()->GetNpad()->GetNpadHandheldActivationMode(system.Kernel(), aruid.pid, *out_activation_mode));
}
Result IHidServer::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
Core::HID::NpadIdType npad_id_2,
ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, npad_id_1={}, npad_id_2={}, applet_resource_user_id={}",
npad_id_1, npad_id_2, aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->SwapNpadAssignment(aruid.pid, npad_id_1, npad_id_2))
Result IHidServer::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, npad_id_1={}, npad_id_2={}, applet_resource_user_id={}", npad_id_1, npad_id_2, aruid.pid);
R_RETURN(GetResourceManager()->GetNpad()->SwapNpadAssignment(system.Kernel(), aruid.pid, npad_id_1, npad_id_2))
}
Result IHidServer::IsUnintendedHomeButtonInputProtectionEnabled(Out<bool> out_is_enabled,
Core::HID::NpadIdType npad_id,
ClientAppletResourceUserId aruid) {
Result IHidServer::IsUnintendedHomeButtonInputProtectionEnabled(Out<bool> out_is_enabled, Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid) {
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", npad_id, aruid.pid);
R_UNLESS(IsNpadIdValid(npad_id), ResultInvalidNpadId);
R_RETURN(GetResourceManager()->GetNpad()->IsUnintendedHomeButtonInputProtectionEnabled(
*out_is_enabled, aruid.pid, npad_id));
R_RETURN(GetResourceManager()->GetNpad()->IsUnintendedHomeButtonInputProtectionEnabled(*out_is_enabled, aruid.pid, npad_id));
}
Result IHidServer::EnableUnintendedHomeButtonInputProtection(bool is_enabled,
Core::HID::NpadIdType npad_id,
ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, is_enabled={}, npad_id={}, applet_resource_user_id={}",
is_enabled, npad_id, aruid.pid);
Result IHidServer::EnableUnintendedHomeButtonInputProtection(bool is_enabled, Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid) {
LOG_DEBUG(Service_HID, "called, is_enabled={}, npad_id={}, applet_resource_user_id={}",is_enabled, npad_id, aruid.pid);
R_UNLESS(IsNpadIdValid(npad_id), ResultInvalidNpadId);
R_RETURN(GetResourceManager()->GetNpad()->EnableUnintendedHomeButtonInputProtection(
aruid.pid, npad_id, is_enabled));
R_RETURN(GetResourceManager()->GetNpad()->EnableUnintendedHomeButtonInputProtection(aruid.pid, npad_id, is_enabled));
}
Result IHidServer::SetNpadJoyAssignmentModeSingleWithDestination(
Out<bool> out_is_reassigned, Out<Core::HID::NpadIdType> out_new_npad_id,
Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid,
NpadJoyDeviceType npad_joy_device_type) {
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}",
npad_id, aruid.pid, npad_joy_device_type);
*out_is_reassigned = GetResourceManager()->GetNpad()->SetNpadMode(
aruid.pid, *out_new_npad_id, npad_id, npad_joy_device_type, NpadJoyAssignmentMode::Single);
Result IHidServer::SetNpadJoyAssignmentModeSingleWithDestination(Out<bool> out_is_reassigned, Out<Core::HID::NpadIdType> out_new_npad_id, Core::HID::NpadIdType npad_id, ClientAppletResourceUserId aruid, NpadJoyDeviceType npad_joy_device_type) {
LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}", npad_id, aruid.pid, npad_joy_device_type);
*out_is_reassigned = GetResourceManager()->GetNpad()->SetNpadMode(system.Kernel(), aruid.pid, *out_new_npad_id, npad_id, npad_joy_device_type, NpadJoyAssignmentMode::Single);
R_SUCCEED();
}
Result IHidServer::SetNpadAnalogStickUseCenterClamp(bool use_center_clamp,
ClientAppletResourceUserId aruid) {
LOG_INFO(Service_HID, "called, use_center_clamp={}, applet_resource_user_id={}",
use_center_clamp, aruid.pid);
Result IHidServer::SetNpadAnalogStickUseCenterClamp(bool use_center_clamp, ClientAppletResourceUserId aruid) {
LOG_INFO(Service_HID, "called, use_center_clamp={}, applet_resource_user_id={}", use_center_clamp, aruid.pid);
GetResourceManager()->GetNpad()->SetNpadAnalogStickUseCenterClamp(aruid.pid, use_center_clamp);
R_SUCCEED();
}

16
src/core/hle/service/hid/hid_system_server.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@ -281,7 +281,7 @@ void IHidSystemServer::ApplyNpadSystemCommonPolicy(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy(applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicy(system.Kernel(), applet_resource_user_id);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);
@ -328,7 +328,7 @@ void IHidSystemServer::ApplyNpadSystemCommonPolicyFull(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicyFull(applet_resource_user_id);
GetResourceManager()->GetNpad()->ApplyNpadSystemCommonPolicyFull(system.Kernel(), applet_resource_user_id);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);
@ -358,9 +358,8 @@ void IHidSystemServer::GetMaskedSupportedNpadStyleSet(HLERequestContext& ctx) {
LOG_INFO(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
Core::HID::NpadStyleSet supported_styleset{};
const auto& npad = GetResourceManager()->GetNpad();
const Result result =
npad->GetMaskedSupportedNpadStyleSet(applet_resource_user_id, supported_styleset);
const auto npad = GetResourceManager()->GetNpad();
const Result result = npad->GetMaskedSupportedNpadStyleSet(system.Kernel(), applet_resource_user_id, supported_styleset);
IPC::ResponseBuilder rb{ctx, 3};
rb.Push(result);
@ -373,9 +372,8 @@ void IHidSystemServer::SetSupportedNpadStyleSetAll(HLERequestContext& ctx) {
LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
const auto& npad = GetResourceManager()->GetNpad();
const auto result =
npad->SetSupportedNpadStyleSet(applet_resource_user_id, Core::HID::NpadStyleSet::All);
const auto npad = GetResourceManager()->GetNpad();
const auto result = npad->SetSupportedNpadStyleSet(system.Kernel(), applet_resource_user_id, Core::HID::NpadStyleSet::All);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(result);

11
src/core/hle/service/hle_ipc.cpp
View file

@ -275,17 +275,17 @@ Result HLERequestContext::WriteToOutgoingCommandBuffer() {
for (auto& object : outgoing_copy_objects) {
Handle handle{};
if (object) {
R_TRY(handle_table.Add(&handle, object));
R_TRY(handle_table.Add(kernel, &handle, object));
}
cmd_buf[current_offset++] = handle;
}
for (auto& object : outgoing_move_objects) {
Handle handle{};
if (object) {
R_TRY(handle_table.Add(&handle, object));
R_TRY(handle_table.Add(kernel, &handle, object));
// Close our reference to the object, as it is being moved to the caller.
object->Close();
object->Close(kernel);
}
cmd_buf[current_offset++] = handle;
}
@ -503,11 +503,10 @@ bool HLERequestContext::CanWriteBuffer(std::size_t buffer_index) const {
}
void HLERequestContext::AddMoveInterface(SessionRequestHandlerPtr s) {
ASSERT(Kernel::GetCurrentProcess(kernel).GetResourceLimit()->Reserve(
Kernel::LimitableResource::SessionCountMax, 1));
ASSERT(Kernel::GetCurrentProcess(kernel).GetResourceLimit()->Reserve(kernel, Kernel::LimitableResource::SessionCountMax, 1));
auto* session = Kernel::KSession::Create(kernel);
session->Initialize(nullptr, 0);
session->Initialize(kernel, nullptr, 0);
Kernel::KSession::Register(kernel, session);
auto& server = manager.lock()->GetServerManager();

9
src/core/hle/service/hle_ipc.h
View file

@ -373,11 +373,10 @@ public:
template <typename T>
Kernel::KScopedAutoObject<T> GetObjectFromHandle(u32 handle) {
auto obj = client_handle_table->GetObjectForIpc(handle, thread);
if (obj.IsNotNull()) {
return obj->DynamicCast<T*>();
}
return nullptr;
auto obj = client_handle_table->GetObjectForIpc(kernel, handle, thread);
if (obj.IsNotNull())
return {kernel, obj->DynamicCast<T*>()};
return {kernel, nullptr};
}
[[nodiscard]] std::shared_ptr<SessionRequestManager> GetManager() const {

5
src/core/hle/service/ipc_helpers.h
View file

@ -151,11 +151,10 @@ public:
if (manager->IsDomain()) {
context->AddDomainObject(std::move(iface));
} else {
ASSERT(Kernel::GetCurrentProcess(kernel).GetResourceLimit()->Reserve(
Kernel::LimitableResource::SessionCountMax, 1));
ASSERT(Kernel::GetCurrentProcess(kernel).GetResourceLimit()->Reserve(kernel, Kernel::LimitableResource::SessionCountMax, 1));
auto* session = Kernel::KSession::Create(kernel);
session->Initialize(nullptr, 0);
session->Initialize(kernel, nullptr, 0);
Kernel::KSession::Register(kernel, session);
auto next_manager = std::make_shared<Service::SessionRequestManager>(

29
src/core/hle/service/jit/jit.cpp
View file

@ -30,12 +30,13 @@ static_assert(sizeof(Struct32) == 32, "Struct32 has wrong size");
class IJitEnvironment final : public ServiceFramework<IJitEnvironment> {
public:
explicit IJitEnvironment(Core::System& system_,
Kernel::KScopedAutoObject<Kernel::KProcess> process_,
CodeMemory&& user_rx_, CodeMemory&& user_ro_)
: ServiceFramework{system_, "IJitEnvironment"}, process{std::move(process_)},
user_rx{std::move(user_rx_)}, user_ro{std::move(user_ro_)},
context{system_.ApplicationMemory()} {
explicit IJitEnvironment(Core::System& system_, Kernel::KProcess* process_, CodeMemory&& user_rx_, CodeMemory&& user_ro_)
: ServiceFramework{system_, "IJitEnvironment"}
, process{kernel, process_}
, user_rx{std::move(user_rx_)}
, user_ro{std::move(user_ro_)}
, context{system_.ApplicationMemory()}
{
// clang-format off
static const FunctionInfo functions[] = {
@ -58,6 +59,11 @@ public:
configuration.sys_ro_memory = configuration.user_ro_memory;
}
~IJitEnvironment() {
user_rx.Finalize(system.Kernel());
user_ro.Finalize(system.Kernel());
}
Result GenerateCode(Out<s32> out_return_value, Out<CodeRange> out_range0,
Out<CodeRange> out_range1, OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
u32 data_size, u64 command, CodeRange range0, CodeRange range1,
@ -281,14 +287,9 @@ private:
}
CodeMemory rx, ro;
R_TRY(rx.Initialize(*process, *rx_mem, rx_size, Kernel::Svc::MemoryPermission::ReadExecute,
generate_random));
R_TRY(ro.Initialize(*process, *ro_mem, ro_size, Kernel::Svc::MemoryPermission::Read,
generate_random));
*out_jit_environment =
std::make_shared<IJitEnvironment>(system, process.Get(), std::move(rx), std::move(ro));
R_TRY(rx.Initialize(system.Kernel(), *process, *rx_mem, rx_size, Kernel::Svc::MemoryPermission::ReadExecute, generate_random));
R_TRY(ro.Initialize(system.Kernel(), *process, *ro_mem, ro_size, Kernel::Svc::MemoryPermission::Read, generate_random));
*out_jit_environment = std::make_shared<IJitEnvironment>(system, process.Get(), std::move(rx), std::move(ro));
R_SUCCEED();
}

20
src/core/hle/service/jit/jit_code_memory.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -5,12 +8,9 @@
namespace Service::JIT {
Result CodeMemory::Initialize(Kernel::KProcess& process, Kernel::KCodeMemory& code_memory,
size_t size, Kernel::Svc::MemoryPermission perm,
std::mt19937_64& generate_random) {
Result CodeMemory::Initialize(Kernel::KernelCore& kernel, Kernel::KProcess& process, Kernel::KCodeMemory& code_memory, size_t size, Kernel::Svc::MemoryPermission perm, std::mt19937_64& generate_random) {
auto& page_table = process.GetPageTable();
const u64 alias_code_start =
GetInteger(page_table.GetAliasCodeRegionStart()) / Kernel::PageSize;
const u64 alias_code_start = GetInteger(page_table.GetAliasCodeRegionStart()) / Kernel::PageSize;
const u64 alias_code_size = page_table.GetAliasCodeRegionSize() / Kernel::PageSize;
// NOTE: This will retry indefinitely until mapping the code memory succeeds.
@ -20,7 +20,7 @@ Result CodeMemory::Initialize(Kernel::KProcess& process, Kernel::KCodeMemory& co
(alias_code_start + (generate_random() % alias_code_size)) * Kernel::PageSize;
// Try to map the address
R_TRY_CATCH(code_memory.MapToOwner(mapped_address, size, perm)) {
R_TRY_CATCH(code_memory.MapToOwner(kernel, mapped_address, size, perm)) {
R_CATCH(Kernel::ResultInvalidMemoryRegion) {
// If we could not map here, retry.
continue;
@ -35,17 +35,17 @@ Result CodeMemory::Initialize(Kernel::KProcess& process, Kernel::KCodeMemory& co
m_perm = perm;
// Open a new reference to the code memory.
m_code_memory->Open();
m_code_memory->Open(kernel);
// We succeeded.
R_SUCCEED();
}
}
void CodeMemory::Finalize() {
void CodeMemory::Finalize(Kernel::KernelCore& kernel) {
if (m_code_memory) {
R_ASSERT(m_code_memory->UnmapFromOwner(m_address, m_size));
m_code_memory->Close();
R_ASSERT(m_code_memory->UnmapFromOwner(kernel, m_address, m_size));
m_code_memory->Close(kernel);
}
m_code_memory = nullptr;

29
src/core/hle/service/jit/jit_code_memory.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -7,29 +10,16 @@
#include "core/hle/kernel/k_code_memory.h"
namespace Kernel {
class KernelCore;
}
namespace Service::JIT {
class CodeMemory {
public:
YUZU_NON_COPYABLE(CodeMemory);
explicit CodeMemory() = default;
CodeMemory(CodeMemory&& rhs) {
std::swap(m_code_memory, rhs.m_code_memory);
std::swap(m_size, rhs.m_size);
std::swap(m_address, rhs.m_address);
std::swap(m_perm, rhs.m_perm);
}
~CodeMemory() {
this->Finalize();
}
public:
Result Initialize(Kernel::KProcess& process, Kernel::KCodeMemory& code_memory, size_t size,
Kernel::Svc::MemoryPermission perm, std::mt19937_64& generate_random);
void Finalize();
Result Initialize(Kernel::KernelCore& kernel, Kernel::KProcess& process, Kernel::KCodeMemory& code_memory, size_t size, Kernel::Svc::MemoryPermission perm, std::mt19937_64& generate_random);
void Finalize(Kernel::KernelCore& kernel);
size_t GetSize() const {
return m_size;
@ -39,7 +29,6 @@ public:
return m_address;
}
private:
Kernel::KCodeMemory* m_code_memory{};
size_t m_size{};
u64 m_address{};

22
src/core/hle/service/kernel_helpers.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -14,15 +17,15 @@
namespace Service::KernelHelpers {
ServiceContext::ServiceContext(Core::System& system_, std::string name_)
: kernel(system_.Kernel()) {
: kernel(system_.Kernel())
{
if (process = Kernel::GetCurrentProcessPointer(kernel); process != nullptr) {
return;
}
// Create the process.
process = Kernel::KProcess::Create(kernel);
ASSERT(R_SUCCEEDED(process->Initialize(Kernel::Svc::CreateProcessParameter{},
kernel.GetSystemResourceLimit(), false)));
ASSERT(R_SUCCEEDED(process->Initialize(kernel, Kernel::Svc::CreateProcessParameter{}, kernel.GetSystemResourceLimit(), false)));
// Register the process.
Kernel::KProcess::Register(kernel, process);
@ -31,14 +34,14 @@ ServiceContext::ServiceContext(Core::System& system_, std::string name_)
ServiceContext::~ServiceContext() {
if (process_created) {
process->Close();
process->Close(kernel);
process = nullptr;
}
}
Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
// Reserve a new event from the process resource limit
Kernel::KScopedResourceReservation event_reservation(process,
Kernel::KScopedResourceReservation event_reservation(kernel, process,
Kernel::LimitableResource::EventCountMax);
if (!event_reservation.Succeeded()) {
LOG_CRITICAL(Service, "Resource limit reached!");
@ -53,7 +56,7 @@ Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
}
// Initialize the event.
event->Initialize(process);
event->Initialize(kernel, process);
// Commit the thread reservation.
event_reservation.Commit();
@ -65,11 +68,10 @@ Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
}
void ServiceContext::CloseEvent(Kernel::KEvent* event) {
if (!event) {
return;
if (event) {
event->GetReadableEvent().Close(kernel);
event->Close(kernel);
}
event->GetReadableEvent().Close();
event->Close();
}
} // namespace Service::KernelHelpers

4
src/core/hle/service/kernel_helpers.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -26,7 +29,6 @@ public:
void CloseEvent(Kernel::KEvent* event);
private:
Kernel::KernelCore& kernel;
Kernel::KProcess* process{};
bool process_created{false};

4
src/core/hle/service/ldn/user_local_communication_service.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
@ -322,7 +322,7 @@ void IUserLocalCommunicationService::OnLDNPacketReceived(const Network::LDNPacke
}
void IUserLocalCommunicationService::OnEventFired() {
state_change_event->Signal();
state_change_event->Signal(system.Kernel());
}
} // namespace Service::LDN

12
src/core/hle/service/nfc/common/device.cpp
View file

@ -71,13 +71,13 @@ NfcDevice::~NfcDevice() {
void NfcDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {
if (type == Core::HID::ControllerTriggerType::Connected) {
Initialize();
availability_change_event->Signal();
availability_change_event->Signal(system.Kernel());
return;
}
if (type == Core::HID::ControllerTriggerType::Disconnected) {
Finalize();
availability_change_event->Signal();
availability_change_event->Signal(system.Kernel());
return;
}
@ -138,8 +138,8 @@ bool NfcDevice::LoadNfcTag(u8 protocol, u8 tag_type, u8 uuid_length, UniqueSeria
};
device_state = DeviceState::TagFound;
deactivate_event->GetReadableEvent().Clear();
activate_event->Signal();
deactivate_event->GetReadableEvent().Clear(system.Kernel());
activate_event->Signal(system.Kernel());
return true;
}
@ -192,8 +192,8 @@ void NfcDevice::CloseNfcTag() {
device_state = DeviceState::TagRemoved;
encrypted_tag_data = {};
tag_data = {};
activate_event->GetReadableEvent().Clear();
deactivate_event->Signal();
activate_event->GetReadableEvent().Clear(system.Kernel());
deactivate_event->Signal(system.Kernel());
}
Kernel::KReadableEvent& NfcDevice::GetActivateEvent() const {

6
src/core/hle/service/nifm/nifm.cpp
View file

@ -275,7 +275,7 @@ private:
}
state.store(State::Processing);
evt_processing->Signal();
evt_processing->Signal(system.Kernel());
worker = std::thread([this]() {
using namespace std::chrono_literals;
@ -321,7 +321,7 @@ private:
void Finish(Result rc) {
worker_result.store(rc);
state.store(State::Finished);
evt_scan_complete->Signal();
evt_scan_complete->Signal(system.Kernel());
}
KernelHelpers::ServiceContext svc_ctx;
@ -486,7 +486,7 @@ private:
void UpdateState(RequestState new_state) {
LOG_DEBUG(Service_NIFM, "(STUBBED) called");
state = new_state;
event1->Signal();
event1->Signal(system.Kernel());
}
KernelHelpers::ServiceContext service_context;

6
src/core/hle/service/nim/nim.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@ -429,7 +429,7 @@ private:
void StartTask(HLERequestContext& ctx) {
// No need to connect to the internet, just finish the task straight away.
LOG_DEBUG(Service_NIM, "called");
finished_event->Signal();
finished_event->Signal(system.Kernel());
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);
}
@ -451,7 +451,7 @@ private:
void Cancel(HLERequestContext& ctx) {
LOG_DEBUG(Service_NIM, "called");
finished_event->Clear();
finished_event->Clear(system.Kernel());
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);
}

6
src/core/hle/service/ns/application_manager_interface.cpp
View file

@ -610,7 +610,7 @@ Result IApplicationManagerInterface::GetApplicationRecordUpdateSystemEvent(
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_NS, "(STUBBED) called");
record_update_system_event.Signal();
record_update_system_event.Signal(system.Kernel());
*out_event = record_update_system_event.GetHandle();
R_SUCCEED();
@ -820,14 +820,14 @@ Result IApplicationManagerInterface::RequestDownloadApplicationControlDataInBack
LOG_INFO(Service_NS, "called, control_source={} app={:016X}",
control_source, application_id);
unknown_event.Signal();
unknown_event.Signal(system.Kernel());
R_SUCCEED();
}
Result IApplicationManagerInterface::Unknown4022(
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_NS, "(STUBBED) called");
unknown_event.Signal();
unknown_event.Signal(system.Kernel());
*out_event = unknown_event.GetHandle();
R_SUCCEED();
}

2
src/core/hle/service/ns/read_only_application_control_data_interface.cpp
View file

@ -87,7 +87,7 @@ public:
RegisterHandlers(functions);
completion_event = service_context.CreateEvent("IAsyncValue:Completion");
completion_event->GetReadableEvent().Signal();
completion_event->GetReadableEvent().Signal(system.Kernel());
}
~IAsyncValueForListApplicationTitle() override {

5
src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
View file

@ -138,8 +138,7 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
static_cast<u32>((vm.va_range_end - vm.va_range_split) >> vm.big_page_size_bits)};
vm.big_page_allocator.emplace(start_big_pages, end_big_pages);
gmmu = std::make_shared<Tegra::MemoryManager>(system, max_big_page_bits, vm.va_range_split,
vm.big_page_size_bits, VM::PAGE_SIZE_BITS);
gmmu = std::make_unique<Tegra::MemoryManager>(system, max_big_page_bits, vm.va_range_split, vm.big_page_size_bits, VM::PAGE_SIZE_BITS);
system.GPU().InitAddressSpace(*gmmu);
vm.initialised = true;
@ -416,7 +415,7 @@ NvResult nvhost_as_gpu::BindChannel(IoctlBindChannel& params) {
LOG_DEBUG(Service_NVDRV, "called, fd={:X}", params.fd);
auto gpu_channel_device = module.GetDevice<nvhost_gpu>(params.fd);
gpu_channel_device->channel_state->memory_manager = gmmu;
gpu_channel_device->channel_state->memory_manager = gmmu.get();
return NvResult::Success;
}

2
src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h
View file

@ -219,7 +219,7 @@ private:
bool initialised{};
} vm;
std::shared_ptr<Tegra::MemoryManager> gmmu;
std::unique_ptr<Tegra::MemoryManager> gmmu;
};
} // namespace Service::Nvidia::Devices

4
src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
View file

@ -203,7 +203,7 @@ NvResult nvhost_ctrl::IocCtrlEventWait(IocCtrlEventWaitParams& params, bool is_a
auto& event_ = events[slot];
if (event_.status.exchange(EventState::Signalling, std::memory_order_acq_rel) ==
EventState::Waiting) {
event_.kevent->Signal();
event_.kevent->Signal(system.Kernel());
}
event_.status.store(EventState::Signalled, std::memory_order_release);
});
@ -292,7 +292,7 @@ NvResult nvhost_ctrl::IocCtrlClearEventWait(IocCtrlEventClearParams& params) {
}
event.fails++;
event.status.store(EventState::Cancelled, std::memory_order_release);
event.kevent->Clear();
event.kevent->Clear(system.Kernel());
return NvResult::Success;
}

8
src/core/hle/service/nvnflinger/buffer_queue_producer.cpp
View file

@ -111,7 +111,7 @@ Status BufferQueueProducer::SetBufferCount(s32 buffer_count) {
core->override_max_buffer_count = buffer_count;
core->SignalDequeueCondition();
buffer_wait_event->Signal();
buffer_wait_event->Signal(service_context.kernel);
listener = core->consumer_listener;
}
@ -576,7 +576,7 @@ void BufferQueueProducer::CancelBuffer(s32 slot, const Fence& fence) {
slots[slot].fence = fence;
core->SignalDequeueCondition();
buffer_wait_event->Signal();
buffer_wait_event->Signal(service_context.kernel);
}
Status BufferQueueProducer::Query(NativeWindow what, s32* out_value) {
@ -714,7 +714,7 @@ Status BufferQueueProducer::Disconnect(NativeWindowApi api) {
core->connected_producer_listener = nullptr;
core->connected_api = NativeWindowApi::NoConnectedApi;
core->SignalDequeueCondition();
buffer_wait_event->Signal();
buffer_wait_event->Signal(service_context.kernel);
listener = core->consumer_listener;
} else {
LOG_ERROR(Service_Nvnflinger,
@ -764,7 +764,7 @@ Status BufferQueueProducer::SetPreallocatedBuffer(s32 slot,
}
core->SignalDequeueCondition();
buffer_wait_event->Signal();
buffer_wait_event->Signal(service_context.kernel);
return Status::NoError;
}

2
src/core/hle/service/olsc/native_handle_holder.cpp
View file

@ -32,7 +32,7 @@ INativeHandleHolder::~INativeHandleHolder() {
Result INativeHandleHolder::GetNativeHandle(OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_OLSC, "(STUBBED) called");
if (event) {
event->Signal();
event->Signal(system.Kernel());
*out_event = std::addressof(event->GetReadableEvent());
} else {
*out_event = nullptr;

23
src/core/hle/service/os/event.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -7,25 +10,27 @@
namespace Service {
Event::Event(KernelHelpers::ServiceContext& ctx) {
Event::Event(KernelHelpers::ServiceContext& ctx_)
: ctx{ctx_}
{
m_event = ctx.CreateEvent("Event");
}
Event::~Event() {
m_event->GetReadableEvent().Close();
m_event->Close();
m_event->GetReadableEvent().Close(ctx.kernel);
m_event->Close(ctx.kernel);
}
void Event::Signal() {
m_event->Signal();
void Event::Signal(Kernel::KernelCore& kernel) noexcept {
m_event->Signal(kernel);
}
void Event::Clear() {
m_event->Clear();
void Event::Clear(Kernel::KernelCore& kernel) noexcept {
m_event->Clear(kernel);
}
Kernel::KReadableEvent* Event::GetHandle() {
return &m_event->GetReadableEvent();
Kernel::KReadableEvent* Event::GetHandle() noexcept {
return std::addressof(m_event->GetReadableEvent());
}
} // namespace Service

12
src/core/hle/service/os/event.h
View file

@ -1,9 +1,13 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
namespace Kernel {
class KernelCore;
class KEvent;
class KReadableEvent;
} // namespace Kernel
@ -19,12 +23,12 @@ public:
explicit Event(KernelHelpers::ServiceContext& ctx);
~Event();
void Signal();
void Clear();
Kernel::KReadableEvent* GetHandle();
void Signal(Kernel::KernelCore& kernel) noexcept;
void Clear(Kernel::KernelCore& kernel) noexcept;
Kernel::KReadableEvent* GetHandle() noexcept;
private:
KernelHelpers::ServiceContext& ctx;
Kernel::KEvent* m_event;
};

15
src/core/hle/service/os/mutex.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -10,22 +13,22 @@ namespace Service {
Mutex::Mutex(Core::System& system) : m_system(system) {
m_event = Kernel::KEvent::Create(system.Kernel());
m_event->Initialize(nullptr);
m_event->Initialize(system.Kernel(), nullptr);
// Register the event.
Kernel::KEvent::Register(system.Kernel(), m_event);
ASSERT(R_SUCCEEDED(m_event->Signal()));
ASSERT(R_SUCCEEDED(m_event->Signal(system.Kernel())));
}
Mutex::~Mutex() {
m_event->GetReadableEvent().Close();
m_event->Close();
m_event->GetReadableEvent().Close(m_system.Kernel());
m_event->Close(m_system.Kernel());
}
void Mutex::lock() {
// Infinitely retry until we successfully clear the event.
while (R_FAILED(m_event->GetReadableEvent().Reset())) {
while (R_FAILED(m_event->GetReadableEvent().Reset(m_system.Kernel()))) {
s32 index;
Kernel::KSynchronizationObject* obj = &m_event->GetReadableEvent();
@ -40,7 +43,7 @@ void Mutex::lock() {
void Mutex::unlock() {
// Unlock.
ASSERT(R_SUCCEEDED(m_event->Signal()));
ASSERT(R_SUCCEEDED(m_event->Signal(m_system.Kernel())));
}
} // namespace Service

27
src/core/hle/service/os/process.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -10,14 +13,6 @@
namespace Service {
Process::Process(Core::System& system)
: m_system(system), m_process(), m_main_thread_priority(), m_main_thread_stack_size(),
m_process_started() {}
Process::~Process() {
this->Finalize();
}
bool Process::Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_load_result) {
// First, ensure we are not holding another process.
this->Finalize();
@ -28,7 +23,7 @@ bool Process::Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_lo
// On exit, ensure we free the additional reference to the process.
SCOPE_EXIT {
process->Close();
process->Close(m_system.Kernel());
};
// Insert process modules into memory.
@ -52,7 +47,7 @@ bool Process::Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_lo
// Take ownership of the process object.
m_process = process;
m_process->Open();
m_process->Open(m_system.Kernel());
// We succeeded.
return true;
@ -64,8 +59,7 @@ void Process::Finalize() {
// Close the process.
if (m_process) {
m_process->Close();
m_process->Close(m_system.Kernel());
// TODO: remove this, kernel already tracks this
m_system.Kernel().RemoveProcess(m_process);
}
@ -85,7 +79,7 @@ bool Process::Run() {
// Start.
if (m_process) {
m_process->Run(m_main_thread_priority, m_main_thread_stack_size);
m_process->Run(m_system.Kernel(), m_main_thread_priority, m_main_thread_stack_size);
}
// Mark as started.
@ -97,13 +91,13 @@ bool Process::Run() {
void Process::Terminate() {
if (m_process) {
m_process->Terminate();
m_process->Terminate(m_system.Kernel());
}
}
void Process::ResetSignal() {
if (m_process) {
m_process->Reset();
m_process->Reset(m_system.Kernel());
}
}
@ -144,8 +138,7 @@ u64 Process::GetProgramId() const {
void Process::Suspend(bool suspended) {
if (m_process) {
m_process->SetActivity(suspended ? Kernel::Svc::ProcessActivity::Paused
: Kernel::Svc::ProcessActivity::Runnable);
m_process->SetActivity(m_system.Kernel(), suspended ? Kernel::Svc::ProcessActivity::Paused : Kernel::Svc::ProcessActivity::Runnable);
}
}

9
src/core/hle/service/os/process.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -22,8 +25,8 @@ namespace Service {
class Process {
public:
explicit Process(Core::System& system);
~Process();
inline explicit Process(Core::System& system) noexcept : m_system(system) {}
inline ~Process() { this->Finalize(); }
bool Initialize(Loader::AppLoader& loader, Loader::ResultStatus& out_load_result);
void Finalize();
@ -50,8 +53,8 @@ public:
private:
Core::System& m_system;
Kernel::KProcess* m_process{};
s32 m_main_thread_priority{};
u64 m_main_thread_stack_size{};
s32 m_main_thread_priority{};
bool m_process_started{};
};

33
src/core/hle/service/pm/pm.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -25,19 +28,15 @@ constexpr u64 NO_PROCESS_FOUND_PID{0};
using ProcessList = std::list<Kernel::KScopedAutoObject<Kernel::KProcess>>;
template <typename F>
Kernel::KScopedAutoObject<Kernel::KProcess> SearchProcessList(ProcessList& process_list,
F&& predicate) {
const auto iter = std::find_if(process_list.begin(), process_list.end(), predicate);
if (iter == process_list.end()) {
return nullptr;
}
return iter->GetPointerUnsafe();
Kernel::KScopedAutoObject<Kernel::KProcess> SearchProcessList(Kernel::KernelCore& kernel, ProcessList& process_list, F&& predicate) {
auto const it = std::find_if(process_list.begin(), process_list.end(), predicate);
if (it == process_list.end())
return {kernel, nullptr};
return {kernel, it->GetPointerUnsafe()};
}
void GetApplicationPidGeneric(HLERequestContext& ctx, ProcessList& process_list) {
auto process = SearchProcessList(process_list, [](auto& p) { return p->IsApplication(); });
void GetApplicationPidGeneric(Kernel::KernelCore& kernel, HLERequestContext& ctx, ProcessList& process_list) {
auto process = SearchProcessList(kernel, process_list, [](auto& p) { return p->IsApplication(); });
IPC::ResponseBuilder rb{ctx, 4};
rb.Push(ResultSuccess);
@ -105,7 +104,7 @@ private:
LOG_DEBUG(Service_PM, "called, program_id={:016X}", program_id);
auto list = kernel.GetProcessList();
auto process = SearchProcessList(
auto process = SearchProcessList(system.Kernel(),
list, [program_id](auto& p) { return p->GetProgramId() == program_id; });
if (process.IsNull()) {
@ -122,7 +121,7 @@ private:
void GetApplicationProcessId(HLERequestContext& ctx) {
LOG_DEBUG(Service_PM, "called");
auto list = kernel.GetProcessList();
GetApplicationPidGeneric(ctx, list);
GetApplicationPidGeneric(system.Kernel(), ctx, list);
}
void AtmosphereGetProcessInfo(HLERequestContext& ctx) {
@ -134,7 +133,7 @@ private:
LOG_WARNING(Service_PM, "(Partial Implementation) called, pid={:016X}", pid);
auto list = kernel.GetProcessList();
auto process = SearchProcessList(list, [pid](auto& p) { return p->GetProcessId() == pid; });
auto process = SearchProcessList(system.Kernel(), list, [pid](auto& p) { return p->GetProcessId() == pid; });
if (process.IsNull()) {
IPC::ResponseBuilder rb{ctx, 2};
@ -188,7 +187,7 @@ private:
LOG_DEBUG(Service_PM, "called, process_id={:016X}", process_id);
auto list = kernel.GetProcessList();
auto process = SearchProcessList(
auto process = SearchProcessList(system.Kernel(),
list, [process_id](auto& p) { return p->GetProcessId() == process_id; });
if (process.IsNull()) {
@ -209,7 +208,7 @@ private:
LOG_DEBUG(Service_PM, "called, program_id={:016X}", program_id);
auto list = system.Kernel().GetProcessList();
auto process = SearchProcessList(
auto process = SearchProcessList(system.Kernel(),
list, [program_id](auto& p) { return p->GetProgramId() == program_id; });
if (process.IsNull()) {
@ -249,7 +248,7 @@ private:
void GetApplicationProcessIdForShell(HLERequestContext& ctx) {
LOG_DEBUG(Service_PM, "called");
auto list = kernel.GetProcessList();
GetApplicationPidGeneric(ctx, list);
GetApplicationPidGeneric(system.Kernel(), ctx, list);
}
};

4
src/core/hle/service/psc/ovln/receiver.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@ -100,7 +100,7 @@ Result IReceiver::ReceiveWithTick(Out<OverlayNotification> out_notification,
}
}
if (!has_messages) {
receive_event->Clear();
receive_event->Clear(system.Kernel());
}
R_SUCCEED();

41
src/core/hle/service/psc/time/alarms.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -7,8 +10,10 @@
namespace Service::PSC::Time {
Alarm::Alarm(Core::System& system, KernelHelpers::ServiceContext& ctx, AlarmType type)
: m_ctx{ctx}, m_event{ctx.CreateEvent("Psc:Alarm:Event")} {
m_event->Clear();
: m_ctx{ctx}
, m_event{ctx.CreateEvent("Psc:Alarm:Event")}
{
m_event->Clear(system.Kernel());
switch (type) {
case WakeupAlarm:
@ -37,7 +42,7 @@ Alarms::~Alarms() {
m_ctx.CloseEvent(m_event);
}
Result Alarms::Enable(Alarm& alarm, s64 time) {
Result Alarms::Enable(Kernel::KernelCore& kernel, Alarm& alarm, s64 time) {
R_UNLESS(m_steady_clock.IsInitialized(), ResultClockUninitialized);
std::scoped_lock l{m_mutex};
@ -49,21 +54,21 @@ Result Alarms::Enable(Alarm& alarm, s64 time) {
time_ns = Common::AlignUp(time_ns, one_second_ns);
alarm.SetAlertTime(time_ns);
Insert(alarm);
R_RETURN(UpdateClosestAndSignal());
Insert(kernel, alarm);
R_RETURN(UpdateClosestAndSignal(kernel));
}
void Alarms::Disable(Alarm& alarm) {
void Alarms::Disable(Kernel::KernelCore& kernel, Alarm& alarm) {
std::scoped_lock l{m_mutex};
if (!alarm.IsLinked()) {
return;
}
Erase(alarm);
UpdateClosestAndSignal();
Erase(kernel, alarm);
UpdateClosestAndSignal(kernel);
}
void Alarms::CheckAndSignal() {
void Alarms::CheckAndSignal(Kernel::KernelCore& kernel) {
std::scoped_lock l{m_mutex};
if (m_alarms.empty()) {
return;
@ -72,9 +77,9 @@ void Alarms::CheckAndSignal() {
bool alarm_signalled{false};
for (auto& alarm : m_alarms) {
if (m_steady_clock.GetRawTime() >= alarm.GetAlertTime()) {
alarm.Signal();
alarm.Signal(kernel);
alarm.Lock();
Erase(alarm);
Erase(kernel, alarm);
m_power_state_request_manager.UpdatePendingPowerStateRequestPriority(
alarm.GetPriority());
@ -87,7 +92,7 @@ void Alarms::CheckAndSignal() {
}
m_power_state_request_manager.SignalPowerStateRequestAvailability();
UpdateClosestAndSignal();
UpdateClosestAndSignal(kernel);
}
bool Alarms::GetClosestAlarm(Alarm** out_alarm) {
@ -97,7 +102,7 @@ bool Alarms::GetClosestAlarm(Alarm** out_alarm) {
return alarm != nullptr;
}
void Alarms::Insert(Alarm& alarm) {
void Alarms::Insert(Kernel::KernelCore& kernel, Alarm& alarm) {
// Alarms are sorted by alert time, then priority
auto it{m_alarms.begin()};
while (it != m_alarms.end()) {
@ -113,15 +118,15 @@ void Alarms::Insert(Alarm& alarm) {
m_alarms.push_back(alarm);
}
void Alarms::Erase(Alarm& alarm) {
void Alarms::Erase(Kernel::KernelCore& kernel, Alarm& alarm) {
m_alarms.erase(m_alarms.iterator_to(alarm));
}
Result Alarms::UpdateClosestAndSignal() {
Result Alarms::UpdateClosestAndSignal(Kernel::KernelCore& kernel) {
m_closest_alarm = m_alarms.empty() ? nullptr : std::addressof(m_alarms.front());
R_SUCCEED_IF(m_closest_alarm == nullptr);
m_event->Signal();
m_event->Signal(kernel);
R_SUCCEED();
}
@ -183,7 +188,7 @@ void ISteadyClockAlarm::Enable(HLERequestContext& ctx) {
IPC::RequestParser rp{ctx};
auto time{rp.Pop<s64>()};
auto res = m_alarms.Enable(m_alarm, time);
auto res = m_alarms.Enable(system.Kernel(), m_alarm, time);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(res);
@ -192,7 +197,7 @@ void ISteadyClockAlarm::Enable(HLERequestContext& ctx) {
void ISteadyClockAlarm::Disable(HLERequestContext& ctx) {
LOG_DEBUG(Service_Time, "called.");
m_alarms.Disable(m_alarm);
m_alarms.Disable(system.Kernel(), m_alarm);
IPC::ResponseBuilder rb{ctx, 2};
rb.Push(ResultSuccess);

19
src/core/hle/service/psc/time/alarms.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -48,8 +51,8 @@ struct Alarm : public Common::IntrusiveListBaseNode<Alarm> {
return m_priority;
}
void Signal() {
m_event->Signal();
void Signal(Kernel::KernelCore& kernel) {
m_event->Signal(kernel);
}
Result Lock() {
@ -83,15 +86,15 @@ public:
return m_steady_clock.GetRawTime();
}
Result Enable(Alarm& alarm, s64 time);
void Disable(Alarm& alarm);
void CheckAndSignal();
Result Enable(Kernel::KernelCore& kernel, Alarm& alarm, s64 time);
void Disable(Kernel::KernelCore& kernel, Alarm& alarm);
void CheckAndSignal(Kernel::KernelCore& kernel);
bool GetClosestAlarm(Alarm** out_alarm);
private:
void Insert(Alarm& alarm);
void Erase(Alarm& alarm);
Result UpdateClosestAndSignal();
void Insert(Kernel::KernelCore& kernel, Alarm& alarm);
void Erase(Kernel::KernelCore& kernel, Alarm& alarm);
Result UpdateClosestAndSignal(Kernel::KernelCore& kernel);
Core::System& m_system;
KernelHelpers::ServiceContext m_ctx;

13
src/core/hle/service/psc/time/clocks/context_writers.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -6,10 +9,10 @@
namespace Service::PSC::Time {
void ContextWriter::SignalAllNodes() {
void ContextWriter::SignalAllNodes(Kernel::KernelCore& kernel) {
std::scoped_lock l{m_mutex};
for (auto& operation : m_operation_events) {
operation.m_event->Signal();
operation.m_event->Signal(kernel);
}
}
@ -33,7 +36,7 @@ Result LocalSystemClockContextWriter::Write(const SystemClockContext& context) {
m_shared_memory.SetLocalSystemContext(context);
SignalAllNodes();
SignalAllNodes(m_system.Kernel());
R_SUCCEED();
}
@ -57,7 +60,7 @@ Result NetworkSystemClockContextWriter::Write(const SystemClockContext& context)
m_shared_memory.SetNetworkSystemContext(context);
SignalAllNodes();
SignalAllNodes(m_system.Kernel());
R_SUCCEED();
}
@ -75,7 +78,7 @@ Result EphemeralNetworkSystemClockContextWriter::Write(const SystemClockContext&
m_in_use = true;
}
SignalAllNodes();
SignalAllNodes(m_system.Kernel());
R_SUCCEED();
}

8
src/core/hle/service/psc/time/clocks/context_writers.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -11,6 +14,9 @@
#include "core/hle/service/psc/time/common.h"
#include "core/hle/service/psc/time/shared_memory.h"
namespace Kernel {
class KernelCore;
}
namespace Core {
class System;
}
@ -25,7 +31,7 @@ public:
virtual ~ContextWriter() = default;
virtual Result Write(const SystemClockContext& context) = 0;
void SignalAllNodes();
void SignalAllNodes(Kernel::KernelCore& kernel);
void Link(OperationEvent& operation_event);
private:

5
src/core/hle/service/psc/time/clocks/standard_user_system_clock_core.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -57,7 +60,7 @@ Result StandardUserSystemClockCore::GetTimePoint(SteadyClockTimePoint& out_time_
void StandardUserSystemClockCore::SetTimePointAndSignal(SteadyClockTimePoint& time_point) {
m_time_point = time_point;
m_event->Signal();
m_event->Signal(m_system.Kernel());
}
} // namespace Service::PSC::Time

6
src/core/hle/service/psc/time/power_state_request_manager.cpp
View file

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@ -35,7 +35,7 @@ void PowerStateRequestManager::SignalPowerStateRequestAvailability() {
}
m_has_pending_request = false;
m_available_request_priority = m_pending_request_priority;
m_event->Signal();
m_event->Signal(m_system.Kernel());
}
}
@ -45,7 +45,7 @@ bool PowerStateRequestManager::GetAndClearPowerStateRequest(u32& out_priority) {
if (m_has_available_request) {
out_priority = m_available_request_priority;
m_has_available_request = false;
m_event->Clear();
m_event->Clear(m_system.Kernel());
}
return had_request;
}

5
src/core/hle/service/psc/time/service_manager.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -238,7 +241,7 @@ Result ServiceManager::GetClosestAlarmUpdatedEvent(
Result ServiceManager::CheckAndSignalAlarms() {
LOG_DEBUG(Service_Time, "called.");
m_alarms.CheckAndSignal();
m_alarms.CheckAndSignal(m_system.Kernel());
R_SUCCEED();
}

5
src/core/hle/service/psc/time/static.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -171,7 +174,7 @@ Result StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled(
R_TRY(m_time->m_standard_steady_clock.GetCurrentTimePoint(time_point));
m_user_system_clock.SetTimePointAndSignal(time_point);
m_user_system_clock.GetEvent().Signal();
m_user_system_clock.GetEvent().Signal(system.Kernel());
R_SUCCEED();
}

6
src/core/hle/service/ptm/psm.cpp
View file

@ -43,19 +43,19 @@ public:
void SignalChargerTypeChanged() {
if (should_signal && should_signal_charger_type) {
state_change_event->Signal();
state_change_event->Signal(system.Kernel());
}
}
void SignalPowerSupplyChanged() {
if (should_signal && should_signal_power_supply) {
state_change_event->Signal();
state_change_event->Signal(system.Kernel());
}
}
void SignalBatteryVoltageStateChanged() {
if (should_signal && should_signal_battery_voltage) {
state_change_event->Signal();
state_change_event->Signal(system.Kernel());
}
}

38
src/core/hle/service/ro/ro.cpp
View file

@ -57,7 +57,7 @@ struct NrrInfo {
struct ProcessContext {
constexpr ProcessContext() = default;
void Initialize(Kernel::KProcess* process, u64 process_id) {
void Initialize(Kernel::KernelCore& kernel, Kernel::KProcess* process, u64 process_id) {
ASSERT(!m_in_use);
m_nro_in_use = {};
@ -70,15 +70,15 @@ struct ProcessContext {
m_in_use = true;
if (m_process) {
m_process->Open();
m_process->Open(kernel);
}
}
void Finalize() {
void Finalize(Kernel::KernelCore& kernel) {
ASSERT(m_in_use);
if (m_process) {
m_process->Close();
m_process->Close(kernel);
}
m_nro_in_use = {};
@ -307,7 +307,7 @@ class RoContext {
public:
explicit RoContext() = default;
Result RegisterProcess(size_t* out_context_id, Kernel::KProcess* process, u64 process_id) {
Result RegisterProcess(Kernel::KernelCore& kernel, size_t* out_context_id, Kernel::KProcess* process, u64 process_id) {
// Validate process id.
R_UNLESS(process->GetProcessId() == process_id, RO::ResultInvalidProcess);
@ -315,7 +315,7 @@ public:
R_UNLESS(this->GetContextByProcessId(process_id) == nullptr, RO::ResultInvalidSession);
// Allocate a context to manage the process handle.
*out_context_id = this->AllocateContext(process, process_id);
*out_context_id = this->AllocateContext(kernel, process, process_id);
R_SUCCEED();
}
@ -327,8 +327,8 @@ public:
R_SUCCEED();
}
void UnregisterProcess(size_t context_id) {
this->FreeContext(context_id);
void UnregisterProcess(Kernel::KernelCore& kernel, size_t context_id) {
this->FreeContext(kernel, context_id);
}
Result RegisterModuleInfo(size_t context_id, u64 nrr_address, u64 nrr_size, NrrKind nrr_kind,
@ -481,13 +481,13 @@ private:
return nullptr;
}
size_t AllocateContext(Kernel::KProcess* process, u64 process_id) {
size_t AllocateContext(Kernel::KernelCore& kernel, Kernel::KProcess* process, u64 process_id) {
// Find a free process context.
for (size_t i = 0; i < MaxSessions; i++) {
ProcessContext* context = std::addressof(process_contexts[i]);
if (context->IsFree()) {
context->Initialize(process, process_id);
context->Initialize(kernel, process, process_id);
return i;
}
}
@ -496,9 +496,9 @@ private:
UNREACHABLE();
}
void FreeContext(size_t context_id) {
void FreeContext(Kernel::KernelCore& kernel, size_t context_id) {
if (ProcessContext* context = GetContextById(context_id); context != nullptr) {
context->Finalize();
context->Finalize(kernel);
}
}
};
@ -525,7 +525,7 @@ public:
}
~RoInterface() {
m_ro->UnregisterProcess(m_context_id);
m_ro->UnregisterProcess(system.Kernel(), m_context_id);
}
Result MapManualLoadModuleMemory(Out<u64> out_load_address, ClientProcessId client_pid,
@ -551,20 +551,16 @@ public:
R_RETURN(m_ro->UnregisterModuleInfo(m_context_id, nrr_address));
}
Result RegisterProcessHandle(ClientProcessId client_pid,
InCopyHandle<Kernel::KProcess> process) {
Result RegisterProcessHandle(ClientProcessId client_pid, InCopyHandle<Kernel::KProcess> process) {
// Register the process.
R_RETURN(m_ro->RegisterProcess(std::addressof(m_context_id), process.Get(), *client_pid));
R_RETURN(m_ro->RegisterProcess(system.Kernel(), std::addressof(m_context_id), process.Get(), *client_pid));
}
Result RegisterProcessModuleInfo(ClientProcessId client_pid, u64 nrr_address, u64 nrr_size,
InCopyHandle<Kernel::KProcess> process) {
Result RegisterProcessModuleInfo(ClientProcessId client_pid, u64 nrr_address, u64 nrr_size, InCopyHandle<Kernel::KProcess> process) {
// Validate the process.
R_TRY(m_ro->ValidateProcess(m_context_id, *client_pid));
// Register the module.
R_RETURN(m_ro->RegisterModuleInfo(m_context_id, nrr_address, nrr_size, m_nrr_kind,
m_nrr_kind == NrrKind::JitPlugin));
R_RETURN(m_ro->RegisterModuleInfo(m_context_id, nrr_address, nrr_size, m_nrr_kind, m_nrr_kind == NrrKind::JitPlugin));
}
private:

65
src/core/hle/service/server_manager.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -28,13 +31,15 @@ enum class UserDataTag {
class Port : public MultiWaitHolder, public Common::IntrusiveListBaseNode<Port> {
public:
explicit Port(Kernel::KServerPort* server_port, SessionRequestHandlerFactory&& handler_factory)
: MultiWaitHolder(server_port), m_handler_factory(std::move(handler_factory)) {
explicit Port(Kernel::KernelCore& kernel, Kernel::KServerPort* server_port, SessionRequestHandlerFactory&& handler_factory)
: MultiWaitHolder(server_port), m_handler_factory(std::move(handler_factory))
, m_kernel{kernel}
{
this->SetUserData(static_cast<uintptr_t>(UserDataTag::Port));
}
~Port() {
this->GetNativeHandle()->Close();
this->GetNativeHandle()->Close(m_kernel);
}
SessionRequestHandlerPtr CreateHandler() {
@ -43,18 +48,20 @@ public:
private:
const SessionRequestHandlerFactory m_handler_factory;
Kernel::KernelCore& m_kernel;
};
class Session : public MultiWaitHolder, public Common::IntrusiveListBaseNode<Session> {
public:
explicit Session(Kernel::KServerSession* server_session,
std::shared_ptr<SessionRequestManager>&& manager)
: MultiWaitHolder(server_session), m_manager(std::move(manager)) {
explicit Session(Kernel::KernelCore& kernel, Kernel::KServerSession* server_session, std::shared_ptr<SessionRequestManager>&& manager)
: MultiWaitHolder(server_session), m_manager(std::move(manager))
, m_kernel{kernel}
{
this->SetUserData(static_cast<uintptr_t>(UserDataTag::Session));
}
~Session() {
this->GetNativeHandle()->Close();
this->GetNativeHandle()->Close(m_kernel);
}
std::shared_ptr<SessionRequestManager>& GetManager() {
@ -68,12 +75,16 @@ public:
private:
std::shared_ptr<SessionRequestManager> m_manager;
std::shared_ptr<HLERequestContext> m_context;
Kernel::KernelCore& m_kernel;
};
ServerManager::ServerManager(Core::System& system) : m_system{system}, m_selection_mutex{system} {
ServerManager::ServerManager(Core::System& system)
: m_system{system}
, m_selection_mutex{system}
{
// Initialize event.
m_wakeup_event = Kernel::KEvent::Create(system.Kernel());
m_wakeup_event->Initialize(nullptr);
m_wakeup_event->Initialize(m_system.Kernel(), nullptr);
// Register event.
Kernel::KEvent::Register(system.Kernel(), m_wakeup_event);
@ -86,7 +97,7 @@ ServerManager::ServerManager(Core::System& system) : m_system{system}, m_selecti
ServerManager::~ServerManager() {
// Signal stop.
m_stop_source.request_stop();
m_wakeup_event->Signal();
m_wakeup_event->Signal(m_system.Kernel());
// Wait for processing to stop.
m_stopped.Wait();
@ -109,11 +120,11 @@ ServerManager::~ServerManager() {
}
// Close wakeup event.
m_wakeup_event->GetReadableEvent().Close();
m_wakeup_event->Close();
m_wakeup_event->GetReadableEvent().Close(m_system.Kernel());
m_wakeup_event->Close(m_system.Kernel());
if (m_deferral_event) {
m_deferral_event->GetReadableEvent().Close();
m_deferral_event->GetReadableEvent().Close(m_system.Kernel());
// Write event is owned by ServiceManager
}
}
@ -125,7 +136,7 @@ void ServerManager::RunServer(std::unique_ptr<ServerManager>&& server_manager) {
Result ServerManager::RegisterSession(Kernel::KServerSession* server_session,
std::shared_ptr<SessionRequestManager> manager) {
// We are taking ownership of the server session, so don't open it.
auto* session = new Session(server_session, std::move(manager));
auto* session = new Session(m_system.Kernel(), server_session, std::move(manager));
// Begin tracking the server session.
{
@ -148,7 +159,7 @@ Result ServerManager::RegisterNamedService(const std::string& service_name,
max_sessions, handler_factory));
// We are taking ownership of the server port, so don't open it.
auto* server = new Port(server_port, std::move(handler_factory));
auto* server = new Port(m_system.Kernel(), server_port, std::move(handler_factory));
// Begin tracking the server port.
{
@ -177,15 +188,15 @@ Result ServerManager::ManageNamedPort(const std::string& service_name,
u32 max_sessions) {
// Create a new port.
auto* port = Kernel::KPort::Create(m_system.Kernel());
port->Initialize(max_sessions, false, 0);
port->Initialize(m_system.Kernel(), max_sessions, false, 0);
// Register the port.
Kernel::KPort::Register(m_system.Kernel(), port);
// Ensure that our reference to the port is closed if we fail to register it.
SCOPE_EXIT {
port->GetClientPort().Close();
port->GetServerPort().Close();
port->GetClientPort().Close(m_system.Kernel());
port->GetServerPort().Close(m_system.Kernel());
};
// Register the object name with the kernel.
@ -193,10 +204,10 @@ Result ServerManager::ManageNamedPort(const std::string& service_name,
service_name.c_str()));
// Open a new reference to the server port.
port->GetServerPort().Open();
port->GetServerPort().Open(m_system.Kernel());
// Transfer ownership into a new port object.
auto* server = new Port(std::addressof(port->GetServerPort()), std::move(handler_factory));
auto* server = new Port(m_system.Kernel(), std::addressof(port->GetServerPort()), std::move(handler_factory));
// Begin tracking the port.
{
@ -217,7 +228,7 @@ Result ServerManager::ManageDeferral(Kernel::KEvent** out_event) {
ASSERT(m_deferral_event != nullptr);
// Initialize the event.
m_deferral_event->Initialize(nullptr);
m_deferral_event->Initialize(m_system.Kernel(), nullptr);
// Register the event.
Kernel::KEvent::Register(m_system.Kernel(), m_deferral_event);
@ -258,7 +269,7 @@ void ServerManager::LinkToDeferredList(MultiWaitHolder* holder) {
}
// Signal the wakeup event.
m_wakeup_event->Signal();
m_wakeup_event->Signal(m_system.Kernel());
}
void ServerManager::LinkDeferred() {
@ -281,7 +292,7 @@ MultiWaitHolder* ServerManager::WaitSignaled() {
auto* selected = m_multi_wait.WaitAny(m_system.Kernel());
if (selected == std::addressof(*m_wakeup_holder)) {
// Clear and restart if we were woken up.
m_wakeup_event->Clear();
m_wakeup_event->Clear(m_system.Kernel());
} else {
// Unlink and handle the event.
selected->UnlinkFromMultiWait();
@ -323,7 +334,7 @@ Result ServerManager::LoopProcessImpl() {
Result ServerManager::OnPortEvent(Port* server) {
// Accept a new server session.
auto* server_port = static_cast<Kernel::KServerPort*>(server->GetNativeHandle());
Kernel::KServerSession* server_session = server_port->AcceptSession();
Kernel::KServerSession* server_session = server_port->AcceptSession(m_system.Kernel());
ASSERT(server_session != nullptr);
// Create the session manager and install the handler.
@ -345,7 +356,7 @@ Result ServerManager::OnSessionEvent(Session* session) {
// Try to receive a message.
auto* server_session = static_cast<Kernel::KServerSession*>(session->GetNativeHandle());
res = server_session->ReceiveRequestHLE(&session->GetContext(), session->GetManager());
res = server_session->ReceiveRequestHLE(m_system.Kernel(), &session->GetContext(), session->GetManager());
// If the session has been closed, we're done.
if (res == Kernel::ResultSessionClosed) {
@ -382,7 +393,7 @@ Result ServerManager::CompleteSyncRequest(Session* session) {
}
// Send the reply.
res = server_session->SendReplyHLE();
res = server_session->SendReplyHLE(m_system.Kernel());
// If the session has been closed, we're done.
if (res == Kernel::ResultSessionClosed || service_res == IPC::ResultSessionClosed) {
@ -401,7 +412,7 @@ Result ServerManager::CompleteSyncRequest(Session* session) {
Result ServerManager::OnDeferralEvent() {
// Clear event before grabbing the list.
m_deferral_event->Clear();
m_deferral_event->Clear(m_system.Kernel());
// Get and clear list.
const auto deferrals = [&] {

10
src/core/hle/service/sm/sm.cpp
View file

@ -33,11 +33,11 @@ ServiceManager::ServiceManager(Kernel::KernelCore& kernel_) : kernel{kernel_} {
ServiceManager::~ServiceManager() {
for (auto& [name, port] : service_ports) {
port->Close();
port->Close(kernel);
}
if (deferral_event) {
deferral_event->Close();
deferral_event->Close(kernel);
}
}
@ -64,7 +64,7 @@ Result ServiceManager::RegisterService(Kernel::KServerPort** out_server_port, st
}
auto* port = Kernel::KPort::Create(kernel);
port->Initialize(ServerSessionCountMax, false, 0);
port->Initialize(kernel, ServerSessionCountMax, false, 0);
// Register the port.
Kernel::KPort::Register(kernel, port);
@ -72,7 +72,7 @@ Result ServiceManager::RegisterService(Kernel::KServerPort** out_server_port, st
service_ports.emplace(name, std::addressof(port->GetClientPort()));
registered_services.emplace(name, handler);
if (deferral_event) {
deferral_event->Signal();
deferral_event->Signal(kernel);
}
// Set our output.
@ -195,7 +195,7 @@ Result SM::GetServiceImpl(Kernel::KClientSession** out_client_session, HLEReques
// Create a new session.
Kernel::KClientSession* session{};
if (const auto result = client_port->CreateSession(&session); result.IsError()) {
if (const auto result = client_port->CreateSession(kernel, &session); result.IsError()) {
LOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name, result.raw);
return result;
}

5
src/core/hle/service/sm/sm_controller.cpp
View file

@ -37,8 +37,7 @@ void Controller::CloneCurrentObject(HLERequestContext& ctx) {
// once this is a proper process
// Reserve a new session from the process resource limit.
Kernel::KScopedResourceReservation session_reservation(
Kernel::GetCurrentProcessPointer(kernel), Kernel::LimitableResource::SessionCountMax);
Kernel::KScopedResourceReservation session_reservation(system.Kernel(), Kernel::GetCurrentProcessPointer(kernel), Kernel::LimitableResource::SessionCountMax);
ASSERT(session_reservation.Succeeded());
// Create the session.
@ -46,7 +45,7 @@ void Controller::CloneCurrentObject(HLERequestContext& ctx) {
ASSERT(session != nullptr);
// Initialize the session.
session->Initialize(nullptr, 0);
session->Initialize(kernel, nullptr, 0);
// Commit the session reservation.
session_reservation.Commit();

2
src/core/hle/service/vi/conductor.cpp
View file

@ -70,7 +70,7 @@ void Conductor::UnlinkVsyncEvent(u64 display_id, Event* event) {
void Conductor::ProcessVsync() {
for (auto& [display_id, manager] : m_vsync_managers) {
m_container.ComposeOnDisplay(&m_swap_interval, &m_compose_speed_scale, display_id);
manager.SignalVsync();
manager.SignalVsync(m_system.Kernel());
}
}

15
src/core/hle/service/vi/vsync_manager.cpp
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -9,18 +12,10 @@ namespace Service::VI {
VsyncManager::VsyncManager() = default;
VsyncManager::~VsyncManager() = default;
void VsyncManager::SignalVsync() {
void VsyncManager::SignalVsync(Kernel::KernelCore& kernel) {
for (auto* event : m_vsync_events) {
event->Signal();
event->Signal(kernel);
}
}
void VsyncManager::LinkVsyncEvent(Event* event) {
m_vsync_events.insert(event);
}
void VsyncManager::UnlinkVsyncEvent(Event* event) {
m_vsync_events.erase(event);
}
} // namespace Service::VI

17
src/core/hle/service/vi/vsync_manager.h
View file

@ -1,3 +1,6 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
@ -5,6 +8,10 @@
#include <set>
namespace Kernel {
class KernelCore;
}
namespace Service {
class Event;
}
@ -18,9 +25,13 @@ public:
explicit VsyncManager();
~VsyncManager();
void SignalVsync();
void LinkVsyncEvent(Event* event);
void UnlinkVsyncEvent(Event* event);
void SignalVsync(Kernel::KernelCore& kernel);
void LinkVsyncEvent(Event* event) {
m_vsync_events.insert(event);
}
void UnlinkVsyncEvent(Event* event) {
m_vsync_events.erase(event);
}
private:
std::set<Event*> m_vsync_events;