kernel: shared_memory: Refactor for new VMM.

src/core/hle/kernel/shared_memory.cpp

@@ -2,149 +2,56 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <utility>
-
 #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/memory/page_table.h"
 #include "core/hle/kernel/shared_memory.h"
 
 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;
 
-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->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->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;
 }
 
-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,
-                             MemoryPermission other_permissions) {
-    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 (base_address == 0 && other_permissions != MemoryPermission::DontCare) {
-        return ERR_INVALID_MEMORY_PERMISSIONS;
     }
 
-    // Error out if the requested permissions don't match what the creator process allows.
+    Memory::MemoryPermission expected =
-    if (static_cast<u32>(permissions) & ~static_cast<u32>(own_other_permissions)) {
+        &target_process == owner_process ? owner_permission : user_permission;
-        LOG_ERROR(Kernel, "cannot map id={}, address=0x{:X} name={}, permissions don't match",
+
-                  GetObjectId(), address, name);
+    if (permission != expected) {
-        return ERR_INVALID_MEMORY_PERMISSIONS;
+        UNIMPLEMENTED();
     }
 
-    // Error out if the provided permissions are not compatible with what the creator process needs.
+    return target_process.PageTable().MapPages(address, page_list, Memory::MemoryState::Shared,
-    if (other_permissions != MemoryPermission::DontCare &&
+                                               permission);
-        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

src/core/hle/kernel/shared_memory.h

@@ -8,8 +8,10 @@
 #include <string>
 
 #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/physical_memory.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
 
@@ -17,63 +19,21 @@ namespace Kernel {
 
 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 {
 public:
-    explicit SharedMemory(KernelCore& kernel);
+    explicit SharedMemory(KernelCore& kernel, Core::DeviceMemory& device_memory);
     ~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.
+        std::string name = "Unknown");
-     * @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");
-
-    /**
-     * 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 {
         return "SharedMemory";
     }
+
     std::string GetName() const override {
         return name;
     }
@@ -83,71 +43,42 @@ public:
         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
-     * @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 size Size of the shared memory block to map
      * @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
      * @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
      */
-    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
-     * @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:
-    /// 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;
 };