2015-05-13 01:38:29 +00:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
2016-11-24 19:42:32 +00:00
|
|
|
#include <array>
|
2015-06-21 12:12:49 +00:00
|
|
|
#include <cstddef>
|
2016-06-27 17:42:42 +00:00
|
|
|
#include <string>
|
2020-01-03 17:19:59 +00:00
|
|
|
#include <boost/serialization/array.hpp>
|
|
|
|
#include <boost/serialization/vector.hpp>
|
2015-05-13 01:38:29 +00:00
|
|
|
#include "common/common_types.h"
|
2020-01-04 22:39:54 +00:00
|
|
|
#include "common/memory_ref.h"
|
2017-07-22 02:17:57 +00:00
|
|
|
#include "core/mmio.h"
|
2015-05-13 01:38:29 +00:00
|
|
|
|
2019-02-01 17:43:55 +00:00
|
|
|
class ARM_Interface;
|
|
|
|
|
2017-09-26 22:27:44 +00:00
|
|
|
namespace Kernel {
|
|
|
|
class Process;
|
|
|
|
}
|
|
|
|
|
2023-08-01 22:40:39 +00:00
|
|
|
namespace Core {
|
|
|
|
class System;
|
|
|
|
}
|
|
|
|
|
2019-02-04 02:33:20 +00:00
|
|
|
namespace AudioCore {
|
|
|
|
class DspInterface;
|
|
|
|
}
|
|
|
|
|
2015-05-13 01:38:29 +00:00
|
|
|
namespace Memory {
|
|
|
|
|
2015-05-13 02:38:56 +00:00
|
|
|
/**
|
|
|
|
* Page size used by the ARM architecture. This is the smallest granularity with which memory can
|
|
|
|
* be mapped.
|
|
|
|
*/
|
2022-11-04 22:32:57 +00:00
|
|
|
constexpr u32 CITRA_PAGE_SIZE = 0x1000;
|
|
|
|
constexpr u32 CITRA_PAGE_MASK = CITRA_PAGE_SIZE - 1;
|
|
|
|
constexpr int CITRA_PAGE_BITS = 12;
|
|
|
|
constexpr std::size_t PAGE_TABLE_NUM_ENTRIES = 1 << (32 - CITRA_PAGE_BITS);
|
2015-05-13 01:38:29 +00:00
|
|
|
|
2017-07-22 02:17:57 +00:00
|
|
|
enum class PageType {
|
|
|
|
/// Page is unmapped and should cause an access error.
|
|
|
|
Unmapped,
|
|
|
|
/// Page is mapped to regular memory. This is the only type you can get pointers to.
|
|
|
|
Memory,
|
|
|
|
/// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
|
|
|
|
/// invalidation
|
|
|
|
RasterizerCachedMemory,
|
|
|
|
/// Page is mapped to a I/O region. Writing and reading to this page is handled by functions.
|
|
|
|
Special,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct SpecialRegion {
|
|
|
|
VAddr base;
|
|
|
|
u32 size;
|
|
|
|
MMIORegionPointer handler;
|
2019-08-06 14:59:31 +00:00
|
|
|
|
2020-01-03 17:19:59 +00:00
|
|
|
private:
|
2019-12-27 21:07:29 +00:00
|
|
|
template <class Archive>
|
|
|
|
void serialize(Archive& ar, const unsigned int file_version) {
|
|
|
|
ar& base;
|
|
|
|
ar& size;
|
|
|
|
ar& handler;
|
2019-08-06 14:59:31 +00:00
|
|
|
}
|
2020-01-03 17:19:59 +00:00
|
|
|
friend class boost::serialization::access;
|
2017-07-22 02:17:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A (reasonably) fast way of allowing switchable and remappable process address spaces. It loosely
|
|
|
|
* mimics the way a real CPU page table works, but instead is optimized for minimal decoding and
|
|
|
|
* fetching requirements when accessing. In the usual case of an access to regular memory, it only
|
|
|
|
* requires an indexed fetch and a check for NULL.
|
|
|
|
*/
|
|
|
|
struct PageTable {
|
|
|
|
/**
|
|
|
|
* Array of memory pointers backing each page. An entry can only be non-null if the
|
|
|
|
* corresponding entry in the `attributes` array is of type `Memory`.
|
|
|
|
*/
|
2020-01-04 22:39:54 +00:00
|
|
|
|
|
|
|
// The reason for this rigmarole is to keep the 'raw' and 'refs' arrays in sync.
|
|
|
|
// We need 'raw' for dynarmic and 'refs' for serialization
|
|
|
|
struct Pointers {
|
|
|
|
|
|
|
|
struct Entry {
|
|
|
|
Entry(Pointers& pointers_, VAddr idx_) : pointers(pointers_), idx(idx_) {}
|
|
|
|
|
2020-04-28 19:39:02 +00:00
|
|
|
Entry& operator=(MemoryRef value) {
|
2020-01-04 22:39:54 +00:00
|
|
|
pointers.raw[idx] = value.GetPtr();
|
2020-04-28 19:39:02 +00:00
|
|
|
pointers.refs[idx] = std::move(value);
|
|
|
|
return *this;
|
2020-01-04 22:39:54 +00:00
|
|
|
}
|
|
|
|
|
2020-03-31 16:54:28 +00:00
|
|
|
operator u8*() {
|
2020-01-04 22:39:54 +00:00
|
|
|
return pointers.raw[idx];
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
Pointers& pointers;
|
|
|
|
VAddr idx;
|
|
|
|
};
|
|
|
|
|
2020-03-31 16:54:28 +00:00
|
|
|
Entry operator[](std::size_t idx) {
|
2020-01-04 22:39:54 +00:00
|
|
|
return Entry(*this, static_cast<VAddr>(idx));
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::array<u8*, PAGE_TABLE_NUM_ENTRIES> raw;
|
|
|
|
std::array<MemoryRef, PAGE_TABLE_NUM_ENTRIES> refs;
|
|
|
|
friend struct PageTable;
|
|
|
|
};
|
2022-11-04 22:32:57 +00:00
|
|
|
|
2020-01-04 22:39:54 +00:00
|
|
|
Pointers pointers;
|
2017-07-22 02:17:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Contains MMIO handlers that back memory regions whose entries in the `attribute` array is of
|
|
|
|
* type `Special`.
|
|
|
|
*/
|
|
|
|
std::vector<SpecialRegion> special_regions;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Array of fine grained page attributes. If it is set to any value other than `Memory`, then
|
|
|
|
* the corresponding entry in `pointers` MUST be set to null.
|
|
|
|
*/
|
|
|
|
std::array<PageType, PAGE_TABLE_NUM_ENTRIES> attributes;
|
2020-01-03 17:19:59 +00:00
|
|
|
|
2020-03-31 16:54:28 +00:00
|
|
|
std::array<u8*, PAGE_TABLE_NUM_ENTRIES>& GetPointerArray() {
|
2020-01-04 22:39:54 +00:00
|
|
|
return pointers.raw;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Clear();
|
|
|
|
|
2020-01-03 17:19:59 +00:00
|
|
|
private:
|
|
|
|
template <class Archive>
|
|
|
|
void serialize(Archive& ar, const unsigned int) {
|
2020-01-04 22:39:54 +00:00
|
|
|
ar& pointers.refs;
|
2020-01-03 17:19:59 +00:00
|
|
|
ar& special_regions;
|
|
|
|
ar& attributes;
|
2020-04-18 22:35:59 +00:00
|
|
|
for (std::size_t i = 0; i < PAGE_TABLE_NUM_ENTRIES; i++) {
|
2020-01-04 22:39:54 +00:00
|
|
|
pointers.raw[i] = pointers.refs[i].GetPtr();
|
|
|
|
}
|
2020-01-03 17:19:59 +00:00
|
|
|
}
|
|
|
|
friend class boost::serialization::access;
|
2017-07-22 02:17:57 +00:00
|
|
|
};
|
|
|
|
|
2015-05-13 01:38:29 +00:00
|
|
|
/// Physical memory regions as seen from the ARM11
|
|
|
|
enum : PAddr {
|
|
|
|
/// IO register area
|
2016-09-18 00:38:01 +00:00
|
|
|
IO_AREA_PADDR = 0x10100000,
|
2018-11-12 20:12:12 +00:00
|
|
|
IO_AREA_SIZE = 0x00400000, ///< IO area size (4MB)
|
2015-05-13 01:38:29 +00:00
|
|
|
IO_AREA_PADDR_END = IO_AREA_PADDR + IO_AREA_SIZE,
|
|
|
|
|
|
|
|
/// MPCore internal memory region
|
2016-09-18 00:38:01 +00:00
|
|
|
MPCORE_RAM_PADDR = 0x17E00000,
|
|
|
|
MPCORE_RAM_SIZE = 0x00002000, ///< MPCore internal memory size (8KB)
|
2015-05-13 01:38:29 +00:00
|
|
|
MPCORE_RAM_PADDR_END = MPCORE_RAM_PADDR + MPCORE_RAM_SIZE,
|
|
|
|
|
|
|
|
/// Video memory
|
2016-09-18 00:38:01 +00:00
|
|
|
VRAM_PADDR = 0x18000000,
|
|
|
|
VRAM_SIZE = 0x00600000, ///< VRAM size (6MB)
|
2015-05-13 01:38:29 +00:00
|
|
|
VRAM_PADDR_END = VRAM_PADDR + VRAM_SIZE,
|
|
|
|
|
2017-05-01 00:13:53 +00:00
|
|
|
/// New 3DS additional memory. Supposedly faster than regular FCRAM. Part of it can be used by
|
|
|
|
/// applications and system modules if mapped via the ExHeader.
|
|
|
|
N3DS_EXTRA_RAM_PADDR = 0x1F000000,
|
|
|
|
N3DS_EXTRA_RAM_SIZE = 0x00400000, ///< New 3DS additional memory size (4MB)
|
|
|
|
N3DS_EXTRA_RAM_PADDR_END = N3DS_EXTRA_RAM_PADDR + N3DS_EXTRA_RAM_SIZE,
|
|
|
|
|
2015-05-13 01:38:29 +00:00
|
|
|
/// DSP memory
|
2016-09-18 00:38:01 +00:00
|
|
|
DSP_RAM_PADDR = 0x1FF00000,
|
|
|
|
DSP_RAM_SIZE = 0x00080000, ///< DSP memory size (512KB)
|
2015-05-13 01:38:29 +00:00
|
|
|
DSP_RAM_PADDR_END = DSP_RAM_PADDR + DSP_RAM_SIZE,
|
|
|
|
|
|
|
|
/// AXI WRAM
|
2016-09-18 00:38:01 +00:00
|
|
|
AXI_WRAM_PADDR = 0x1FF80000,
|
|
|
|
AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size (512KB)
|
2015-05-13 01:38:29 +00:00
|
|
|
AXI_WRAM_PADDR_END = AXI_WRAM_PADDR + AXI_WRAM_SIZE,
|
|
|
|
|
|
|
|
/// Main FCRAM
|
2016-09-18 00:38:01 +00:00
|
|
|
FCRAM_PADDR = 0x20000000,
|
2017-06-19 01:39:17 +00:00
|
|
|
FCRAM_SIZE = 0x08000000, ///< FCRAM size on the Old 3DS (128MB)
|
|
|
|
FCRAM_N3DS_SIZE = 0x10000000, ///< FCRAM size on the New 3DS (256MB)
|
2015-05-13 01:38:29 +00:00
|
|
|
FCRAM_PADDR_END = FCRAM_PADDR + FCRAM_SIZE,
|
2017-06-19 01:39:17 +00:00
|
|
|
FCRAM_N3DS_PADDR_END = FCRAM_PADDR + FCRAM_N3DS_SIZE,
|
2015-05-13 01:38:29 +00:00
|
|
|
};
|
|
|
|
|
2020-01-04 22:39:54 +00:00
|
|
|
enum class Region { FCRAM, VRAM, DSP, N3DS };
|
|
|
|
|
2015-05-13 01:38:29 +00:00
|
|
|
/// Virtual user-space memory regions
|
|
|
|
enum : VAddr {
|
|
|
|
/// Where the application text, data and bss reside.
|
2016-09-18 00:38:01 +00:00
|
|
|
PROCESS_IMAGE_VADDR = 0x00100000,
|
|
|
|
PROCESS_IMAGE_MAX_SIZE = 0x03F00000,
|
2015-05-13 01:38:29 +00:00
|
|
|
PROCESS_IMAGE_VADDR_END = PROCESS_IMAGE_VADDR + PROCESS_IMAGE_MAX_SIZE,
|
|
|
|
|
|
|
|
/// Area where IPC buffers are mapped onto.
|
2016-09-18 00:38:01 +00:00
|
|
|
IPC_MAPPING_VADDR = 0x04000000,
|
|
|
|
IPC_MAPPING_SIZE = 0x04000000,
|
2015-05-13 01:38:29 +00:00
|
|
|
IPC_MAPPING_VADDR_END = IPC_MAPPING_VADDR + IPC_MAPPING_SIZE,
|
|
|
|
|
|
|
|
/// Application heap (includes stack).
|
2016-09-18 00:38:01 +00:00
|
|
|
HEAP_VADDR = 0x08000000,
|
|
|
|
HEAP_SIZE = 0x08000000,
|
2015-05-13 01:38:29 +00:00
|
|
|
HEAP_VADDR_END = HEAP_VADDR + HEAP_SIZE,
|
|
|
|
|
|
|
|
/// Area where shared memory buffers are mapped onto.
|
2016-09-18 00:38:01 +00:00
|
|
|
SHARED_MEMORY_VADDR = 0x10000000,
|
|
|
|
SHARED_MEMORY_SIZE = 0x04000000,
|
2015-05-13 01:38:29 +00:00
|
|
|
SHARED_MEMORY_VADDR_END = SHARED_MEMORY_VADDR + SHARED_MEMORY_SIZE,
|
|
|
|
|
2016-09-18 00:38:01 +00:00
|
|
|
/// Maps 1:1 to an offset in FCRAM. Used for HW allocations that need to be linear in physical
|
|
|
|
/// memory.
|
|
|
|
LINEAR_HEAP_VADDR = 0x14000000,
|
|
|
|
LINEAR_HEAP_SIZE = 0x08000000,
|
2015-05-13 01:38:29 +00:00
|
|
|
LINEAR_HEAP_VADDR_END = LINEAR_HEAP_VADDR + LINEAR_HEAP_SIZE,
|
|
|
|
|
2017-05-01 00:13:53 +00:00
|
|
|
/// Maps 1:1 to New 3DS additional memory
|
|
|
|
N3DS_EXTRA_RAM_VADDR = 0x1E800000,
|
|
|
|
N3DS_EXTRA_RAM_VADDR_END = N3DS_EXTRA_RAM_VADDR + N3DS_EXTRA_RAM_SIZE,
|
|
|
|
|
2015-05-13 01:38:29 +00:00
|
|
|
/// Maps 1:1 to the IO register area.
|
2016-09-18 00:38:01 +00:00
|
|
|
IO_AREA_VADDR = 0x1EC00000,
|
2015-05-13 01:38:29 +00:00
|
|
|
IO_AREA_VADDR_END = IO_AREA_VADDR + IO_AREA_SIZE,
|
|
|
|
|
|
|
|
/// Maps 1:1 to VRAM.
|
2016-09-18 00:38:01 +00:00
|
|
|
VRAM_VADDR = 0x1F000000,
|
2015-05-13 01:38:29 +00:00
|
|
|
VRAM_VADDR_END = VRAM_VADDR + VRAM_SIZE,
|
|
|
|
|
|
|
|
/// Maps 1:1 to DSP memory.
|
2016-09-18 00:38:01 +00:00
|
|
|
DSP_RAM_VADDR = 0x1FF00000,
|
2015-05-13 01:38:29 +00:00
|
|
|
DSP_RAM_VADDR_END = DSP_RAM_VADDR + DSP_RAM_SIZE,
|
|
|
|
|
|
|
|
/// Read-only page containing kernel and system configuration values.
|
2016-09-18 00:38:01 +00:00
|
|
|
CONFIG_MEMORY_VADDR = 0x1FF80000,
|
|
|
|
CONFIG_MEMORY_SIZE = 0x00001000,
|
2015-05-13 01:38:29 +00:00
|
|
|
CONFIG_MEMORY_VADDR_END = CONFIG_MEMORY_VADDR + CONFIG_MEMORY_SIZE,
|
|
|
|
|
|
|
|
/// Usually read-only page containing mostly values read from hardware.
|
2016-09-18 00:38:01 +00:00
|
|
|
SHARED_PAGE_VADDR = 0x1FF81000,
|
|
|
|
SHARED_PAGE_SIZE = 0x00001000,
|
2015-05-13 01:38:29 +00:00
|
|
|
SHARED_PAGE_VADDR_END = SHARED_PAGE_VADDR + SHARED_PAGE_SIZE,
|
|
|
|
|
|
|
|
/// Area where TLS (Thread-Local Storage) buffers are allocated.
|
2016-09-18 00:38:01 +00:00
|
|
|
TLS_AREA_VADDR = 0x1FF82000,
|
|
|
|
TLS_ENTRY_SIZE = 0x200,
|
2015-08-06 00:39:53 +00:00
|
|
|
|
2015-08-06 00:26:52 +00:00
|
|
|
/// Equivalent to LINEAR_HEAP_VADDR, but expanded to cover the extra memory in the New 3DS.
|
2016-09-18 00:38:01 +00:00
|
|
|
NEW_LINEAR_HEAP_VADDR = 0x30000000,
|
|
|
|
NEW_LINEAR_HEAP_SIZE = 0x10000000,
|
2015-08-06 00:26:52 +00:00
|
|
|
NEW_LINEAR_HEAP_VADDR_END = NEW_LINEAR_HEAP_VADDR + NEW_LINEAR_HEAP_SIZE,
|
2022-12-11 08:08:58 +00:00
|
|
|
|
|
|
|
/// Area where 3GX plugin framebuffers are stored
|
|
|
|
PLUGIN_3GX_FB_VADDR = 0x06000000,
|
|
|
|
PLUGIN_3GX_FB_SIZE = 0x000A9000,
|
|
|
|
PLUGIN_3GX_FB_VADDR_END = PLUGIN_3GX_FB_VADDR + PLUGIN_3GX_FB_SIZE
|
2015-05-13 01:38:29 +00:00
|
|
|
};
|
|
|
|
|
2016-04-16 22:57:57 +00:00
|
|
|
/**
|
|
|
|
* Flushes any externally cached rasterizer resources touching the given region.
|
|
|
|
*/
|
|
|
|
void RasterizerFlushRegion(PAddr start, u32 size);
|
|
|
|
|
2017-11-23 17:43:12 +00:00
|
|
|
/**
|
|
|
|
* Invalidates any externally cached rasterizer resources touching the given region.
|
|
|
|
*/
|
|
|
|
void RasterizerInvalidateRegion(PAddr start, u32 size);
|
|
|
|
|
2016-04-16 22:57:57 +00:00
|
|
|
/**
|
|
|
|
* Flushes and invalidates any externally cached rasterizer resources touching the given region.
|
|
|
|
*/
|
|
|
|
void RasterizerFlushAndInvalidateRegion(PAddr start, u32 size);
|
2016-11-24 19:42:32 +00:00
|
|
|
|
2017-06-22 05:48:00 +00:00
|
|
|
enum class FlushMode {
|
|
|
|
/// Write back modified surfaces to RAM
|
|
|
|
Flush,
|
2017-11-23 17:43:12 +00:00
|
|
|
/// Remove region from the cache
|
|
|
|
Invalidate,
|
2017-06-22 05:48:00 +00:00
|
|
|
/// Write back modified surfaces to RAM, and also remove them from the cache
|
|
|
|
FlushAndInvalidate,
|
|
|
|
};
|
|
|
|
|
2020-01-17 06:17:55 +00:00
|
|
|
/**
|
|
|
|
* Flushes and invalidates all memory in the rasterizer cache and removes any leftover state
|
|
|
|
* If flush is true, the rasterizer should flush any cached resources to RAM before clearing
|
|
|
|
*/
|
|
|
|
void RasterizerClearAll(bool flush);
|
|
|
|
|
2017-06-22 05:48:00 +00:00
|
|
|
/**
|
|
|
|
* Flushes and invalidates any externally cached rasterizer resources touching the given virtual
|
|
|
|
* address region.
|
|
|
|
*/
|
|
|
|
void RasterizerFlushVirtualRegion(VAddr start, u32 size, FlushMode mode);
|
|
|
|
|
2018-11-21 03:38:47 +00:00
|
|
|
class MemorySystem {
|
2018-11-21 03:52:44 +00:00
|
|
|
public:
|
2023-08-01 22:40:39 +00:00
|
|
|
explicit MemorySystem(Core::System& system);
|
2018-12-01 22:46:18 +00:00
|
|
|
~MemorySystem();
|
|
|
|
|
2018-12-11 03:01:09 +00:00
|
|
|
/**
|
|
|
|
* Maps an allocated buffer onto a region of the emulated process address space.
|
|
|
|
*
|
|
|
|
* @param page_table The page table of the emulated process.
|
|
|
|
* @param base The address to start mapping at. Must be page-aligned.
|
|
|
|
* @param size The amount of bytes to map. Must be page-aligned.
|
|
|
|
* @param target Buffer with the memory backing the mapping. Must be of length at least `size`.
|
|
|
|
*/
|
2020-01-04 22:39:54 +00:00
|
|
|
void MapMemoryRegion(PageTable& page_table, VAddr base, u32 size, MemoryRef target);
|
2018-12-11 03:01:09 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Maps a region of the emulated process address space as a IO region.
|
|
|
|
* @param page_table The page table of the emulated process.
|
|
|
|
* @param base The address to start mapping at. Must be page-aligned.
|
|
|
|
* @param size The amount of bytes to map. Must be page-aligned.
|
|
|
|
* @param mmio_handler The handler that backs the mapping.
|
|
|
|
*/
|
|
|
|
void MapIoRegion(PageTable& page_table, VAddr base, u32 size, MMIORegionPointer mmio_handler);
|
|
|
|
|
|
|
|
void UnmapRegion(PageTable& page_table, VAddr base, u32 size);
|
|
|
|
|
2018-11-21 04:50:00 +00:00
|
|
|
/// Currently active page table
|
2020-01-05 16:35:01 +00:00
|
|
|
void SetCurrentPageTable(std::shared_ptr<PageTable> page_table);
|
|
|
|
std::shared_ptr<PageTable> GetCurrentPageTable() const;
|
2018-11-21 04:50:00 +00:00
|
|
|
|
2022-11-04 22:32:57 +00:00
|
|
|
/**
|
|
|
|
* Gets a pointer to the given address.
|
|
|
|
*
|
|
|
|
* @param vaddr Virtual address to retrieve a pointer to.
|
|
|
|
*
|
|
|
|
* @returns The pointer to the given address, if the address is valid.
|
|
|
|
* If the address is not valid, nullptr will be returned.
|
|
|
|
*/
|
|
|
|
u8* GetPointer(VAddr vaddr);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Gets a pointer to the given address.
|
|
|
|
*
|
|
|
|
* @param vaddr Virtual address to retrieve a pointer to.
|
|
|
|
*
|
|
|
|
* @returns The pointer to the given address, if the address is valid.
|
|
|
|
* If the address is not valid, nullptr will be returned.
|
|
|
|
*/
|
|
|
|
const u8* GetPointer(VAddr vaddr) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads an 8-bit unsigned value from the current process' address space
|
|
|
|
* at the given virtual address.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to read the 8-bit value from.
|
|
|
|
*
|
|
|
|
* @returns the read 8-bit unsigned value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
u8 Read8(VAddr addr);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads a 16-bit unsigned value from the current process' address space
|
|
|
|
* at the given virtual address.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to read the 16-bit value from.
|
|
|
|
*
|
|
|
|
* @returns the read 16-bit unsigned value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
u16 Read16(VAddr addr);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads a 32-bit unsigned value from the current process' address space
|
|
|
|
* at the given virtual address.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to read the 32-bit value from.
|
|
|
|
*
|
|
|
|
* @returns the read 32-bit unsigned value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
u32 Read32(VAddr addr);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads a 64-bit unsigned value from the current process' address space
|
|
|
|
* at the given virtual address.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to read the 64-bit value from.
|
|
|
|
*
|
|
|
|
* @returns the read 64-bit value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
u64 Read64(VAddr addr);
|
|
|
|
|
2022-11-04 22:32:57 +00:00
|
|
|
/**
|
|
|
|
* Writes an 8-bit unsigned integer to the given virtual address in
|
|
|
|
* the current process' address space.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to write the 8-bit unsigned integer to.
|
|
|
|
* @param data The 8-bit unsigned integer to write to the given virtual address.
|
|
|
|
*
|
|
|
|
* @post The memory at the given virtual address contains the specified data value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
void Write8(VAddr addr, u8 data);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Writes a 16-bit unsigned integer to the given virtual address in
|
|
|
|
* the current process' address space.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to write the 16-bit unsigned integer to.
|
|
|
|
* @param data The 16-bit unsigned integer to write to the given virtual address.
|
|
|
|
*
|
|
|
|
* @post The memory range [addr, sizeof(data)) contains the given data value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
void Write16(VAddr addr, u16 data);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Writes a 32-bit unsigned integer to the given virtual address in
|
|
|
|
* the current process' address space.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to write the 32-bit unsigned integer to.
|
|
|
|
* @param data The 32-bit unsigned integer to write to the given virtual address.
|
|
|
|
*
|
|
|
|
* @post The memory range [addr, sizeof(data)) contains the given data value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
void Write32(VAddr addr, u32 data);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Writes a 64-bit unsigned integer to the given virtual address in
|
|
|
|
* the current process' address space.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to write the 64-bit unsigned integer to.
|
|
|
|
* @param data The 64-bit unsigned integer to write to the given virtual address.
|
|
|
|
*
|
|
|
|
* @post The memory range [addr, sizeof(data)) contains the given data value.
|
|
|
|
*/
|
2018-11-21 20:04:31 +00:00
|
|
|
void Write64(VAddr addr, u64 data);
|
|
|
|
|
2022-06-21 18:59:36 +00:00
|
|
|
/**
|
|
|
|
* Writes a {8, 16, 32, 64}-bit unsigned integer to the given virtual address in
|
|
|
|
* the current process' address space if and only if the address contains
|
|
|
|
* the expected value. This operation is atomic.
|
|
|
|
*
|
|
|
|
* @param addr The virtual address to write the X-bit unsigned integer to.
|
|
|
|
* @param data The X-bit unsigned integer to write to the given virtual address.
|
|
|
|
* @param expected The X-bit unsigned integer to check against the given virtual address.
|
|
|
|
* @returns true if the operation failed
|
|
|
|
*
|
|
|
|
* @post The memory range [addr, sizeof(data)) contains the given data value.
|
|
|
|
*/
|
|
|
|
bool WriteExclusive8(const VAddr addr, const u8 data, const u8 expected);
|
|
|
|
bool WriteExclusive16(const VAddr addr, const u16 data, const u16 expected);
|
|
|
|
bool WriteExclusive32(const VAddr addr, const u32 data, const u32 expected);
|
|
|
|
bool WriteExclusive64(const VAddr addr, const u64 data, const u64 expected);
|
|
|
|
|
2022-11-04 22:32:57 +00:00
|
|
|
/**
|
|
|
|
* Reads a null-terminated string from the given virtual address.
|
|
|
|
* This function will continually read characters until either:
|
|
|
|
*
|
|
|
|
* - A null character ('\0') is reached.
|
|
|
|
* - max_length characters have been read.
|
|
|
|
*
|
|
|
|
* @note The final null-terminating character (if found) is not included
|
|
|
|
* in the returned string.
|
|
|
|
*
|
|
|
|
* @param vaddr The address to begin reading the string from.
|
|
|
|
* @param max_length The maximum length of the string to read in characters.
|
|
|
|
*
|
|
|
|
* @returns The read string.
|
|
|
|
*/
|
|
|
|
std::string ReadCString(VAddr vaddr, std::size_t max_length);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads a contiguous block of bytes from a specified process' address space.
|
|
|
|
*
|
|
|
|
* @param process The process to read the data from.
|
|
|
|
* @param src_addr The virtual address to begin reading from.
|
|
|
|
* @param dest_buffer The buffer to place the read bytes into.
|
|
|
|
* @param size The amount of data to read, in bytes.
|
|
|
|
*
|
|
|
|
* @note If a size of 0 is specified, then this function reads nothing and
|
|
|
|
* no attempts to access memory are made at all.
|
|
|
|
*
|
|
|
|
* @pre dest_buffer must be at least size bytes in length, otherwise a
|
|
|
|
* buffer overrun will occur.
|
|
|
|
*
|
|
|
|
* @post The range [dest_buffer, size) contains the read bytes from the
|
|
|
|
* process' address space.
|
|
|
|
*/
|
2018-11-21 20:21:30 +00:00
|
|
|
void ReadBlock(const Kernel::Process& process, VAddr src_addr, void* dest_buffer,
|
|
|
|
std::size_t size);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Reads a contiguous block of bytes from the current process' address space.
|
|
|
|
*
|
|
|
|
* @param src_addr The virtual address to begin reading from.
|
|
|
|
* @param dest_buffer The buffer to place the read bytes into.
|
|
|
|
* @param size The amount of data to read, in bytes.
|
|
|
|
*
|
|
|
|
* @note If a size of 0 is specified, then this function reads nothing and
|
|
|
|
* no attempts to access memory are made at all.
|
|
|
|
*
|
|
|
|
* @pre dest_buffer must be at least size bytes in length, otherwise a
|
|
|
|
* buffer overrun will occur.
|
|
|
|
*
|
|
|
|
* @post The range [dest_buffer, size) contains the read bytes from the
|
|
|
|
* current process' address space.
|
|
|
|
*/
|
|
|
|
void ReadBlock(VAddr src_addr, void* dest_buffer, std::size_t size);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Writes a range of bytes into a given process' address space at the specified
|
|
|
|
* virtual address.
|
|
|
|
*
|
|
|
|
* @param process The process to write data into the address space of.
|
|
|
|
* @param dest_addr The destination virtual address to begin writing the data at.
|
|
|
|
* @param src_buffer The data to write into the process' address space.
|
|
|
|
* @param size The size of the data to write, in bytes.
|
|
|
|
*
|
|
|
|
* @post The address range [dest_addr, size) in the process' address space
|
|
|
|
* contains the data that was within src_buffer.
|
|
|
|
*
|
|
|
|
* @post If an attempt is made to write into an unmapped region of memory, the writes
|
|
|
|
* will be ignored and an error will be logged.
|
|
|
|
*
|
|
|
|
* @post If a write is performed into a region of memory that is considered cached
|
|
|
|
* rasterizer memory, will cause the currently active rasterizer to be notified
|
|
|
|
* and will mark that region as invalidated to caches that the active
|
|
|
|
* graphics backend may be maintaining over the course of execution.
|
|
|
|
*/
|
2018-11-21 20:21:30 +00:00
|
|
|
void WriteBlock(const Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
|
|
|
|
std::size_t size);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Writes a range of bytes into a given process' address space at the specified
|
|
|
|
* virtual address.
|
|
|
|
*
|
|
|
|
* @param dest_addr The destination virtual address to begin writing the data at.
|
|
|
|
* @param src_buffer The data to write into the process' address space.
|
|
|
|
* @param size The size of the data to write, in bytes.
|
|
|
|
*
|
|
|
|
* @post The address range [dest_addr, size) in the process' address space
|
|
|
|
* contains the data that was within src_buffer.
|
|
|
|
*
|
|
|
|
* @post If an attempt is made to write into an unmapped region of memory, the writes
|
|
|
|
* will be ignored and an error will be logged.
|
|
|
|
*
|
|
|
|
* @post If a write is performed into a region of memory that is considered cached
|
|
|
|
* rasterizer memory, will cause the currently active rasterizer to be notified
|
|
|
|
* and will mark that region as invalidated to caches that the active
|
|
|
|
* graphics backend may be maintaining over the course of execution.
|
|
|
|
*/
|
|
|
|
void WriteBlock(VAddr dest_addr, const void* src_buffer, std::size_t size);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Zeros a range of bytes within the current process' address space at the specified
|
|
|
|
* virtual address.
|
|
|
|
*
|
|
|
|
* @param process The process that will have data zeroed within its address space.
|
|
|
|
* @param dest_addr The destination virtual address to zero the data from.
|
|
|
|
* @param size The size of the range to zero out, in bytes.
|
|
|
|
*
|
|
|
|
* @post The range [dest_addr, size) within the process' address space contains the
|
|
|
|
* value 0.
|
|
|
|
*/
|
2018-11-21 20:21:30 +00:00
|
|
|
void ZeroBlock(const Kernel::Process& process, VAddr dest_addr, const std::size_t size);
|
2022-11-04 22:32:57 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Copies data within a process' address space to another location within the
|
|
|
|
* same address space.
|
|
|
|
*
|
|
|
|
* @param process The process that will have data copied within its address space.
|
|
|
|
* @param dest_addr The destination virtual address to begin copying the data into.
|
|
|
|
* @param src_addr The source virtual address to begin copying the data from.
|
|
|
|
* @param size The size of the data to copy, in bytes.
|
|
|
|
*
|
|
|
|
* @post The range [dest_addr, size) within the process' address space contains the
|
|
|
|
* same data within the range [src_addr, size).
|
|
|
|
*/
|
2018-11-21 20:21:30 +00:00
|
|
|
void CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
|
|
|
|
std::size_t size);
|
2019-04-19 18:15:05 +00:00
|
|
|
void CopyBlock(const Kernel::Process& dest_process, const Kernel::Process& src_process,
|
|
|
|
VAddr dest_addr, VAddr src_addr, std::size_t size);
|
2018-11-21 20:21:30 +00:00
|
|
|
|
2022-11-04 22:32:57 +00:00
|
|
|
/**
|
|
|
|
* Marks each page within the specified address range as cached or uncached.
|
|
|
|
*
|
|
|
|
* @param vaddr The virtual address indicating the start of the address range.
|
|
|
|
* @param size The size of the address range in bytes.
|
|
|
|
* @param cached Whether or not any pages within the address range should be
|
|
|
|
* marked as cached or uncached.
|
|
|
|
*/
|
|
|
|
void RasterizerMarkRegionCached(PAddr start, u32 size, bool cached);
|
2018-11-21 20:04:31 +00:00
|
|
|
|
2023-08-01 22:40:39 +00:00
|
|
|
/// For a rasterizer-accessible PAddr, gets a list of all possible VAddr
|
|
|
|
std::vector<VAddr> PhysicalToVirtualAddressForRasterizer(PAddr addr);
|
|
|
|
|
2020-04-28 19:43:52 +00:00
|
|
|
/// Gets a pointer to the memory region beginning at the specified physical address.
|
2023-07-09 11:07:28 +00:00
|
|
|
u8* GetPhysicalPointer(PAddr address) const;
|
2018-11-21 17:01:19 +00:00
|
|
|
|
2022-11-04 22:32:57 +00:00
|
|
|
/// Returns a reference to the memory region beginning at the specified physical address
|
2020-04-28 19:43:52 +00:00
|
|
|
MemoryRef GetPhysicalRef(PAddr address) const;
|
2020-01-04 22:39:54 +00:00
|
|
|
|
2022-11-04 22:32:57 +00:00
|
|
|
/// Determines if the given VAddr is valid for the specified process.
|
|
|
|
bool IsValidVirtualAddress(const Kernel::Process& process, VAddr vaddr);
|
2018-11-21 18:51:12 +00:00
|
|
|
|
2022-11-04 22:32:57 +00:00
|
|
|
/// Returns true if the address refers to a valid memory region
|
2020-04-28 19:43:52 +00:00
|
|
|
bool IsValidPhysicalAddress(PAddr paddr) const;
|
2018-11-21 17:01:19 +00:00
|
|
|
|
2018-11-21 03:52:44 +00:00
|
|
|
/// Gets offset in FCRAM from a pointer inside FCRAM range
|
2020-04-28 19:43:52 +00:00
|
|
|
u32 GetFCRAMOffset(const u8* pointer) const;
|
|
|
|
|
|
|
|
/// Gets pointer in FCRAM with given offset
|
|
|
|
u8* GetFCRAMPointer(std::size_t offset);
|
2018-11-21 20:04:31 +00:00
|
|
|
|
2018-12-01 22:46:18 +00:00
|
|
|
/// Gets pointer in FCRAM with given offset
|
2020-04-28 19:43:52 +00:00
|
|
|
const u8* GetFCRAMPointer(std::size_t offset) const;
|
2018-12-01 22:46:18 +00:00
|
|
|
|
2020-01-04 22:39:54 +00:00
|
|
|
/// Gets a serializable ref to FCRAM with the given offset
|
2020-04-28 19:43:52 +00:00
|
|
|
MemoryRef GetFCRAMRef(std::size_t offset) const;
|
2020-01-04 22:39:54 +00:00
|
|
|
|
2018-12-11 03:13:10 +00:00
|
|
|
/// Registers page table for rasterizer cache marking
|
2020-01-05 16:35:01 +00:00
|
|
|
void RegisterPageTable(std::shared_ptr<PageTable> page_table);
|
2018-12-11 03:13:10 +00:00
|
|
|
|
|
|
|
/// Unregisters page table for rasterizer cache marking
|
2020-01-05 16:35:01 +00:00
|
|
|
void UnregisterPageTable(std::shared_ptr<PageTable> page_table);
|
2018-12-11 03:13:10 +00:00
|
|
|
|
2019-02-04 02:33:20 +00:00
|
|
|
void SetDSP(AudioCore::DspInterface& dsp);
|
|
|
|
|
2018-11-21 20:04:31 +00:00
|
|
|
private:
|
|
|
|
template <typename T>
|
|
|
|
T Read(const VAddr vaddr);
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
void Write(const VAddr vaddr, const T data);
|
2018-11-21 21:18:23 +00:00
|
|
|
|
2022-06-21 18:59:36 +00:00
|
|
|
template <typename T>
|
|
|
|
bool WriteExclusive(const VAddr vaddr, const T data, const T expected);
|
|
|
|
|
2018-11-21 21:18:23 +00:00
|
|
|
/**
|
|
|
|
* Gets the pointer for virtual memory where the page is marked as RasterizerCachedMemory.
|
|
|
|
* This is used to access the memory where the page pointer is nullptr due to rasterizer cache.
|
|
|
|
* Since the cache only happens on linear heap or VRAM, we know the exact physical address and
|
|
|
|
* pointer of such virtual address
|
|
|
|
*/
|
2020-04-28 19:43:52 +00:00
|
|
|
MemoryRef GetPointerForRasterizerCache(VAddr addr) const;
|
2018-11-21 21:18:23 +00:00
|
|
|
|
2020-01-04 22:39:54 +00:00
|
|
|
void MapPages(PageTable& page_table, u32 base, u32 size, MemoryRef memory, PageType type);
|
2018-12-11 03:01:09 +00:00
|
|
|
|
2023-08-01 22:40:39 +00:00
|
|
|
private:
|
2018-12-01 22:46:18 +00:00
|
|
|
class Impl;
|
|
|
|
std::unique_ptr<Impl> impl;
|
2019-08-07 01:53:56 +00:00
|
|
|
|
|
|
|
friend class boost::serialization::access;
|
2019-12-27 21:07:29 +00:00
|
|
|
template <class Archive>
|
|
|
|
void serialize(Archive& ar, const unsigned int file_version);
|
2020-01-04 22:39:54 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
template <Region R>
|
|
|
|
class BackingMemImpl;
|
2018-11-21 03:38:47 +00:00
|
|
|
};
|
|
|
|
|
2017-07-22 02:17:57 +00:00
|
|
|
} // namespace Memory
|
2020-01-04 22:39:54 +00:00
|
|
|
|
|
|
|
BOOST_CLASS_EXPORT_KEY(Memory::MemorySystem::BackingMemImpl<Memory::Region::FCRAM>)
|
|
|
|
BOOST_CLASS_EXPORT_KEY(Memory::MemorySystem::BackingMemImpl<Memory::Region::VRAM>)
|
|
|
|
BOOST_CLASS_EXPORT_KEY(Memory::MemorySystem::BackingMemImpl<Memory::Region::DSP>)
|
|
|
|
BOOST_CLASS_EXPORT_KEY(Memory::MemorySystem::BackingMemImpl<Memory::Region::N3DS>)
|