Browse Source
Merge pull request #1025 from yuriks/heap-management
Merge pull request #1025 from yuriks/heap-management
Kernel: Correct(er) handling of Heap and Linear Heap allocationsnce_cpp
Yuri Kunde Schlesner
11 years ago
29 changed files with 729 additions and 316 deletions
-
15src/common/logging/log.h
-
4src/core/CMakeLists.txt
-
1src/core/arm/skyeye_common/armstate.cpp
-
1src/core/arm/skyeye_common/armsupp.cpp
-
7src/core/hle/config_mem.cpp
-
1src/core/hle/config_mem.h
-
8src/core/hle/function_wrappers.h
-
4src/core/hle/hle.cpp
-
19src/core/hle/kernel/kernel.cpp
-
136src/core/hle/kernel/memory.cpp
-
35src/core/hle/kernel/memory.h
-
152src/core/hle/kernel/process.cpp
-
39src/core/hle/kernel/process.h
-
1src/core/hle/kernel/resource_limit.cpp
-
4src/core/hle/kernel/thread.cpp
-
118src/core/hle/kernel/vm_manager.cpp
-
38src/core/hle/kernel/vm_manager.h
-
21src/core/hle/service/apt/apt.cpp
-
1src/core/hle/service/gsp_gpu.cpp
-
1src/core/hle/service/y2r_u.cpp
-
3src/core/hle/shared_page.cpp
-
1src/core/hle/shared_page.h
-
158src/core/hle/svc.cpp
-
163src/core/mem_map.cpp
-
46src/core/mem_map.h
-
40src/core/memory.cpp
-
22src/core/memory.h
-
3src/core/memory_setup.h
-
3src/core/system.cpp
@ -0,0 +1,136 @@ |
|||
// Copyright 2014 Citra Emulator Project
|
|||
// Licensed under GPLv2 or any later version
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include <map>
|
|||
#include <memory>
|
|||
#include <utility>
|
|||
#include <vector>
|
|||
|
|||
#include "common/common_types.h"
|
|||
#include "common/logging/log.h"
|
|||
|
|||
#include "core/hle/config_mem.h"
|
|||
#include "core/hle/kernel/memory.h"
|
|||
#include "core/hle/kernel/vm_manager.h"
|
|||
#include "core/hle/result.h"
|
|||
#include "core/hle/shared_page.h"
|
|||
#include "core/memory.h"
|
|||
#include "core/memory_setup.h"
|
|||
|
|||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|||
|
|||
namespace Kernel { |
|||
|
|||
static MemoryRegionInfo memory_regions[3]; |
|||
|
|||
/// Size of the APPLICATION, SYSTEM and BASE memory regions (respectively) for each sytem
|
|||
/// memory configuration type.
|
|||
static const u32 memory_region_sizes[8][3] = { |
|||
// Old 3DS layouts
|
|||
{0x04000000, 0x02C00000, 0x01400000}, // 0
|
|||
{ /* This appears to be unused. */ }, // 1
|
|||
{0x06000000, 0x00C00000, 0x01400000}, // 2
|
|||
{0x05000000, 0x01C00000, 0x01400000}, // 3
|
|||
{0x04800000, 0x02400000, 0x01400000}, // 4
|
|||
{0x02000000, 0x04C00000, 0x01400000}, // 5
|
|||
|
|||
// New 3DS layouts
|
|||
{0x07C00000, 0x06400000, 0x02000000}, // 6
|
|||
{0x0B200000, 0x02E00000, 0x02000000}, // 7
|
|||
}; |
|||
|
|||
void MemoryInit(u32 mem_type) { |
|||
// TODO(yuriks): On the n3DS, all o3DS configurations (<=5) are forced to 6 instead.
|
|||
ASSERT_MSG(mem_type <= 5, "New 3DS memory configuration aren't supported yet!"); |
|||
ASSERT(mem_type != 1); |
|||
|
|||
// The kernel allocation regions (APPLICATION, SYSTEM and BASE) are laid out in sequence, with
|
|||
// the sizes specified in the memory_region_sizes table.
|
|||
VAddr base = 0; |
|||
for (int i = 0; i < 3; ++i) { |
|||
memory_regions[i].base = base; |
|||
memory_regions[i].size = memory_region_sizes[mem_type][i]; |
|||
memory_regions[i].linear_heap_memory = std::make_shared<std::vector<u8>>(); |
|||
|
|||
base += memory_regions[i].size; |
|||
} |
|||
|
|||
// We must've allocated the entire FCRAM by the end
|
|||
ASSERT(base == Memory::FCRAM_SIZE); |
|||
|
|||
using ConfigMem::config_mem; |
|||
config_mem.app_mem_type = mem_type; |
|||
// app_mem_malloc does not always match the configured size for memory_region[0]: in case the
|
|||
// n3DS type override is in effect it reports the size the game expects, not the real one.
|
|||
config_mem.app_mem_alloc = memory_region_sizes[mem_type][0]; |
|||
config_mem.sys_mem_alloc = memory_regions[1].size; |
|||
config_mem.base_mem_alloc = memory_regions[2].size; |
|||
} |
|||
|
|||
void MemoryShutdown() { |
|||
for (auto& region : memory_regions) { |
|||
region.base = 0; |
|||
region.size = 0; |
|||
region.linear_heap_memory = nullptr; |
|||
} |
|||
} |
|||
|
|||
MemoryRegionInfo* GetMemoryRegion(MemoryRegion region) { |
|||
switch (region) { |
|||
case MemoryRegion::APPLICATION: |
|||
return &memory_regions[0]; |
|||
case MemoryRegion::SYSTEM: |
|||
return &memory_regions[1]; |
|||
case MemoryRegion::BASE: |
|||
return &memory_regions[2]; |
|||
default: |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
} |
|||
|
|||
namespace Memory { |
|||
|
|||
namespace { |
|||
|
|||
struct MemoryArea { |
|||
u32 base; |
|||
u32 size; |
|||
const char* name; |
|||
}; |
|||
|
|||
// We don't declare the IO regions in here since its handled by other means.
|
|||
static MemoryArea memory_areas[] = { |
|||
{SHARED_MEMORY_VADDR, SHARED_MEMORY_SIZE, "Shared Memory"}, // Shared memory
|
|||
{VRAM_VADDR, VRAM_SIZE, "VRAM"}, // Video memory (VRAM)
|
|||
{DSP_RAM_VADDR, DSP_RAM_SIZE, "DSP RAM"}, // DSP memory
|
|||
{TLS_AREA_VADDR, TLS_AREA_SIZE, "TLS Area"}, // TLS memory
|
|||
}; |
|||
|
|||
} |
|||
|
|||
void Init() { |
|||
InitMemoryMap(); |
|||
LOG_DEBUG(HW_Memory, "initialized OK"); |
|||
} |
|||
|
|||
void InitLegacyAddressSpace(Kernel::VMManager& address_space) { |
|||
using namespace Kernel; |
|||
|
|||
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 cfg_mem_vma = address_space.MapBackingMemory(CONFIG_MEMORY_VADDR, |
|||
(u8*)&ConfigMem::config_mem, 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).MoveFrom(); |
|||
address_space.Reprotect(shared_page_vma, VMAPermission::Read); |
|||
} |
|||
|
|||
} // namespace
|
|||
@ -0,0 +1,35 @@ |
|||
// Copyright 2014 Citra Emulator Project |
|||
// Licensed under GPLv2 or any later version |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
|
|||
#include "common/common_types.h" |
|||
|
|||
#include "core/hle/kernel/process.h" |
|||
|
|||
namespace Kernel { |
|||
|
|||
class VMManager; |
|||
|
|||
struct MemoryRegionInfo { |
|||
u32 base; // Not an address, but offset from start of FCRAM |
|||
u32 size; |
|||
|
|||
std::shared_ptr<std::vector<u8>> linear_heap_memory; |
|||
}; |
|||
|
|||
void MemoryInit(u32 mem_type); |
|||
void MemoryShutdown(); |
|||
MemoryRegionInfo* GetMemoryRegion(MemoryRegion region); |
|||
|
|||
} |
|||
|
|||
namespace Memory { |
|||
|
|||
void Init(); |
|||
void InitLegacyAddressSpace(Kernel::VMManager& address_space); |
|||
|
|||
} // namespace |
|||
@ -1,163 +0,0 @@ |
|||
// Copyright 2014 Citra Emulator Project
|
|||
// Licensed under GPLv2 or any later version
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include <map>
|
|||
#include <memory>
|
|||
#include <utility>
|
|||
#include <vector>
|
|||
|
|||
#include "common/common_types.h"
|
|||
#include "common/logging/log.h"
|
|||
|
|||
#include "core/hle/config_mem.h"
|
|||
#include "core/hle/kernel/vm_manager.h"
|
|||
#include "core/hle/result.h"
|
|||
#include "core/hle/shared_page.h"
|
|||
#include "core/mem_map.h"
|
|||
#include "core/memory.h"
|
|||
#include "core/memory_setup.h"
|
|||
|
|||
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|||
|
|||
namespace Memory { |
|||
|
|||
namespace { |
|||
|
|||
struct MemoryArea { |
|||
u32 base; |
|||
u32 size; |
|||
const char* name; |
|||
}; |
|||
|
|||
// We don't declare the IO regions in here since its handled by other means.
|
|||
static MemoryArea memory_areas[] = { |
|||
{HEAP_VADDR, HEAP_SIZE, "Heap"}, // Application heap (main memory)
|
|||
{SHARED_MEMORY_VADDR, SHARED_MEMORY_SIZE, "Shared Memory"}, // Shared memory
|
|||
{LINEAR_HEAP_VADDR, LINEAR_HEAP_SIZE, "Linear Heap"}, // Linear heap (main memory)
|
|||
{VRAM_VADDR, VRAM_SIZE, "VRAM"}, // Video memory (VRAM)
|
|||
{DSP_RAM_VADDR, DSP_RAM_SIZE, "DSP RAM"}, // DSP memory
|
|||
{TLS_AREA_VADDR, TLS_AREA_SIZE, "TLS Area"}, // TLS memory
|
|||
}; |
|||
|
|||
/// Represents a block of memory mapped by ControlMemory/MapMemoryBlock
|
|||
struct MemoryBlock { |
|||
MemoryBlock() : handle(0), base_address(0), address(0), size(0), operation(0), permissions(0) { |
|||
} |
|||
u32 handle; |
|||
u32 base_address; |
|||
u32 address; |
|||
u32 size; |
|||
u32 operation; |
|||
u32 permissions; |
|||
|
|||
const u32 GetVirtualAddress() const{ |
|||
return base_address + address; |
|||
} |
|||
}; |
|||
|
|||
static std::map<u32, MemoryBlock> heap_map; |
|||
static std::map<u32, MemoryBlock> heap_linear_map; |
|||
|
|||
} |
|||
|
|||
u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions) { |
|||
MemoryBlock block; |
|||
|
|||
block.base_address = HEAP_VADDR; |
|||
block.size = size; |
|||
block.operation = operation; |
|||
block.permissions = permissions; |
|||
|
|||
if (heap_map.size() > 0) { |
|||
const MemoryBlock last_block = heap_map.rbegin()->second; |
|||
block.address = last_block.address + last_block.size; |
|||
} |
|||
heap_map[block.GetVirtualAddress()] = block; |
|||
|
|||
return block.GetVirtualAddress(); |
|||
} |
|||
|
|||
u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions) { |
|||
MemoryBlock block; |
|||
|
|||
block.base_address = LINEAR_HEAP_VADDR; |
|||
block.size = size; |
|||
block.operation = operation; |
|||
block.permissions = permissions; |
|||
|
|||
if (heap_linear_map.size() > 0) { |
|||
const MemoryBlock last_block = heap_linear_map.rbegin()->second; |
|||
block.address = last_block.address + last_block.size; |
|||
} |
|||
heap_linear_map[block.GetVirtualAddress()] = block; |
|||
|
|||
return block.GetVirtualAddress(); |
|||
} |
|||
|
|||
PAddr VirtualToPhysicalAddress(const VAddr addr) { |
|||
if (addr == 0) { |
|||
return 0; |
|||
} else if (addr >= VRAM_VADDR && addr < VRAM_VADDR_END) { |
|||
return addr - VRAM_VADDR + VRAM_PADDR; |
|||
} else if (addr >= LINEAR_HEAP_VADDR && addr < LINEAR_HEAP_VADDR_END) { |
|||
return addr - LINEAR_HEAP_VADDR + FCRAM_PADDR; |
|||
} else if (addr >= DSP_RAM_VADDR && addr < DSP_RAM_VADDR_END) { |
|||
return addr - DSP_RAM_VADDR + DSP_RAM_PADDR; |
|||
} else if (addr >= IO_AREA_VADDR && addr < IO_AREA_VADDR_END) { |
|||
return addr - IO_AREA_VADDR + IO_AREA_PADDR; |
|||
} |
|||
|
|||
LOG_ERROR(HW_Memory, "Unknown virtual address @ 0x%08x", addr); |
|||
// To help with debugging, set bit on address so that it's obviously invalid.
|
|||
return addr | 0x80000000; |
|||
} |
|||
|
|||
VAddr PhysicalToVirtualAddress(const PAddr addr) { |
|||
if (addr == 0) { |
|||
return 0; |
|||
} else if (addr >= VRAM_PADDR && addr < VRAM_PADDR_END) { |
|||
return addr - VRAM_PADDR + VRAM_VADDR; |
|||
} else if (addr >= FCRAM_PADDR && addr < FCRAM_PADDR_END) { |
|||
return addr - FCRAM_PADDR + LINEAR_HEAP_VADDR; |
|||
} else if (addr >= DSP_RAM_PADDR && addr < DSP_RAM_PADDR_END) { |
|||
return addr - DSP_RAM_PADDR + DSP_RAM_VADDR; |
|||
} else if (addr >= IO_AREA_PADDR && addr < IO_AREA_PADDR_END) { |
|||
return addr - IO_AREA_PADDR + IO_AREA_VADDR; |
|||
} |
|||
|
|||
LOG_ERROR(HW_Memory, "Unknown physical address @ 0x%08x", addr); |
|||
// To help with debugging, set bit on address so that it's obviously invalid.
|
|||
return addr | 0x80000000; |
|||
} |
|||
|
|||
void Init() { |
|||
InitMemoryMap(); |
|||
LOG_DEBUG(HW_Memory, "initialized OK"); |
|||
} |
|||
|
|||
void InitLegacyAddressSpace(Kernel::VMManager& address_space) { |
|||
using namespace Kernel; |
|||
|
|||
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 cfg_mem_vma = address_space.MapBackingMemory(CONFIG_MEMORY_VADDR, |
|||
(u8*)&ConfigMem::config_mem, 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).MoveFrom(); |
|||
address_space.Reprotect(shared_page_vma, VMAPermission::Read); |
|||
} |
|||
|
|||
void Shutdown() { |
|||
heap_map.clear(); |
|||
heap_linear_map.clear(); |
|||
|
|||
LOG_DEBUG(HW_Memory, "shutdown OK"); |
|||
} |
|||
|
|||
} // namespace
|
|||
@ -1,46 +0,0 @@ |
|||
// Copyright 2014 Citra Emulator Project |
|||
// Licensed under GPLv2 or any later version |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include "common/common_types.h" |
|||
|
|||
namespace Kernel { |
|||
class VMManager; |
|||
} |
|||
|
|||
namespace Memory { |
|||
|
|||
void Init(); |
|||
void InitLegacyAddressSpace(Kernel::VMManager& address_space); |
|||
void Shutdown(); |
|||
|
|||
/** |
|||
* Maps a block of memory on the heap |
|||
* @param size Size of block in bytes |
|||
* @param operation Memory map operation type |
|||
* @param permissions Memory allocation permissions |
|||
*/ |
|||
u32 MapBlock_Heap(u32 size, u32 operation, u32 permissions); |
|||
|
|||
/** |
|||
* Maps a block of memory on the GSP heap |
|||
* @param size Size of block in bytes |
|||
* @param operation Memory map operation type |
|||
* @param permissions Control memory permissions |
|||
*/ |
|||
u32 MapBlock_HeapLinear(u32 size, u32 operation, u32 permissions); |
|||
|
|||
/** |
|||
* Converts a virtual address inside a region with 1:1 mapping to physical memory to a physical |
|||
* address. This should be used by services to translate addresses for use by the hardware. |
|||
*/ |
|||
PAddr VirtualToPhysicalAddress(VAddr addr); |
|||
|
|||
/** |
|||
* Undoes a mapping performed by VirtualToPhysicalAddress(). |
|||
*/ |
|||
VAddr PhysicalToVirtualAddress(PAddr addr); |
|||
|
|||
} // namespace |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue