diff --git a/src/core/hle/kernel/shared_memory.cpp b/src/core/hle/kernel/shared_memory.cpp
index fa8fc6f92db351757c32cfe22a69363c737b30c7..536d134b0f3dd95a4f4a5613ba3f0e644be5163a 100644
--- a/src/core/hle/kernel/shared_memory.cpp
+++ b/src/core/hle/kernel/shared_memory.cpp
@@ -9,68 +9,39 @@
namespace Kernel {
-class SharedMemory : public Object {
-public:
- std::string GetTypeName() const override { return "SharedMemory"; }
+ResultVal<SharedPtr<SharedMemory>> SharedMemory::Create(std::string name) {
+ SharedPtr<SharedMemory> shared_memory(new SharedMemory);
- static const HandleType HANDLE_TYPE = HandleType::SharedMemory;
- HandleType GetHandleType() const override { return HANDLE_TYPE; }
+ // TOOD(yuriks): Don't create Handle (see Thread::Create())
+ CASCADE_RESULT(auto unused, Kernel::g_handle_table.Create(shared_memory));
- u32 base_address; ///< Address of shared memory block in RAM
- MemoryPermission permissions; ///< Permissions of shared memory block (SVC field)
- MemoryPermission other_permissions; ///< Other permissions of shared memory block (SVC field)
- std::string name; ///< Name of shared memory object (optional)
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Creates a shared memory object
- * @param handle Handle of newly created shared memory object
- * @param name Name of shared memory object
- * @return Pointer to newly created shared memory object
- */
-static SharedMemory* CreateSharedMemory(Handle& handle, const std::string& name) {
- SharedMemory* shared_memory = new SharedMemory;
- // TOOD(yuriks): Fix error reporting
- handle = Kernel::g_handle_table.Create(shared_memory).ValueOr(INVALID_HANDLE);
- shared_memory->name = name;
- return shared_memory;
+ shared_memory->name = std::move(name);
+ return MakeResult<SharedPtr<SharedMemory>>(std::move(shared_memory));
}
-Handle CreateSharedMemory(const std::string& name) {
- Handle handle;
- CreateSharedMemory(handle, name);
- return handle;
-}
-
-ResultCode MapSharedMemory(u32 handle, u32 address, MemoryPermission permissions,
- MemoryPermission other_permissions) {
+ResultCode SharedMemory::Map(VAddr address, MemoryPermission permissions,
+ MemoryPermission other_permissions) {
if (address < Memory::SHARED_MEMORY_VADDR || address >= Memory::SHARED_MEMORY_VADDR_END) {
- LOG_ERROR(Kernel_SVC, "cannot map handle=0x%08X, address=0x%08X outside of shared mem bounds!",
- handle, address);
+ LOG_ERROR(Kernel, "cannot map handle=0x%08X, address=0x%08X outside of shared mem bounds!",
+ GetHandle(), address);
+ // TODO: Verify error code with hardware
return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::Kernel,
ErrorSummary::InvalidArgument, ErrorLevel::Permanent);
}
- SharedMemory* shared_memory = Kernel::g_handle_table.Get<SharedMemory>(handle).get();
- if (shared_memory == nullptr) return InvalidHandle(ErrorModule::Kernel);
- shared_memory->base_address = address;
- shared_memory->permissions = permissions;
- shared_memory->other_permissions = other_permissions;
+ base_address = address;
+ permissions = permissions;
+ other_permissions = other_permissions;
return RESULT_SUCCESS;
}
-ResultVal<u8*> GetSharedMemoryPointer(Handle handle, u32 offset) {
- SharedMemory* shared_memory = Kernel::g_handle_table.Get<SharedMemory>(handle).get();
- if (shared_memory == nullptr) return InvalidHandle(ErrorModule::Kernel);
-
- if (0 != shared_memory->base_address)
- return MakeResult<u8*>(Memory::GetPointer(shared_memory->base_address + offset));
+ResultVal<u8*> SharedMemory::GetPointer(u32 offset) {
+ if (base_address != 0)
+ return MakeResult<u8*>(Memory::GetPointer(base_address + offset));
- LOG_ERROR(Kernel_SVC, "memory block handle=0x%08X not mapped!", handle);
+ LOG_ERROR(Kernel_SVC, "memory block handle=0x%08X not mapped!", GetHandle());
// TODO(yuriks): Verify error code.
return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::Kernel,
ErrorSummary::InvalidState, ErrorLevel::Permanent);
diff --git a/src/core/hle/kernel/shared_memory.h b/src/core/hle/kernel/shared_memory.h
index bb65c7ccd6fe4fcf7c1fd08ecbe6323fe6daea58..eb063d39d66803a89b9f3d50caa139e0a7931c25 100644
--- a/src/core/hle/kernel/shared_memory.h
+++ b/src/core/hle/kernel/shared_memory.h
@@ -23,29 +23,41 @@ enum class MemoryPermission : u32 {
DontCare = (1u << 28)
};
-/**
- * Creates a shared memory object
- * @param name Optional name of shared memory object
- * @return Handle of newly created shared memory object
- */
-Handle CreateSharedMemory(const std::string& name="Unknown");
-
-/**
- * Maps a shared memory block to an address in system memory
- * @param handle Shared memory block handle
- * @param address Address in system memory to map shared memory block to
- * @param permissions Memory block map permissions (specified by SVC field)
- * @param other_permissions Memory block map other permissions (specified by SVC field)
- */
-ResultCode MapSharedMemory(Handle handle, u32 address, MemoryPermission permissions,
- MemoryPermission other_permissions);
-
-/**
- * Gets a pointer to the shared memory block
- * @param handle Shared memory block handle
- * @param offset Offset from the start of the shared memory block to get pointer
- * @return Pointer to the shared memory block from the specified offset
- */
-ResultVal<u8*> GetSharedMemoryPointer(Handle handle, u32 offset);
+class SharedMemory : public Object {
+public:
+ /**
+ * Creates a shared memory object
+ * @param name Optional object name, used only for debugging purposes.
+ */
+ static ResultVal<SharedPtr<SharedMemory>> Create(std::string name = "Unknown");
+
+ std::string GetTypeName() const override { return "SharedMemory"; }
+
+ static const HandleType HANDLE_TYPE = HandleType::SharedMemory;
+ HandleType GetHandleType() const override { return HANDLE_TYPE; }
+
+ /**
+ * Maps a shared memory block to an address in system memory
+ * @param address Address in system memory to map shared memory block to
+ * @param permissions Memory block map permissions (specified by SVC field)
+ * @param other_permissions Memory block map other permissions (specified by SVC field)
+ */
+ ResultCode Map(VAddr address, MemoryPermission permissions, MemoryPermission other_permissions);
+
+ /**
+ * Gets a pointer to the shared memory block
+ * @param offset Offset from the start of the shared memory block to get pointer
+ * @return Pointer to the shared memory block from the specified offset
+ */
+ ResultVal<u8*> GetPointer(u32 offset = 0);
+
+ VAddr base_address; ///< Address of shared memory block in RAM
+ MemoryPermission permissions; ///< Permissions of shared memory block (SVC field)
+ MemoryPermission other_permissions; ///< Other permissions of shared memory block (SVC field)
+ std::string name; ///< Name of shared memory object (optional)
+
+private:
+ SharedMemory() = default;
+};
} // namespace
diff --git a/src/core/hle/service/apt_u.cpp b/src/core/hle/service/apt_u.cpp
index 001b0d1836894b34fafdbae10374dee8aae17fa9..1f6b148e8c95ab78c8e3ea1fe078205db37cb852 100644
--- a/src/core/hle/service/apt_u.cpp
+++ b/src/core/hle/service/apt_u.cpp
@@ -26,7 +26,7 @@ namespace APT_U {
static const VAddr SHARED_FONT_VADDR = 0x18000000;
/// Handle to shared memory region designated to for shared system font
-static Handle shared_font_mem = 0;
+static Kernel::SharedPtr<Kernel::SharedMemory> shared_font_mem;
static Handle lock_handle = 0;
static Handle notification_event_handle = 0; ///< APT notification event handle
@@ -354,7 +354,7 @@ void GetSharedFont(Service::Interface* self) {
cmd_buff[0] = 0x00440082;
cmd_buff[1] = RESULT_SUCCESS.raw; // No error
cmd_buff[2] = SHARED_FONT_VADDR;
- cmd_buff[4] = shared_font_mem;
+ cmd_buff[4] = Kernel::g_handle_table.Create(shared_font_mem).MoveFrom();
} else {
cmd_buff[1] = -1; // Generic error (not really possible to verify this on hardware)
LOG_ERROR(Kernel_SVC, "called, but %s has not been loaded!", SHARED_FONT);
@@ -514,10 +514,10 @@ Interface::Interface() {
file.ReadBytes(shared_font.data(), (size_t)file.GetSize());
// Create shared font memory object
- shared_font_mem = Kernel::CreateSharedMemory("APT_U:shared_font_mem");
+ shared_font_mem = Kernel::SharedMemory::Create("APT_U:shared_font_mem").MoveFrom();
} else {
LOG_WARNING(Service_APT, "Unable to load shared font: %s", filepath.c_str());
- shared_font_mem = 0;
+ shared_font_mem = nullptr;
}
lock_handle = 0;
diff --git a/src/core/hle/service/gsp_gpu.cpp b/src/core/hle/service/gsp_gpu.cpp
index 4ca2b9bd0f1ca9c3860096ac16761c13ba15ab20..1be2438c8632bebf7e3fec1b17c5bab84308b30a 100644
--- a/src/core/hle/service/gsp_gpu.cpp
+++ b/src/core/hle/service/gsp_gpu.cpp
@@ -23,12 +23,12 @@ GraphicsDebugger g_debugger;
namespace GSP_GPU {
Handle g_interrupt_event = 0; ///< Handle to event triggered when GSP interrupt has been signalled
-Handle g_shared_memory = 0; ///< Handle to GSP shared memorys
+Kernel::SharedPtr<Kernel::SharedMemory> g_shared_memory; ///< GSP shared memoryings
u32 g_thread_id = 1; ///< Thread index into interrupt relay queue, 1 is arbitrary
/// Gets a pointer to a thread command buffer in GSP shared memory
static inline u8* GetCommandBuffer(u32 thread_id) {
- ResultVal<u8*> ptr = Kernel::GetSharedMemoryPointer(g_shared_memory, 0x800 + (thread_id * sizeof(CommandBuffer)));
+ ResultVal<u8*> ptr = g_shared_memory->GetPointer(0x800 + (thread_id * sizeof(CommandBuffer)));
return ptr.ValueOr(nullptr);
}
@@ -37,13 +37,13 @@ static inline FrameBufferUpdate* GetFrameBufferInfo(u32 thread_id, u32 screen_in
// For each thread there are two FrameBufferUpdate fields
u32 offset = 0x200 + (2 * thread_id + screen_index) * sizeof(FrameBufferUpdate);
- ResultVal<u8*> ptr = Kernel::GetSharedMemoryPointer(g_shared_memory, offset);
+ ResultVal<u8*> ptr = g_shared_memory->GetPointer(offset);
return reinterpret_cast<FrameBufferUpdate*>(ptr.ValueOr(nullptr));
}
/// Gets a pointer to the interrupt relay queue for a given thread index
static inline InterruptRelayQueue* GetInterruptRelayQueue(u32 thread_id) {
- ResultVal<u8*> ptr = Kernel::GetSharedMemoryPointer(g_shared_memory, sizeof(InterruptRelayQueue) * thread_id);
+ ResultVal<u8*> ptr = g_shared_memory->GetPointer(sizeof(InterruptRelayQueue) * thread_id);
return reinterpret_cast<InterruptRelayQueue*>(ptr.ValueOr(nullptr));
}
@@ -182,13 +182,15 @@ static void RegisterInterruptRelayQueue(Service::Interface* self) {
u32* cmd_buff = Kernel::GetCommandBuffer();
u32 flags = cmd_buff[1];
g_interrupt_event = cmd_buff[3];
- g_shared_memory = Kernel::CreateSharedMemory("GSPSharedMem");
+ g_shared_memory = Kernel::SharedMemory::Create("GSPSharedMem").MoveFrom();
_assert_msg_(GSP, (g_interrupt_event != 0), "handle is not valid!");
+ Handle shmem_handle = Kernel::g_handle_table.Create(g_shared_memory).MoveFrom();
+
cmd_buff[1] = 0x2A07; // Value verified by 3dmoo team, purpose unknown, but needed for GSP init
cmd_buff[2] = g_thread_id++; // Thread ID
- cmd_buff[4] = g_shared_memory; // GSP shared memory
+ cmd_buff[4] = shmem_handle; // GSP shared memory
Kernel::SignalEvent(g_interrupt_event); // TODO(bunnei): Is this correct?
}
@@ -204,7 +206,7 @@ void SignalInterrupt(InterruptId interrupt_id) {
LOG_WARNING(Service_GSP, "cannot synchronize until GSP event has been created!");
return;
}
- if (0 == g_shared_memory) {
+ if (nullptr == g_shared_memory) {
LOG_WARNING(Service_GSP, "cannot synchronize until GSP shared memory has been created!");
return;
}
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 5abcb2596c83cd47a5e87d0407a4668879ca44d6..ee2ba7e01400ab7feeebc11ed3448fe9f227c5fd 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -12,7 +12,7 @@
namespace Service {
namespace HID {
-Handle g_shared_mem = 0;
+Kernel::SharedPtr<Kernel::SharedMemory> g_shared_mem = nullptr;
Handle g_event_pad_or_touch_1 = 0;
Handle g_event_pad_or_touch_2 = 0;
@@ -30,7 +30,7 @@ static s16 next_circle_y = 0;
* Gets a pointer to the PadData structure inside HID shared memory
*/
static inline PadData* GetPadData() {
- return reinterpret_cast<PadData*>(Kernel::GetSharedMemoryPointer(g_shared_mem, 0).ValueOr(nullptr));
+ return reinterpret_cast<PadData*>(g_shared_mem->GetPointer().ValueOr(nullptr));
}
/**
@@ -120,7 +120,7 @@ void PadUpdateComplete() {
}
void HIDInit() {
- g_shared_mem = Kernel::CreateSharedMemory("HID:SharedMem"); // Create shared memory object
+ g_shared_mem = Kernel::SharedMemory::Create("HID:SharedMem").MoveFrom();
// Create event handles
g_event_pad_or_touch_1 = Kernel::CreateEvent(RESETTYPE_ONESHOT, "HID:EventPadOrTouch1");
diff --git a/src/core/hle/service/hid/hid.h b/src/core/hle/service/hid/hid.h
index 73cdaa527a6b6c1ac815341247f0e4f563bff092..5e6236647166f68fafd1df8e57ebbfa3ceeb3dcc 100644
--- a/src/core/hle/service/hid/hid.h
+++ b/src/core/hle/service/hid/hid.h
@@ -9,11 +9,15 @@
#include "core/hle/kernel/kernel.h"
#include "common/bit_field.h"
+namespace Kernel {
+ class SharedMemory;
+}
+
namespace Service {
namespace HID {
// Handle to shared memory region designated to HID_User service
-extern Handle g_shared_mem;
+extern Kernel::SharedPtr<Kernel::SharedMemory> g_shared_mem;
// Event handles
extern Handle g_event_pad_or_touch_1;
diff --git a/src/core/hle/service/hid/hid_user.cpp b/src/core/hle/service/hid/hid_user.cpp
index 3a627570744709581ed30b48d12039d95ebd53a6..c167927ea79a5577bbcdd1af4e6e2c28b3bfd5f4 100644
--- a/src/core/hle/service/hid/hid_user.cpp
+++ b/src/core/hle/service/hid/hid_user.cpp
@@ -5,6 +5,7 @@
#include "common/log.h"
#include "core/hle/hle.h"
+#include "core/hle/kernel/shared_memory.h"
#include "core/hle/service/hid/hid.h"
#include "hid_user.h"
@@ -46,7 +47,8 @@ void GetIPCHandles(Service::Interface* self) {
u32* cmd_buff = Kernel::GetCommandBuffer();
cmd_buff[1] = 0; // No error
- cmd_buff[3] = Service::HID::g_shared_mem;
+ // TODO(yuriks): Return error from SendSyncRequest is this fails (part of IPC marshalling)
+ cmd_buff[3] = Kernel::g_handle_table.Create(Service::HID::g_shared_mem).MoveFrom();
cmd_buff[4] = Service::HID::g_event_pad_or_touch_1;
cmd_buff[5] = Service::HID::g_event_pad_or_touch_2;
cmd_buff[6] = Service::HID::g_event_accelerometer;
diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp
index 3d743f1253677efea4d8525d6de5c2d770d534be..165da04020698c9a610c49277d33098613e06d76 100644
--- a/src/core/hle/svc.cpp
+++ b/src/core/hle/svc.cpp
@@ -63,21 +63,28 @@ static Result ControlMemory(u32* out_addr, u32 operation, u32 addr0, u32 addr1,
/// Maps a memory block to specified address
static Result MapMemoryBlock(Handle handle, u32 addr, u32 permissions, u32 other_permissions) {
+ using Kernel::SharedMemory;
+ using Kernel::MemoryPermission;
+
LOG_TRACE(Kernel_SVC, "called memblock=0x%08X, addr=0x%08X, mypermissions=0x%08X, otherpermission=%d",
handle, addr, permissions, other_permissions);
- Kernel::MemoryPermission permissions_type = static_cast<Kernel::MemoryPermission>(permissions);
+ SharedPtr<SharedMemory> shared_memory = Kernel::g_handle_table.Get<SharedMemory>(handle);
+ if (shared_memory == nullptr)
+ return InvalidHandle(ErrorModule::Kernel).raw;
+
+ MemoryPermission permissions_type = static_cast<MemoryPermission>(permissions);
switch (permissions_type) {
- case Kernel::MemoryPermission::Read:
- case Kernel::MemoryPermission::Write:
- case Kernel::MemoryPermission::ReadWrite:
- case Kernel::MemoryPermission::Execute:
- case Kernel::MemoryPermission::ReadExecute:
- case Kernel::MemoryPermission::WriteExecute:
- case Kernel::MemoryPermission::ReadWriteExecute:
- case Kernel::MemoryPermission::DontCare:
- Kernel::MapSharedMemory(handle, addr, permissions_type,
- static_cast<Kernel::MemoryPermission>(other_permissions));
+ case MemoryPermission::Read:
+ case MemoryPermission::Write:
+ case MemoryPermission::ReadWrite:
+ case MemoryPermission::Execute:
+ case MemoryPermission::ReadExecute:
+ case MemoryPermission::WriteExecute:
+ case MemoryPermission::ReadWriteExecute:
+ case MemoryPermission::DontCare:
+ shared_memory->Map(addr, permissions_type,
+ static_cast<MemoryPermission>(other_permissions));
break;
default:
LOG_ERROR(Kernel_SVC, "unknown permissions=0x%08X", permissions);
@@ -463,12 +470,19 @@ static s64 GetSystemTick() {
/// Creates a memory block at the specified address with the specified permissions and size
static Result CreateMemoryBlock(Handle* memblock, u32 addr, u32 size, u32 my_permission,
- u32 other_permission) {
-
+ u32 other_permission) {
+ using Kernel::SharedMemory;
// TODO(Subv): Implement this function
- Handle shared_memory = Kernel::CreateSharedMemory();
- *memblock = shared_memory;
+ ResultVal<SharedPtr<SharedMemory>> shared_memory_res = SharedMemory::Create();
+ if (shared_memory_res.Failed())
+ return shared_memory_res.Code().raw;
+
+ ResultVal<Handle> handle_res = Kernel::g_handle_table.Create(*shared_memory_res);
+ if (handle_res.Failed())
+ return handle_res.Code().raw;
+
+ *memblock = *handle_res;
LOG_WARNING(Kernel_SVC, "(STUBBED) called addr=0x%08X", addr);
return 0;
}