Merge pull request #10117 from liamwhite/sync-register

kernel: match calls to Register and Unregister
This commit is contained in:
bunnei 2023-05-03 09:07:19 -07:00 committed by GitHub
commit 737e1ca101
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 50 additions and 5 deletions

View File

@ -293,6 +293,7 @@ struct System::Impl {
ASSERT(Kernel::KProcess::Initialize(main_process, system, "main", ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
Kernel::KProcess::ProcessType::Userland, resource_limit) Kernel::KProcess::ProcessType::Userland, resource_limit)
.IsSuccess()); .IsSuccess());
Kernel::KProcess::Register(system.Kernel(), main_process);
kernel.MakeApplicationProcess(main_process); kernel.MakeApplicationProcess(main_process);
const auto [load_result, load_parameters] = app_loader->Load(*main_process, system); const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
if (load_result != Loader::ResultStatus::Success) { if (load_result != Loader::ResultStatus::Success) {

View File

@ -182,8 +182,8 @@ public:
explicit KAutoObjectWithList(KernelCore& kernel) : KAutoObject(kernel) {} explicit KAutoObjectWithList(KernelCore& kernel) : KAutoObject(kernel) {}
static int Compare(const KAutoObjectWithList& lhs, const KAutoObjectWithList& rhs) { static int Compare(const KAutoObjectWithList& lhs, const KAutoObjectWithList& rhs) {
const u64 lid = lhs.GetId(); const uintptr_t lid = reinterpret_cast<uintptr_t>(std::addressof(lhs));
const u64 rid = rhs.GetId(); const uintptr_t rid = reinterpret_cast<uintptr_t>(std::addressof(rhs));
if (lid < rid) { if (lid < rid) {
return -1; return -1;

View File

@ -95,7 +95,7 @@ struct KernelCore::Impl {
pt_heap_region.GetSize()); pt_heap_region.GetSize());
} }
InitializeHackSharedMemory(); InitializeHackSharedMemory(kernel);
RegisterHostThread(nullptr); RegisterHostThread(nullptr);
} }
@ -216,10 +216,12 @@ struct KernelCore::Impl {
auto* main_thread{Kernel::KThread::Create(system.Kernel())}; auto* main_thread{Kernel::KThread::Create(system.Kernel())};
main_thread->SetCurrentCore(core); main_thread->SetCurrentCore(core);
ASSERT(Kernel::KThread::InitializeMainThread(system, main_thread, core).IsSuccess()); ASSERT(Kernel::KThread::InitializeMainThread(system, main_thread, core).IsSuccess());
KThread::Register(system.Kernel(), main_thread);
auto* idle_thread{Kernel::KThread::Create(system.Kernel())}; auto* idle_thread{Kernel::KThread::Create(system.Kernel())};
idle_thread->SetCurrentCore(core); idle_thread->SetCurrentCore(core);
ASSERT(Kernel::KThread::InitializeIdleThread(system, idle_thread, core).IsSuccess()); ASSERT(Kernel::KThread::InitializeIdleThread(system, idle_thread, core).IsSuccess());
KThread::Register(system.Kernel(), idle_thread);
schedulers[i]->Initialize(main_thread, idle_thread, core); schedulers[i]->Initialize(main_thread, idle_thread, core);
} }
@ -230,6 +232,7 @@ struct KernelCore::Impl {
const Core::Timing::CoreTiming& core_timing) { const Core::Timing::CoreTiming& core_timing) {
system_resource_limit = KResourceLimit::Create(system.Kernel()); system_resource_limit = KResourceLimit::Create(system.Kernel());
system_resource_limit->Initialize(&core_timing); system_resource_limit->Initialize(&core_timing);
KResourceLimit::Register(kernel, system_resource_limit);
const auto sizes{memory_layout->GetTotalAndKernelMemorySizes()}; const auto sizes{memory_layout->GetTotalAndKernelMemorySizes()};
const auto total_size{sizes.first}; const auto total_size{sizes.first};
@ -355,6 +358,7 @@ struct KernelCore::Impl {
ASSERT(KThread::InitializeHighPriorityThread(system, shutdown_threads[core_id], {}, {}, ASSERT(KThread::InitializeHighPriorityThread(system, shutdown_threads[core_id], {}, {},
core_id) core_id)
.IsSuccess()); .IsSuccess());
KThread::Register(system.Kernel(), shutdown_threads[core_id]);
} }
} }
@ -729,7 +733,7 @@ struct KernelCore::Impl {
memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize()); memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize());
} }
void InitializeHackSharedMemory() { void InitializeHackSharedMemory(KernelCore& kernel) {
// Setup memory regions for emulated processes // Setup memory regions for emulated processes
// TODO(bunnei): These should not be hardcoded regions initialized within the kernel // TODO(bunnei): These should not be hardcoded regions initialized within the kernel
constexpr std::size_t hid_size{0x40000}; constexpr std::size_t hid_size{0x40000};
@ -746,14 +750,23 @@ struct KernelCore::Impl {
hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None, hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
Svc::MemoryPermission::Read, hid_size); Svc::MemoryPermission::Read, hid_size);
KSharedMemory::Register(kernel, hid_shared_mem);
font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None, font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
Svc::MemoryPermission::Read, font_size); Svc::MemoryPermission::Read, font_size);
KSharedMemory::Register(kernel, font_shared_mem);
irs_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None, irs_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
Svc::MemoryPermission::Read, irs_size); Svc::MemoryPermission::Read, irs_size);
KSharedMemory::Register(kernel, irs_shared_mem);
time_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None, time_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
Svc::MemoryPermission::Read, time_size); Svc::MemoryPermission::Read, time_size);
KSharedMemory::Register(kernel, time_shared_mem);
hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None, hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
Svc::MemoryPermission::Read, hidbus_size); Svc::MemoryPermission::Read, hidbus_size);
KSharedMemory::Register(kernel, hidbus_shared_mem);
} }
std::mutex registered_objects_lock; std::mutex registered_objects_lock;
@ -1072,12 +1085,15 @@ static std::jthread RunHostThreadFunc(KernelCore& kernel, KProcess* process,
// Commit the thread reservation. // Commit the thread reservation.
thread_reservation.Commit(); thread_reservation.Commit();
// Register the thread.
KThread::Register(kernel, thread);
return std::jthread( return std::jthread(
[&kernel, thread, thread_name{std::move(thread_name)}, func{std::move(func)}] { [&kernel, thread, thread_name{std::move(thread_name)}, func{std::move(func)}] {
// Set the thread name. // Set the thread name.
Common::SetCurrentThreadName(thread_name.c_str()); Common::SetCurrentThreadName(thread_name.c_str());
// Register the thread. // Set the thread as current.
kernel.RegisterHostThread(thread); kernel.RegisterHostThread(thread);
// Run the callback. // Run the callback.
@ -1099,6 +1115,9 @@ std::jthread KernelCore::RunOnHostCoreProcess(std::string&& process_name,
// Ensure that we don't hold onto any extra references. // Ensure that we don't hold onto any extra references.
SCOPE_EXIT({ process->Close(); }); SCOPE_EXIT({ process->Close(); });
// Register the new process.
KProcess::Register(*this, process);
// Run the host thread. // Run the host thread.
return RunHostThreadFunc(*this, process, std::move(process_name), std::move(func)); return RunHostThreadFunc(*this, process, std::move(process_name), std::move(func));
} }
@ -1124,6 +1143,9 @@ void KernelCore::RunOnGuestCoreProcess(std::string&& process_name, std::function
// Ensure that we don't hold onto any extra references. // Ensure that we don't hold onto any extra references.
SCOPE_EXIT({ process->Close(); }); SCOPE_EXIT({ process->Close(); });
// Register the new process.
KProcess::Register(*this, process);
// Reserve a new thread from the process resource limit. // Reserve a new thread from the process resource limit.
KScopedResourceReservation thread_reservation(process, LimitableResource::ThreadCountMax); KScopedResourceReservation thread_reservation(process, LimitableResource::ThreadCountMax);
ASSERT(thread_reservation.Succeeded()); ASSERT(thread_reservation.Succeeded());
@ -1136,6 +1158,9 @@ void KernelCore::RunOnGuestCoreProcess(std::string&& process_name, std::function
// Commit the thread reservation. // Commit the thread reservation.
thread_reservation.Commit(); thread_reservation.Commit();
// Register the new thread.
KThread::Register(*this, thread);
// Begin running the thread. // Begin running the thread.
ASSERT(R_SUCCEEDED(thread->Run())); ASSERT(R_SUCCEEDED(thread->Run()));
} }

View File

@ -156,6 +156,7 @@ public:
auto* session = Kernel::KSession::Create(kernel); auto* session = Kernel::KSession::Create(kernel);
session->Initialize(nullptr, 0); session->Initialize(nullptr, 0);
Kernel::KSession::Register(kernel, session);
auto next_manager = std::make_shared<Service::SessionRequestManager>( auto next_manager = std::make_shared<Service::SessionRequestManager>(
kernel, manager->GetServerManager()); kernel, manager->GetServerManager());

View File

@ -25,6 +25,9 @@ ServiceContext::ServiceContext(Core::System& system_, std::string name_)
Kernel::KProcess::ProcessType::KernelInternal, Kernel::KProcess::ProcessType::KernelInternal,
kernel.GetSystemResourceLimit()) kernel.GetSystemResourceLimit())
.IsSuccess()); .IsSuccess());
// Register the process.
Kernel::KProcess::Register(kernel, process);
process_created = true; process_created = true;
} }

View File

@ -12,6 +12,9 @@ Mutex::Mutex(Core::System& system) : m_system(system) {
m_event = Kernel::KEvent::Create(system.Kernel()); m_event = Kernel::KEvent::Create(system.Kernel());
m_event->Initialize(nullptr); m_event->Initialize(nullptr);
// Register the event.
Kernel::KEvent::Register(system.Kernel(), m_event);
ASSERT(R_SUCCEEDED(m_event->Signal())); ASSERT(R_SUCCEEDED(m_event->Signal()));
} }

View File

@ -33,6 +33,9 @@ ServerManager::ServerManager(Core::System& system) : m_system{system}, m_serve_m
// Initialize event. // Initialize event.
m_event = Kernel::KEvent::Create(system.Kernel()); m_event = Kernel::KEvent::Create(system.Kernel());
m_event->Initialize(nullptr); m_event->Initialize(nullptr);
// Register event.
Kernel::KEvent::Register(system.Kernel(), m_event);
} }
ServerManager::~ServerManager() { ServerManager::~ServerManager() {
@ -160,6 +163,9 @@ Result ServerManager::ManageDeferral(Kernel::KEvent** out_event) {
// Initialize the event. // Initialize the event.
m_deferral_event->Initialize(nullptr); m_deferral_event->Initialize(nullptr);
// Register the event.
Kernel::KEvent::Register(m_system.Kernel(), m_deferral_event);
// Set the output. // Set the output.
*out_event = m_deferral_event; *out_event = m_deferral_event;

View File

@ -64,6 +64,9 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
auto* port = Kernel::KPort::Create(kernel); auto* port = Kernel::KPort::Create(kernel);
port->Initialize(ServerSessionCountMax, false, 0); port->Initialize(ServerSessionCountMax, false, 0);
// Register the port.
Kernel::KPort::Register(kernel, port);
service_ports.emplace(name, port); service_ports.emplace(name, port);
registered_services.emplace(name, handler); registered_services.emplace(name, handler);
if (deferral_event) { if (deferral_event) {

View File

@ -49,6 +49,9 @@ void Controller::CloneCurrentObject(HLERequestContext& ctx) {
// Commit the session reservation. // Commit the session reservation.
session_reservation.Commit(); session_reservation.Commit();
// Register the session.
Kernel::KSession::Register(system.Kernel(), session);
// Register with server manager. // Register with server manager.
session_manager->GetServerManager().RegisterSession(&session->GetServerSession(), session_manager->GetServerManager().RegisterSession(&session->GetServerSession(),
session_manager); session_manager);