1
0
Fork 0
forked from suyu/suyu

hle: kernel: Track and release server sessions, and protect methods with locks.

This commit is contained in:
bunnei 2021-07-02 15:19:04 -07:00
parent 8d755147d8
commit 52caa52cc2
4 changed files with 82 additions and 13 deletions

View file

@ -58,6 +58,9 @@ bool SessionRequestManager::HasSessionRequestHandler(const HLERequestContext& co
void SessionRequestHandler::ClientConnected(KServerSession* session) { void SessionRequestHandler::ClientConnected(KServerSession* session) {
session->ClientConnected(shared_from_this()); session->ClientConnected(shared_from_this());
// Ensure our server session is tracked globally.
kernel.RegisterServerSession(session);
} }
void SessionRequestHandler::ClientDisconnected(KServerSession* session) { void SessionRequestHandler::ClientDisconnected(KServerSession* session) {

View file

@ -28,7 +28,10 @@ namespace Kernel {
KServerSession::KServerSession(KernelCore& kernel_) : KSynchronizationObject{kernel_} {} KServerSession::KServerSession(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
KServerSession::~KServerSession() {} KServerSession::~KServerSession() {
// Ensure that the global list tracking server sessions does not hold on to a reference.
kernel.UnregisterServerSession(this);
}
void KServerSession::Initialize(KSession* parent_session_, std::string&& name_, void KServerSession::Initialize(KSession* parent_session_, std::string&& name_,
std::shared_ptr<SessionRequestManager> manager_) { std::shared_ptr<SessionRequestManager> manager_) {

View file

@ -91,15 +91,39 @@ struct KernelCore::Impl {
} }
void Shutdown() { void Shutdown() {
// Shutdown all processes.
if (current_process) { if (current_process) {
current_process->Finalize(); current_process->Finalize();
current_process->Close(); current_process->Close();
current_process = nullptr; current_process = nullptr;
} }
process_list.clear(); process_list.clear();
// Ensures all service threads gracefully shutdown // Close all open server ports.
std::unordered_set<KServerPort*> server_ports_;
{
std::lock_guard lk(server_ports_lock);
server_ports_ = server_ports;
server_ports.clear();
}
for (auto* server_port : server_ports_) {
server_port->Close();
}
// Close all open server sessions.
std::unordered_set<KServerSession*> server_sessions_;
{
std::lock_guard lk(server_sessions_lock);
server_sessions_ = server_sessions;
server_sessions.clear();
}
for (auto* server_session : server_sessions_) {
server_session->Close();
}
// Ensure that the object list container is finalized and properly shutdown.
object_list_container.Finalize();
// Ensures all service threads gracefully shutdown.
service_threads.clear(); service_threads.clear();
next_object_id = 0; next_object_id = 0;
@ -147,10 +171,13 @@ struct KernelCore::Impl {
next_host_thread_id = Core::Hardware::NUM_CPU_CORES; next_host_thread_id = Core::Hardware::NUM_CPU_CORES;
// Track kernel objects that were not freed on shutdown // Track kernel objects that were not freed on shutdown
if (registered_objects.size()) { {
LOG_WARNING(Kernel, "{} kernel objects were dangling on shutdown!", std::lock_guard lk(registered_objects_lock);
registered_objects.size()); if (registered_objects.size()) {
registered_objects.clear(); LOG_WARNING(Kernel, "{} kernel objects were dangling on shutdown!",
registered_objects.size());
registered_objects.clear();
}
} }
} }
@ -640,6 +667,21 @@ struct KernelCore::Impl {
user_slab_heap_size); user_slab_heap_size);
} }
KClientPort* CreateNamedServicePort(std::string name) {
auto search = service_interface_factory.find(name);
if (search == service_interface_factory.end()) {
UNIMPLEMENTED();
return {};
}
KClientPort* port = &search->second(system.ServiceManager(), system);
{
std::lock_guard lk(server_ports_lock);
server_ports.insert(&port->GetParent()->GetServerPort());
}
return port;
}
std::atomic<u32> next_object_id{0}; std::atomic<u32> next_object_id{0};
std::atomic<u64> next_kernel_process_id{KProcess::InitialKIPIDMin}; std::atomic<u64> next_kernel_process_id{KProcess::InitialKIPIDMin};
std::atomic<u64> next_user_process_id{KProcess::ProcessIDMin}; std::atomic<u64> next_user_process_id{KProcess::ProcessIDMin};
@ -666,7 +708,12 @@ struct KernelCore::Impl {
/// the ConnectToPort SVC. /// the ConnectToPort SVC.
std::unordered_map<std::string, ServiceInterfaceFactory> service_interface_factory; std::unordered_map<std::string, ServiceInterfaceFactory> service_interface_factory;
NamedPortTable named_ports; NamedPortTable named_ports;
std::unordered_set<KServerPort*> server_ports;
std::unordered_set<KServerSession*> server_sessions;
std::unordered_set<KAutoObject*> registered_objects; std::unordered_set<KAutoObject*> registered_objects;
std::mutex server_ports_lock;
std::mutex server_sessions_lock;
std::mutex registered_objects_lock;
std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor; std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
std::vector<Kernel::PhysicalCore> cores; std::vector<Kernel::PhysicalCore> cores;
@ -855,19 +902,26 @@ void KernelCore::RegisterNamedService(std::string name, ServiceInterfaceFactory&
} }
KClientPort* KernelCore::CreateNamedServicePort(std::string name) { KClientPort* KernelCore::CreateNamedServicePort(std::string name) {
auto search = impl->service_interface_factory.find(name); return impl->CreateNamedServicePort(std::move(name));
if (search == impl->service_interface_factory.end()) { }
UNIMPLEMENTED();
return {}; void KernelCore::RegisterServerSession(KServerSession* server_session) {
} std::lock_guard lk(impl->server_sessions_lock);
return &search->second(impl->system.ServiceManager(), impl->system); impl->server_sessions.insert(server_session);
}
void KernelCore::UnregisterServerSession(KServerSession* server_session) {
std::lock_guard lk(impl->server_sessions_lock);
impl->server_sessions.erase(server_session);
} }
void KernelCore::RegisterKernelObject(KAutoObject* object) { void KernelCore::RegisterKernelObject(KAutoObject* object) {
std::lock_guard lk(impl->registered_objects_lock);
impl->registered_objects.insert(object); impl->registered_objects.insert(object);
} }
void KernelCore::UnregisterKernelObject(KAutoObject* object) { void KernelCore::UnregisterKernelObject(KAutoObject* object) {
std::lock_guard lk(impl->registered_objects_lock);
impl->registered_objects.erase(object); impl->registered_objects.erase(object);
} }

View file

@ -45,6 +45,7 @@ class KPort;
class KProcess; class KProcess;
class KResourceLimit; class KResourceLimit;
class KScheduler; class KScheduler;
class KServerSession;
class KSession; class KSession;
class KSharedMemory; class KSharedMemory;
class KThread; class KThread;
@ -185,6 +186,14 @@ public:
/// Opens a port to a service previously registered with RegisterNamedService. /// Opens a port to a service previously registered with RegisterNamedService.
KClientPort* CreateNamedServicePort(std::string name); KClientPort* CreateNamedServicePort(std::string name);
/// Registers a server session with the gobal emulation state, to be freed on shutdown. This is
/// necessary because we do not emulate processes for HLE sessions.
void RegisterServerSession(KServerSession* server_session);
/// Unregisters a server session previously registered with RegisterServerSession when it was
/// destroyed during the current emulation session.
void UnregisterServerSession(KServerSession* server_session);
/// Registers all kernel objects with the global emulation state, this is purely for tracking /// Registers all kernel objects with the global emulation state, this is purely for tracking
/// leaks after emulation has been shutdown. /// leaks after emulation has been shutdown.
void RegisterKernelObject(KAutoObject* object); void RegisterKernelObject(KAutoObject* object);