kernel: shared_memory: Refactor for new VMM.
This commit is contained in:
parent
a040a15246
commit
d0162fc3d7
|
@ -2,149 +2,56 @@
|
||||||
// Licensed under GPLv2 or any later version
|
// Licensed under GPLv2 or any later version
|
||||||
// Refer to the license.txt file included.
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
#include <utility>
|
|
||||||
|
|
||||||
#include "common/assert.h"
|
#include "common/assert.h"
|
||||||
#include "common/logging/log.h"
|
#include "core/core.h"
|
||||||
#include "core/hle/kernel/errors.h"
|
|
||||||
#include "core/hle/kernel/kernel.h"
|
#include "core/hle/kernel/kernel.h"
|
||||||
|
#include "core/hle/kernel/memory/page_table.h"
|
||||||
#include "core/hle/kernel/shared_memory.h"
|
#include "core/hle/kernel/shared_memory.h"
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
|
||||||
SharedMemory::SharedMemory(KernelCore& kernel) : Object{kernel} {}
|
SharedMemory::SharedMemory(KernelCore& kernel, Core::DeviceMemory& device_memory)
|
||||||
|
: Object{kernel}, device_memory{device_memory} {}
|
||||||
|
|
||||||
SharedMemory::~SharedMemory() = default;
|
SharedMemory::~SharedMemory() = default;
|
||||||
|
|
||||||
std::shared_ptr<SharedMemory> SharedMemory::Create(KernelCore& kernel, Process* owner_process,
|
std::shared_ptr<SharedMemory> SharedMemory::Create(
|
||||||
u64 size, MemoryPermission permissions,
|
KernelCore& kernel, Core::DeviceMemory& device_memory, Process* owner_process,
|
||||||
MemoryPermission other_permissions,
|
Memory::PageLinkedList&& page_list, Memory::MemoryPermission owner_permission,
|
||||||
VAddr address, MemoryRegion region,
|
Memory::MemoryPermission user_permission, PAddr physical_address, std::size_t size,
|
||||||
std::string name) {
|
std::string name) {
|
||||||
std::shared_ptr<SharedMemory> shared_memory = std::make_shared<SharedMemory>(kernel);
|
|
||||||
|
std::shared_ptr<SharedMemory> shared_memory{
|
||||||
|
std::make_shared<SharedMemory>(kernel, device_memory)};
|
||||||
|
|
||||||
shared_memory->owner_process = owner_process;
|
shared_memory->owner_process = owner_process;
|
||||||
shared_memory->name = std::move(name);
|
shared_memory->page_list = std::move(page_list);
|
||||||
|
shared_memory->owner_permission = owner_permission;
|
||||||
|
shared_memory->user_permission = user_permission;
|
||||||
|
shared_memory->physical_address = physical_address;
|
||||||
shared_memory->size = size;
|
shared_memory->size = size;
|
||||||
shared_memory->permissions = permissions;
|
shared_memory->name = name;
|
||||||
shared_memory->other_permissions = other_permissions;
|
|
||||||
|
|
||||||
if (address == 0) {
|
|
||||||
shared_memory->backing_block = std::make_shared<Kernel::PhysicalMemory>(size);
|
|
||||||
shared_memory->backing_block_offset = 0;
|
|
||||||
|
|
||||||
// Refresh the address mappings for the current process.
|
|
||||||
if (kernel.CurrentProcess() != nullptr) {
|
|
||||||
kernel.CurrentProcess()->VMManager().RefreshMemoryBlockMappings(
|
|
||||||
shared_memory->backing_block.get());
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
const auto& vm_manager = shared_memory->owner_process->VMManager();
|
|
||||||
|
|
||||||
// The memory is already available and mapped in the owner process.
|
|
||||||
const auto vma = vm_manager.FindVMA(address);
|
|
||||||
ASSERT_MSG(vm_manager.IsValidHandle(vma), "Invalid memory address");
|
|
||||||
ASSERT_MSG(vma->second.backing_block, "Backing block doesn't exist for address");
|
|
||||||
|
|
||||||
// The returned VMA might be a bigger one encompassing the desired address.
|
|
||||||
const auto vma_offset = address - vma->first;
|
|
||||||
ASSERT_MSG(vma_offset + size <= vma->second.size,
|
|
||||||
"Shared memory exceeds bounds of mapped block");
|
|
||||||
|
|
||||||
shared_memory->backing_block = vma->second.backing_block;
|
|
||||||
shared_memory->backing_block_offset = vma->second.offset + vma_offset;
|
|
||||||
}
|
|
||||||
|
|
||||||
shared_memory->base_address = address;
|
|
||||||
|
|
||||||
return shared_memory;
|
return shared_memory;
|
||||||
}
|
}
|
||||||
|
|
||||||
std::shared_ptr<SharedMemory> SharedMemory::CreateForApplet(
|
ResultCode SharedMemory::Map(Process& target_process, VAddr address, std::size_t size,
|
||||||
KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
|
Memory::MemoryPermission permission) {
|
||||||
u64 size, MemoryPermission permissions, MemoryPermission other_permissions, std::string name) {
|
const u64 page_count{(size + Memory::PageSize - 1) / Memory::PageSize};
|
||||||
std::shared_ptr<SharedMemory> shared_memory = std::make_shared<SharedMemory>(kernel);
|
|
||||||
|
|
||||||
shared_memory->owner_process = nullptr;
|
if (page_list.GetNumPages() != page_count) {
|
||||||
shared_memory->name = std::move(name);
|
UNIMPLEMENTED();
|
||||||
shared_memory->size = size;
|
|
||||||
shared_memory->permissions = permissions;
|
|
||||||
shared_memory->other_permissions = other_permissions;
|
|
||||||
shared_memory->backing_block = std::move(heap_block);
|
|
||||||
shared_memory->backing_block_offset = offset;
|
|
||||||
shared_memory->base_address =
|
|
||||||
kernel.CurrentProcess()->VMManager().GetHeapRegionBaseAddress() + offset;
|
|
||||||
|
|
||||||
return shared_memory;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
ResultCode SharedMemory::Map(Process& target_process, VAddr address, MemoryPermission permissions,
|
Memory::MemoryPermission expected =
|
||||||
MemoryPermission other_permissions) {
|
&target_process == owner_process ? owner_permission : user_permission;
|
||||||
const MemoryPermission own_other_permissions =
|
|
||||||
&target_process == owner_process ? this->permissions : this->other_permissions;
|
|
||||||
|
|
||||||
// Automatically allocated memory blocks can only be mapped with other_permissions = DontCare
|
if (permission != expected) {
|
||||||
if (base_address == 0 && other_permissions != MemoryPermission::DontCare) {
|
UNIMPLEMENTED();
|
||||||
return ERR_INVALID_MEMORY_PERMISSIONS;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Error out if the requested permissions don't match what the creator process allows.
|
return target_process.PageTable().MapPages(address, page_list, Memory::MemoryState::Shared,
|
||||||
if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
|
permission);
|
||||||
LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
|
|
||||||
GetObjectId(), address, name);
|
|
||||||
return ERR_INVALID_MEMORY_PERMISSIONS;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Error out if the provided permissions are not compatible with what the creator process needs.
|
|
||||||
if (other_permissions != MemoryPermission::DontCare &&
|
|
||||||
static_cast<u32>(this->permissions) & ~static_cast<u32>(other_permissions)) {
|
|
||||||
LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
|
|
||||||
GetObjectId(), address, name);
|
|
||||||
return ERR_INVALID_MEMORY_PERMISSIONS;
|
|
||||||
}
|
|
||||||
|
|
||||||
VAddr target_address = address;
|
|
||||||
|
|
||||||
// Map the memory block into the target process
|
|
||||||
auto result = target_process.VMManager().MapMemoryBlock(
|
|
||||||
target_address, backing_block, backing_block_offset, size, MemoryState::Shared);
|
|
||||||
if (result.Failed()) {
|
|
||||||
LOG_ERROR(
|
|
||||||
Kernel,
|
|
||||||
"cannot map id={}, target_address=0x{:X} name={}, error mapping to virtual memory",
|
|
||||||
GetObjectId(), target_address, name);
|
|
||||||
return result.Code();
|
|
||||||
}
|
|
||||||
|
|
||||||
return target_process.VMManager().ReprotectRange(target_address, size,
|
|
||||||
ConvertPermissions(permissions));
|
|
||||||
}
|
|
||||||
|
|
||||||
ResultCode SharedMemory::Unmap(Process& target_process, VAddr address, u64 unmap_size) {
|
|
||||||
if (unmap_size != size) {
|
|
||||||
LOG_ERROR(Kernel,
|
|
||||||
"Invalid size passed to Unmap. Size must be equal to the size of the "
|
|
||||||
"memory managed. Shared memory size=0x{:016X}, Unmap size=0x{:016X}",
|
|
||||||
size, unmap_size);
|
|
||||||
return ERR_INVALID_SIZE;
|
|
||||||
}
|
|
||||||
|
|
||||||
// TODO(Subv): Verify what happens if the application tries to unmap an address that is not
|
|
||||||
// mapped to a SharedMemory.
|
|
||||||
return target_process.VMManager().UnmapRange(address, size);
|
|
||||||
}
|
|
||||||
|
|
||||||
VMAPermission SharedMemory::ConvertPermissions(MemoryPermission permission) {
|
|
||||||
u32 masked_permissions =
|
|
||||||
static_cast<u32>(permission) & static_cast<u32>(MemoryPermission::ReadWriteExecute);
|
|
||||||
return static_cast<VMAPermission>(masked_permissions);
|
|
||||||
}
|
|
||||||
|
|
||||||
u8* SharedMemory::GetPointer(std::size_t offset) {
|
|
||||||
return backing_block->data() + backing_block_offset + offset;
|
|
||||||
}
|
|
||||||
|
|
||||||
const u8* SharedMemory::GetPointer(std::size_t offset) const {
|
|
||||||
return backing_block->data() + backing_block_offset + offset;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace Kernel
|
} // namespace Kernel
|
||||||
|
|
|
@ -8,8 +8,10 @@
|
||||||
#include <string>
|
#include <string>
|
||||||
|
|
||||||
#include "common/common_types.h"
|
#include "common/common_types.h"
|
||||||
|
#include "core/device_memory.h"
|
||||||
|
#include "core/hle/kernel/memory/memory_block.h"
|
||||||
|
#include "core/hle/kernel/memory/page_linked_list.h"
|
||||||
#include "core/hle/kernel/object.h"
|
#include "core/hle/kernel/object.h"
|
||||||
#include "core/hle/kernel/physical_memory.h"
|
|
||||||
#include "core/hle/kernel/process.h"
|
#include "core/hle/kernel/process.h"
|
||||||
#include "core/hle/result.h"
|
#include "core/hle/result.h"
|
||||||
|
|
||||||
|
@ -17,63 +19,21 @@ namespace Kernel {
|
||||||
|
|
||||||
class KernelCore;
|
class KernelCore;
|
||||||
|
|
||||||
/// Permissions for mapped shared memory blocks
|
|
||||||
enum class MemoryPermission : u32 {
|
|
||||||
None = 0,
|
|
||||||
Read = (1u << 0),
|
|
||||||
Write = (1u << 1),
|
|
||||||
ReadWrite = (Read | Write),
|
|
||||||
Execute = (1u << 2),
|
|
||||||
ReadExecute = (Read | Execute),
|
|
||||||
WriteExecute = (Write | Execute),
|
|
||||||
ReadWriteExecute = (Read | Write | Execute),
|
|
||||||
DontCare = (1u << 28)
|
|
||||||
};
|
|
||||||
|
|
||||||
class SharedMemory final : public Object {
|
class SharedMemory final : public Object {
|
||||||
public:
|
public:
|
||||||
explicit SharedMemory(KernelCore& kernel);
|
explicit SharedMemory(KernelCore& kernel, Core::DeviceMemory& device_memory);
|
||||||
~SharedMemory() override;
|
~SharedMemory() override;
|
||||||
|
|
||||||
/**
|
static std::shared_ptr<SharedMemory> Create(
|
||||||
* Creates a shared memory object.
|
KernelCore& kernel, Core::DeviceMemory& device_memory, Process* owner_process,
|
||||||
* @param kernel The kernel instance to create a shared memory instance under.
|
Memory::PageLinkedList&& page_list, Memory::MemoryPermission owner_permission,
|
||||||
* @param owner_process Process that created this shared memory object.
|
Memory::MemoryPermission user_permission, PAddr physical_address, std::size_t size,
|
||||||
* @param size Size of the memory block. Must be page-aligned.
|
|
||||||
* @param permissions Permission restrictions applied to the process which created the block.
|
|
||||||
* @param other_permissions Permission restrictions applied to other processes mapping the
|
|
||||||
* block.
|
|
||||||
* @param address The address from which to map the Shared Memory.
|
|
||||||
* @param region If the address is 0, the shared memory will be allocated in this region of the
|
|
||||||
* linear heap.
|
|
||||||
* @param name Optional object name, used for debugging purposes.
|
|
||||||
*/
|
|
||||||
static std::shared_ptr<SharedMemory> Create(KernelCore& kernel, Process* owner_process,
|
|
||||||
u64 size, MemoryPermission permissions,
|
|
||||||
MemoryPermission other_permissions,
|
|
||||||
VAddr address = 0,
|
|
||||||
MemoryRegion region = MemoryRegion::BASE,
|
|
||||||
std::string name = "Unknown");
|
std::string name = "Unknown");
|
||||||
|
|
||||||
/**
|
|
||||||
* Creates a shared memory object from a block of memory managed by an HLE applet.
|
|
||||||
* @param kernel The kernel instance to create a shared memory instance under.
|
|
||||||
* @param heap_block Heap block of the HLE applet.
|
|
||||||
* @param offset The offset into the heap block that the SharedMemory will map.
|
|
||||||
* @param size Size of the memory block. Must be page-aligned.
|
|
||||||
* @param permissions Permission restrictions applied to the process which created the block.
|
|
||||||
* @param other_permissions Permission restrictions applied to other processes mapping the
|
|
||||||
* block.
|
|
||||||
* @param name Optional object name, used for debugging purposes.
|
|
||||||
*/
|
|
||||||
static std::shared_ptr<SharedMemory> CreateForApplet(
|
|
||||||
KernelCore& kernel, std::shared_ptr<Kernel::PhysicalMemory> heap_block, std::size_t offset,
|
|
||||||
u64 size, MemoryPermission permissions, MemoryPermission other_permissions,
|
|
||||||
std::string name = "Unknown Applet");
|
|
||||||
|
|
||||||
std::string GetTypeName() const override {
|
std::string GetTypeName() const override {
|
||||||
return "SharedMemory";
|
return "SharedMemory";
|
||||||
}
|
}
|
||||||
|
|
||||||
std::string GetName() const override {
|
std::string GetName() const override {
|
||||||
return name;
|
return name;
|
||||||
}
|
}
|
||||||
|
@ -83,71 +43,42 @@ public:
|
||||||
return HANDLE_TYPE;
|
return HANDLE_TYPE;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Gets the size of the underlying memory block in bytes.
|
|
||||||
u64 GetSize() const {
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Converts the specified MemoryPermission into the equivalent VMAPermission.
|
|
||||||
* @param permission The MemoryPermission to convert.
|
|
||||||
*/
|
|
||||||
static VMAPermission ConvertPermissions(MemoryPermission permission);
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Maps a shared memory block to an address in the target process' address space
|
* Maps a shared memory block to an address in the target process' address space
|
||||||
* @param target_process Process on which to map the memory block.
|
* @param target_process Process on which to map the memory block
|
||||||
* @param address Address in system memory to map shared memory block to
|
* @param address Address in system memory to map shared memory block to
|
||||||
|
* @param size Size of the shared memory block to map
|
||||||
* @param permissions Memory block map permissions (specified by SVC field)
|
* @param permissions Memory block map permissions (specified by SVC field)
|
||||||
* @param other_permissions Memory block map other permissions (specified by SVC field)
|
|
||||||
*/
|
*/
|
||||||
ResultCode Map(Process& target_process, VAddr address, MemoryPermission permissions,
|
ResultCode Map(Process& target_process, VAddr address, std::size_t size,
|
||||||
MemoryPermission other_permissions);
|
Memory::MemoryPermission permission);
|
||||||
|
|
||||||
/**
|
|
||||||
* Unmaps a shared memory block from the specified address in system memory
|
|
||||||
*
|
|
||||||
* @param target_process Process from which to unmap the memory block.
|
|
||||||
* @param address Address in system memory where the shared memory block is mapped.
|
|
||||||
* @param unmap_size The amount of bytes to unmap from this shared memory instance.
|
|
||||||
*
|
|
||||||
* @return Result code of the unmap operation
|
|
||||||
*
|
|
||||||
* @pre The given size to unmap must be the same size as the amount of memory managed by
|
|
||||||
* the SharedMemory instance itself, otherwise ERR_INVALID_SIZE will be returned.
|
|
||||||
*/
|
|
||||||
ResultCode Unmap(Process& target_process, VAddr address, u64 unmap_size);
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Gets a pointer to the shared memory block
|
* Gets a pointer to the shared memory block
|
||||||
* @param offset Offset from the start of the shared memory block to get pointer
|
* @param offset Offset from the start of the shared memory block to get pointer
|
||||||
* @return A pointer to the shared memory block from the specified offset
|
* @return A pointer to the shared memory block from the specified offset
|
||||||
*/
|
*/
|
||||||
u8* GetPointer(std::size_t offset = 0);
|
u8* GetPointer(std::size_t offset = 0) {
|
||||||
|
return device_memory.GetPointer(physical_address + offset);
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Gets a constant pointer to the shared memory block
|
* Gets a pointer to the shared memory block
|
||||||
* @param offset Offset from the start of the shared memory block to get pointer
|
* @param offset Offset from the start of the shared memory block to get pointer
|
||||||
* @return A constant pointer to the shared memory block from the specified offset
|
* @return A pointer to the shared memory block from the specified offset
|
||||||
*/
|
*/
|
||||||
const u8* GetPointer(std::size_t offset = 0) const;
|
const u8* GetPointer(std::size_t offset = 0) const {
|
||||||
|
return device_memory.GetPointer(physical_address + offset);
|
||||||
|
}
|
||||||
|
|
||||||
private:
|
private:
|
||||||
/// Backing memory for this shared memory block.
|
Core::DeviceMemory& device_memory;
|
||||||
std::shared_ptr<PhysicalMemory> backing_block;
|
Process* owner_process{};
|
||||||
/// Offset into the backing block for this shared memory.
|
Memory::PageLinkedList page_list;
|
||||||
std::size_t backing_block_offset = 0;
|
Memory::MemoryPermission owner_permission{};
|
||||||
/// Size of the memory block. Page-aligned.
|
Memory::MemoryPermission user_permission{};
|
||||||
u64 size = 0;
|
PAddr physical_address{};
|
||||||
/// Permission restrictions applied to the process which created the block.
|
std::size_t size{};
|
||||||
MemoryPermission permissions{};
|
|
||||||
/// Permission restrictions applied to other processes mapping the block.
|
|
||||||
MemoryPermission other_permissions{};
|
|
||||||
/// Process that created this shared memory block.
|
|
||||||
Process* owner_process;
|
|
||||||
/// Address of shared memory block in the owner process if specified.
|
|
||||||
VAddr base_address = 0;
|
|
||||||
/// Name of shared memory object.
|
|
||||||
std::string name;
|
std::string name;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
Reference in New Issue