OpenPunk/citra
1
0
Fork 0
mirror of https://github.com/citra-emu/citra.git synced 2024-12-18 22:00:05 +00:00
Code Issues Projects Releases Wiki Activity

Memory: Make ReadBlock take a Process parameter on which to operate

Browse Source
This commit is contained in:
Subv 2017-09-29 19:38:54 -05:00
parent 8217ed7acb
commit 811c01e5fe
2 changed files with 30 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/core/memory.cpp
View File

@ -82,10 +82,10 @@ void UnmapRegion(PageTable& page_table, VAddr base, u32 size) {
* Gets a pointer to the exact memory at the virtual address (i.e. not page aligned) * Gets a pointer to the exact memory at the virtual address (i.e. not page aligned)
* using a VMA from the current process * using a VMA from the current process
*/ */
static u8* GetPointerFromVMA(VAddr vaddr) { static u8* GetPointerFromVMA(const Kernel::Process& process, VAddr vaddr) {
u8* direct_pointer = nullptr; u8* direct_pointer = nullptr;
auto& vm_manager = Kernel::g_current_process->vm_manager; auto& vm_manager = process.vm_manager;
auto it = vm_manager.FindVMA(vaddr); auto it = vm_manager.FindVMA(vaddr);
ASSERT(it != vm_manager.vma_map.end()); ASSERT(it != vm_manager.vma_map.end());
@ -107,6 +107,14 @@ static u8* GetPointerFromVMA(VAddr vaddr) {
return direct_pointer + (vaddr - vma.base); return direct_pointer + (vaddr - vma.base);
} }
/**
* Gets a pointer to the exact memory at the virtual address (i.e. not page aligned)
* using a VMA from the current process.
*/
static u8* GetPointerFromVMA(VAddr vaddr) {
return GetPointerFromVMA(*Kernel::g_current_process, vaddr);
}
/** /**
* This function should only be called for virtual addreses with attribute `PageType::Special`. * This function should only be called for virtual addreses with attribute `PageType::Special`.
*/ */
@ -470,7 +478,10 @@ u64 Read64(const VAddr addr) {
return Read<u64_le>(addr); return Read<u64_le>(addr);
} }
void ReadBlock(const VAddr src_addr, void* dest_buffer, const size_t size) { void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
const size_t size) {
auto& page_table = process.vm_manager.page_table;
size_t remaining_size = size; size_t remaining_size = size;
size_t page_index = src_addr >> PAGE_BITS; size_t page_index = src_addr >> PAGE_BITS;
size_t page_offset = src_addr & PAGE_MASK; size_t page_offset = src_addr & PAGE_MASK;
@ -479,7 +490,7 @@ void ReadBlock(const VAddr src_addr, void* dest_buffer, const size_t size) {
const size_t copy_amount = std::min(PAGE_SIZE - page_offset, remaining_size); const size_t copy_amount = std::min(PAGE_SIZE - page_offset, remaining_size);
const VAddr current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset); const VAddr current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
switch (current_page_table->attributes[page_index]) { switch (page_table.attributes[page_index]) {
case PageType::Unmapped: { case PageType::Unmapped: {
LOG_ERROR(HW_Memory, "unmapped ReadBlock @ 0x%08X (start address = 0x%08X, size = %zu)", LOG_ERROR(HW_Memory, "unmapped ReadBlock @ 0x%08X (start address = 0x%08X, size = %zu)",
current_vaddr, src_addr, size); current_vaddr, src_addr, size);
@ -487,29 +498,30 @@ void ReadBlock(const VAddr src_addr, void* dest_buffer, const size_t size) {
break; break;
} }
case PageType::Memory: { case PageType::Memory: {
DEBUG_ASSERT(current_page_table->pointers[page_index]); DEBUG_ASSERT(page_table.pointers[page_index]);
const u8* src_ptr = current_page_table->pointers[page_index] + page_offset; const u8* src_ptr = page_table.pointers[page_index] + page_offset;
std::memcpy(dest_buffer, src_ptr, copy_amount); std::memcpy(dest_buffer, src_ptr, copy_amount);
break; break;
} }
case PageType::Special: { case PageType::Special: {
DEBUG_ASSERT(GetMMIOHandler(current_vaddr)); MMIORegionPointer handler = GetMMIOHandler(page_table, current_vaddr);
DEBUG_ASSERT(handler);
GetMMIOHandler(current_vaddr)->ReadBlock(current_vaddr, dest_buffer, copy_amount); handler->ReadBlock(current_vaddr, dest_buffer, copy_amount);
break; break;
} }
case PageType::RasterizerCachedMemory: { case PageType::RasterizerCachedMemory: {
RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount), RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
FlushMode::Flush); FlushMode::Flush);
std::memcpy(dest_buffer, GetPointerFromVMA(current_vaddr), copy_amount); std::memcpy(dest_buffer, GetPointerFromVMA(process, current_vaddr), copy_amount);
break; break;
} }
case PageType::RasterizerCachedSpecial: { case PageType::RasterizerCachedSpecial: {
DEBUG_ASSERT(GetMMIOHandler(current_vaddr)); MMIORegionPointer handler = GetMMIOHandler(page_table, current_vaddr);
DEBUG_ASSERT(handler);
RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount), RasterizerFlushVirtualRegion(current_vaddr, static_cast<u32>(copy_amount),
FlushMode::Flush); FlushMode::Flush);
GetMMIOHandler(current_vaddr)->ReadBlock(current_vaddr, dest_buffer, copy_amount); handler->ReadBlock(current_vaddr, dest_buffer, copy_amount);
break; break;
} }
default: default:
@ -523,6 +535,10 @@ void ReadBlock(const VAddr src_addr, void* dest_buffer, const size_t size) {
} }
} }
void ReadBlock(const VAddr src_addr, void* dest_buffer, const size_t size) {
ReadBlock(*Kernel::g_current_process, src_addr, dest_buffer, size);
}
void Write8(const VAddr addr, const u8 data) { void Write8(const VAddr addr, const u8 data) {
Write<u8>(addr, data); Write<u8>(addr, data);
} }

2
src/core/memory.h
View File

@ -205,6 +205,8 @@ void Write16(VAddr addr, u16 data);
void Write32(VAddr addr, u32 data); void Write32(VAddr addr, u32 data);
void Write64(VAddr addr, u64 data); void Write64(VAddr addr, u64 data);
void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
size_t size);
void ReadBlock(const VAddr src_addr, void* dest_buffer, size_t size); void ReadBlock(const VAddr src_addr, void* dest_buffer, size_t size);
void WriteBlock(const VAddr dest_addr, const void* src_buffer, size_t size); void WriteBlock(const VAddr dest_addr, const void* src_buffer, size_t size);
void ZeroBlock(const VAddr dest_addr, const size_t size); void ZeroBlock(const VAddr dest_addr, const size_t size);