summaryrefslogtreecommitdiffstats
path: root/src/core/hle/kernel
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/hle/kernel')
-rw-r--r--src/core/hle/kernel/client_port.cpp13
-rw-r--r--src/core/hle/kernel/client_session.cpp27
-rw-r--r--src/core/hle/kernel/client_session.h23
-rw-r--r--src/core/hle/kernel/memory.cpp112
-rw-r--r--src/core/hle/kernel/memory.h10
-rw-r--r--src/core/hle/kernel/process.cpp23
-rw-r--r--src/core/hle/kernel/process.h2
-rw-r--r--src/core/hle/kernel/server_session.cpp31
-rw-r--r--src/core/hle/kernel/server_session.h12
-rw-r--r--src/core/hle/kernel/session.h27
10 files changed, 184 insertions, 96 deletions
diff --git a/src/core/hle/kernel/client_port.cpp b/src/core/hle/kernel/client_port.cpp
index 22645f4ec..ddcf4c916 100644
--- a/src/core/hle/kernel/client_port.cpp
+++ b/src/core/hle/kernel/client_port.cpp
@@ -19,24 +19,21 @@ ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
// AcceptSession before returning from this call.
if (active_sessions >= max_sessions) {
- // TODO(Subv): Return an error code in this situation after session disconnection is
- // implemented.
- /*return ResultCode(ErrorDescription::MaxConnectionsReached,
- ErrorModule::OS, ErrorSummary::WouldBlock,
- ErrorLevel::Temporary);*/
+ return ResultCode(ErrorDescription::MaxConnectionsReached, ErrorModule::OS,
+ ErrorSummary::WouldBlock, ErrorLevel::Temporary);
}
active_sessions++;
// Create a new session pair, let the created sessions inherit the parent port's HLE handler.
auto sessions =
- ServerSession::CreateSessionPair(server_port->GetName(), server_port->hle_handler);
+ ServerSession::CreateSessionPair(server_port->GetName(), server_port->hle_handler, this);
auto client_session = std::get<SharedPtr<ClientSession>>(sessions);
auto server_session = std::get<SharedPtr<ServerSession>>(sessions);
if (server_port->hle_handler)
server_port->hle_handler->ClientConnected(server_session);
-
- server_port->pending_sessions.push_back(std::move(server_session));
+ else
+ server_port->pending_sessions.push_back(std::move(server_session));
// Wake the threads waiting on the ServerPort
server_port->WakeupAllWaitingThreads();
diff --git a/src/core/hle/kernel/client_session.cpp b/src/core/hle/kernel/client_session.cpp
index 0331386ec..e297b7464 100644
--- a/src/core/hle/kernel/client_session.cpp
+++ b/src/core/hle/kernel/client_session.cpp
@@ -14,27 +14,24 @@ ClientSession::~ClientSession() {
// This destructor will be called automatically when the last ClientSession handle is closed by
// the emulated application.
- if (server_session->hle_handler)
- server_session->hle_handler->ClientDisconnected(server_session);
+ if (parent->server) {
+ if (parent->server->hle_handler)
+ parent->server->hle_handler->ClientDisconnected(parent->server);
- // TODO(Subv): If the session is still open, set the connection status to 2 (Closed by client),
- // wake up all the ServerSession's waiting threads and set the WaitSynchronization result to
- // 0xC920181A.
-}
-
-ResultVal<SharedPtr<ClientSession>> ClientSession::Create(ServerSession* server_session,
- std::string name) {
- SharedPtr<ClientSession> client_session(new ClientSession);
+ // TODO(Subv): Force a wake up of all the ServerSession's waiting threads and set
+ // their WaitSynchronization result to 0xC920181A.
+ }
- client_session->name = std::move(name);
- client_session->server_session = server_session;
- client_session->session_status = SessionStatus::Open;
- return MakeResult<SharedPtr<ClientSession>>(std::move(client_session));
+ parent->client = nullptr;
}
ResultCode ClientSession::SendSyncRequest() {
// Signal the server session that new data is available
- return server_session->HandleSyncRequest();
+ if (parent->server)
+ return parent->server->HandleSyncRequest();
+
+ return ResultCode(ErrorDescription::SessionClosedByRemote, ErrorModule::OS,
+ ErrorSummary::Canceled, ErrorLevel::Status);
}
} // namespace
diff --git a/src/core/hle/kernel/client_session.h b/src/core/hle/kernel/client_session.h
index ed468dec6..9f3adb72b 100644
--- a/src/core/hle/kernel/client_session.h
+++ b/src/core/hle/kernel/client_session.h
@@ -14,12 +14,7 @@
namespace Kernel {
class ServerSession;
-
-enum class SessionStatus {
- Open = 1,
- ClosedByClient = 2,
- ClosedBYServer = 3,
-};
+class Session;
class ClientSession final : public Object {
public:
@@ -44,22 +39,14 @@ public:
*/
ResultCode SendSyncRequest();
- std::string name; ///< Name of client port (optional)
- ServerSession* server_session; ///< The server session associated with this client session.
- SessionStatus session_status; ///< The session's current status.
+ std::string name; ///< Name of client port (optional)
+
+ /// The parent session, which links to the server endpoint.
+ std::shared_ptr<Session> parent;
private:
ClientSession();
~ClientSession() override;
-
- /**
- * Creates a client session.
- * @param server_session The server session associated with this client session
- * @param name Optional name of client session
- * @return The created client session
- */
- static ResultVal<SharedPtr<ClientSession>> Create(ServerSession* server_session,
- std::string name = "Unknown");
};
} // namespace
diff --git a/src/core/hle/kernel/memory.cpp b/src/core/hle/kernel/memory.cpp
index 33c165197..8250a90b5 100644
--- a/src/core/hle/kernel/memory.cpp
+++ b/src/core/hle/kernel/memory.cpp
@@ -2,11 +2,13 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
+#include <cinttypes>
#include <map>
#include <memory>
#include <utility>
#include <vector>
#include "audio_core/audio_core.h"
+#include "common/assert.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "core/hle/config_mem.h"
@@ -92,52 +94,96 @@ MemoryRegionInfo* GetMemoryRegion(MemoryRegion region) {
UNREACHABLE();
}
}
-}
-
-namespace Memory {
-namespace {
+std::array<u8, Memory::VRAM_SIZE> vram;
+std::array<u8, Memory::N3DS_EXTRA_RAM_SIZE> n3ds_extra_ram;
+
+void HandleSpecialMapping(VMManager& address_space, const AddressMapping& mapping) {
+ using namespace Memory;
+
+ struct MemoryArea {
+ VAddr vaddr_base;
+ PAddr paddr_base;
+ u32 size;
+ };
+
+ // The order of entries in this array is important. The VRAM and IO VAddr ranges overlap, and
+ // VRAM must be tried first.
+ static constexpr MemoryArea memory_areas[] = {
+ {VRAM_VADDR, VRAM_PADDR, VRAM_SIZE},
+ {IO_AREA_VADDR, IO_AREA_PADDR, IO_AREA_SIZE},
+ {DSP_RAM_VADDR, DSP_RAM_PADDR, DSP_RAM_SIZE},
+ {N3DS_EXTRA_RAM_VADDR, N3DS_EXTRA_RAM_PADDR, N3DS_EXTRA_RAM_SIZE - 0x20000},
+ };
+
+ VAddr mapping_limit = mapping.address + mapping.size;
+ if (mapping_limit < mapping.address) {
+ LOG_CRITICAL(Loader, "Mapping size overflowed: address=0x%08" PRIX32 " size=0x%" PRIX32,
+ mapping.address, mapping.size);
+ return;
+ }
-struct MemoryArea {
- u32 base;
- u32 size;
- const char* name;
-};
+ auto area =
+ std::find_if(std::begin(memory_areas), std::end(memory_areas), [&](const auto& area) {
+ return mapping.address >= area.vaddr_base &&
+ mapping_limit <= area.vaddr_base + area.size;
+ });
+ if (area == std::end(memory_areas)) {
+ LOG_ERROR(Loader, "Unhandled special mapping: address=0x%08" PRIX32 " size=0x%" PRIX32
+ " read_only=%d unk_flag=%d",
+ mapping.address, mapping.size, mapping.read_only, mapping.unk_flag);
+ return;
+ }
-// We don't declare the IO regions in here since its handled by other means.
-static MemoryArea memory_areas[] = {
- {VRAM_VADDR, VRAM_SIZE, "VRAM"}, // Video memory (VRAM)
-};
-}
+ u32 offset_into_region = mapping.address - area->vaddr_base;
+ if (area->paddr_base == IO_AREA_PADDR) {
+ LOG_ERROR(Loader, "MMIO mappings are not supported yet. phys_addr=0x%08" PRIX32,
+ area->paddr_base + offset_into_region);
+ return;
+ }
-void Init() {
- InitMemoryMap();
- LOG_DEBUG(HW_Memory, "initialized OK");
-}
+ // TODO(yuriks): Use GetPhysicalPointer when that becomes independent of the virtual
+ // mappings.
+ u8* target_pointer = nullptr;
+ switch (area->paddr_base) {
+ case VRAM_PADDR:
+ target_pointer = vram.data();
+ break;
+ case DSP_RAM_PADDR:
+ target_pointer = AudioCore::GetDspMemory().data();
+ break;
+ case N3DS_EXTRA_RAM_PADDR:
+ target_pointer = n3ds_extra_ram.data();
+ break;
+ default:
+ UNREACHABLE();
+ }
-void InitLegacyAddressSpace(Kernel::VMManager& address_space) {
- using namespace Kernel;
+ // TODO(yuriks): This flag seems to have some other effect, but it's unknown what
+ MemoryState memory_state = mapping.unk_flag ? MemoryState::Static : MemoryState::IO;
- for (MemoryArea& area : memory_areas) {
- auto block = std::make_shared<std::vector<u8>>(area.size);
- address_space
- .MapMemoryBlock(area.base, std::move(block), 0, area.size, MemoryState::Private)
- .Unwrap();
- }
+ auto vma = address_space
+ .MapBackingMemory(mapping.address, target_pointer + offset_into_region,
+ mapping.size, memory_state)
+ .MoveFrom();
+ address_space.Reprotect(vma,
+ mapping.read_only ? VMAPermission::Read : VMAPermission::ReadWrite);
+}
+void MapSharedPages(VMManager& address_space) {
auto cfg_mem_vma = address_space
- .MapBackingMemory(CONFIG_MEMORY_VADDR, (u8*)&ConfigMem::config_mem,
- CONFIG_MEMORY_SIZE, MemoryState::Shared)
+ .MapBackingMemory(Memory::CONFIG_MEMORY_VADDR,
+ reinterpret_cast<u8*>(&ConfigMem::config_mem),
+ Memory::CONFIG_MEMORY_SIZE, MemoryState::Shared)
.MoveFrom();
address_space.Reprotect(cfg_mem_vma, VMAPermission::Read);
auto shared_page_vma = address_space
- .MapBackingMemory(SHARED_PAGE_VADDR, (u8*)&SharedPage::shared_page,
- SHARED_PAGE_SIZE, MemoryState::Shared)
+ .MapBackingMemory(Memory::SHARED_PAGE_VADDR,
+ reinterpret_cast<u8*>(&SharedPage::shared_page),
+ Memory::SHARED_PAGE_SIZE, MemoryState::Shared)
.MoveFrom();
address_space.Reprotect(shared_page_vma, VMAPermission::Read);
-
- AudioCore::AddAddressSpace(address_space);
}
-} // namespace
+} // namespace Kernel
diff --git a/src/core/hle/kernel/memory.h b/src/core/hle/kernel/memory.h
index 4e1856a41..08c1a9989 100644
--- a/src/core/hle/kernel/memory.h
+++ b/src/core/hle/kernel/memory.h
@@ -23,11 +23,7 @@ struct MemoryRegionInfo {
void MemoryInit(u32 mem_type);
void MemoryShutdown();
MemoryRegionInfo* GetMemoryRegion(MemoryRegion region);
-}
-namespace Memory {
-
-void Init();
-void InitLegacyAddressSpace(Kernel::VMManager& address_space);
-
-} // namespace
+void HandleSpecialMapping(VMManager& address_space, const AddressMapping& mapping);
+void MapSharedPages(VMManager& address_space);
+} // namespace Kernel
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index ba80fe7f8..32cb25fb7 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -35,7 +35,6 @@ SharedPtr<Process> Process::Create(SharedPtr<CodeSet> code_set) {
process->codeset = std::move(code_set);
process->flags.raw = 0;
process->flags.memory_region.Assign(MemoryRegion::APPLICATION);
- Memory::InitLegacyAddressSpace(process->vm_manager);
return process;
}
@@ -78,8 +77,15 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
AddressMapping mapping;
mapping.address = descriptor << 12;
- mapping.size = (end_desc << 12) - mapping.address;
- mapping.writable = (descriptor & (1 << 20)) != 0;
+ VAddr end_address = end_desc << 12;
+
+ if (mapping.address < end_address) {
+ mapping.size = end_address - mapping.address;
+ } else {
+ mapping.size = 0;
+ }
+
+ mapping.read_only = (descriptor & (1 << 20)) != 0;
mapping.unk_flag = (end_desc & (1 << 20)) != 0;
address_mappings.push_back(mapping);
@@ -88,8 +94,10 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
AddressMapping mapping;
mapping.address = descriptor << 12;
mapping.size = Memory::PAGE_SIZE;
- mapping.writable = true; // TODO: Not sure if correct
+ mapping.read_only = false;
mapping.unk_flag = false;
+
+ address_mappings.push_back(mapping);
} else if ((type & 0xFE0) == 0xFC0) { // 0x01FF
// Kernel version
kernel_version = descriptor & 0xFFFF;
@@ -131,6 +139,12 @@ void Process::Run(s32 main_thread_priority, u32 stack_size) {
misc_memory_used += stack_size;
memory_region->used += stack_size;
+ // Map special address mappings
+ MapSharedPages(vm_manager);
+ for (const auto& mapping : address_mappings) {
+ HandleSpecialMapping(vm_manager, mapping);
+ }
+
vm_manager.LogLayout(Log::Level::Debug);
Kernel::SetupMainThread(codeset->entrypoint, main_thread_priority);
}
@@ -138,6 +152,7 @@ void Process::Run(s32 main_thread_priority, u32 stack_size) {
VAddr Process::GetLinearHeapAreaAddress() const {
return kernel_version < 0x22C ? Memory::LINEAR_HEAP_VADDR : Memory::NEW_LINEAR_HEAP_VADDR;
}
+
VAddr Process::GetLinearHeapBase() const {
return GetLinearHeapAreaAddress() + memory_region->base;
}
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index b566950b0..b52211d2a 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -20,7 +20,7 @@ struct AddressMapping {
// Address and size must be page-aligned
VAddr address;
u32 size;
- bool writable;
+ bool read_only;
bool unk_flag;
};
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index 9447ff236..500b909ab 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -14,8 +14,15 @@ ServerSession::ServerSession() = default;
ServerSession::~ServerSession() {
// This destructor will be called automatically when the last ServerSession handle is closed by
// the emulated application.
- // TODO(Subv): Reduce the ClientPort's connection count,
- // if the session is still open, set the connection status to 3 (Closed by server),
+
+ // Decrease the port's connection count.
+ if (parent->port)
+ parent->port->active_sessions--;
+
+ // TODO(Subv): Wake up all the ClientSession's waiting threads and set
+ // the SendSyncRequest result to 0xC920181A.
+
+ parent->server = nullptr;
}
ResultVal<SharedPtr<ServerSession>> ServerSession::Create(
@@ -25,6 +32,7 @@ ResultVal<SharedPtr<ServerSession>> ServerSession::Create(
server_session->name = std::move(name);
server_session->signaled = false;
server_session->hle_handler = std::move(hle_handler);
+ server_session->parent = nullptr;
return MakeResult<SharedPtr<ServerSession>>(std::move(server_session));
}
@@ -61,13 +69,22 @@ ResultCode ServerSession::HandleSyncRequest() {
}
ServerSession::SessionPair ServerSession::CreateSessionPair(
- const std::string& name, std::shared_ptr<Service::SessionRequestHandler> hle_handler) {
+ const std::string& name, std::shared_ptr<Service::SessionRequestHandler> hle_handler,
+ SharedPtr<ClientPort> port) {
+
auto server_session =
ServerSession::Create(name + "_Server", std::move(hle_handler)).MoveFrom();
- // We keep a non-owning pointer to the ServerSession in the ClientSession because we don't want
- // to prevent the ServerSession's destructor from being called when the emulated
- // application closes the last ServerSession handle.
- auto client_session = ClientSession::Create(server_session.get(), name + "_Client").MoveFrom();
+
+ SharedPtr<ClientSession> client_session(new ClientSession);
+ client_session->name = name + "_Client";
+
+ std::shared_ptr<Session> parent(new Session);
+ parent->client = client_session.get();
+ parent->server = server_session.get();
+ parent->port = port;
+
+ client_session->parent = parent;
+ server_session->parent = parent;
return std::make_tuple(std::move(server_session), std::move(client_session));
}
diff --git a/src/core/hle/kernel/server_session.h b/src/core/hle/kernel/server_session.h
index 761fc4781..c907d487c 100644
--- a/src/core/hle/kernel/server_session.h
+++ b/src/core/hle/kernel/server_session.h
@@ -9,6 +9,7 @@
#include "common/assert.h"
#include "common/common_types.h"
#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/session.h"
#include "core/hle/kernel/thread.h"
#include "core/hle/result.h"
#include "core/hle/service/service.h"
@@ -17,6 +18,8 @@
namespace Kernel {
class ClientSession;
+class ClientPort;
+class ServerSession;
/**
* Kernel object representing the server endpoint of an IPC session. Sessions are the basic CTR-OS
@@ -47,11 +50,13 @@ public:
* Creates a pair of ServerSession and an associated ClientSession.
* @param name Optional name of the ports.
* @param hle_handler Optional HLE handler for this server session.
+ * @param client_port Optional The ClientPort that spawned this session.
* @return The created session tuple
*/
static SessionPair CreateSessionPair(
const std::string& name = "Unknown",
- std::shared_ptr<Service::SessionRequestHandler> hle_handler = nullptr);
+ std::shared_ptr<Service::SessionRequestHandler> hle_handler = nullptr,
+ SharedPtr<ClientPort> client_port = nullptr);
/**
* Handle a sync request from the emulated application.
@@ -63,8 +68,9 @@ public:
void Acquire(Thread* thread) override;
- std::string name; ///< The name of this session (optional)
- bool signaled; ///< Whether there's new data available to this ServerSession
+ std::string name; ///< The name of this session (optional)
+ bool signaled; ///< Whether there's new data available to this ServerSession
+ std::shared_ptr<Session> parent; ///< The parent session, which links to the client endpoint.
std::shared_ptr<Service::SessionRequestHandler>
hle_handler; ///< This session's HLE request handler (optional)
diff --git a/src/core/hle/kernel/session.h b/src/core/hle/kernel/session.h
new file mode 100644
index 000000000..a45e78022
--- /dev/null
+++ b/src/core/hle/kernel/session.h
@@ -0,0 +1,27 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/kernel/kernel.h"
+
+namespace Kernel {
+
+class ClientSession;
+class ClientPort;
+class ServerSession;
+
+/**
+ * Parent structure to link the client and server endpoints of a session with their associated
+ * client port. The client port need not exist, as is the case for portless sessions like the
+ * FS File and Directory sessions. When one of the endpoints of a session is destroyed, its
+ * corresponding field in this structure will be set to nullptr.
+ */
+class Session final {
+public:
+ ClientSession* client = nullptr; ///< The client endpoint of the session.
+ ServerSession* server = nullptr; ///< The server endpoint of the session.
+ SharedPtr<ClientPort> port; ///< The port that this session is associated with (optional).
+};
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-20 06:35:01 +0200