Memory mirror support

Implemented utils::memory_release (not used)
Implemented utils::shm class (handler for shared memory)
Improved sys_mmapper syscalls
Rewritten ppu_patch function
Implemented vm::get_super_ptr (ignores memory protection)
Minimal allocation alignment increased to 0x10000

Utilities/VirtualMemory.cpp

@@ -76,13 +76,145 @@ namespace utils
 #endif
 	}
 
+	void memory_release(void* pointer, std::size_t size)
+	{
+#ifdef _WIN32
+		verify(HERE), ::VirtualFree(pointer, 0, MEM_RELEASE);
+#else
+		verify(HERE), ::munmap(pointer, size) != -1;
+#endif
+	}
+
 	void memory_protect(void* pointer, std::size_t size, protection prot)
 	{
 #ifdef _WIN32
 		DWORD old;
 		verify(HERE), ::VirtualProtect(pointer, size, +prot, &old);
 #else
 		verify(HERE), ::mprotect((void*)((u64)pointer & -4096), ::align(size, 4096), +prot) != -1;
+#endif
+	}
+
+	shm::shm(u32 size)
+		: m_size(::align(size, 0x10000))
+		, m_ptr(nullptr)
+	{
+#ifdef _WIN32
+		m_handle = ::CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE, 0, m_size, NULL);
+//#elif __linux__
+//		m_file = ::memfd_create("mem1", 0);
+//		::ftruncate(m_file, m_size);
+#else
+		while ((m_file = ::shm_open("/rpcs3-mem1", O_RDWR | O_CREAT | O_EXCL, S_IWUSR | S_IRUSR)) == -1)
+		{
+			if (errno != EEXIST)
+				return;
+		}
+
+		::shm_unlink("/rpcs3-mem1");
+		::ftruncate(m_file, m_size);
+#endif
+
+		m_ptr = this->map(nullptr);
+	}
+
+	shm::~shm()
+	{
+#ifdef _WIN32
+		::UnmapViewOfFile(m_ptr);
+		::CloseHandle(m_handle);
+#else
+		::munmap(m_ptr, m_size);
+		::close(m_file);
+#endif
+	}
+
+	u8* shm::map(void* ptr, protection prot) const
+	{
+#ifdef _WIN32
+		DWORD access = 0;
+		switch (prot)
+		{
+		case protection::rw: access = FILE_MAP_WRITE; break;
+		case protection::ro: access = FILE_MAP_READ; break;
+		case protection::no: break;
+		case protection::wx: access = FILE_MAP_WRITE | FILE_MAP_EXECUTE; break;
+		case protection::rx: access = FILE_MAP_READ | FILE_MAP_EXECUTE; break;
+		}
+
+		return static_cast<u8*>(::MapViewOfFileEx(m_handle, access, 0, 0, m_size, ptr));
+#else
+		return static_cast<u8*>(::mmap((void*)((u64)ptr & -0x10000), m_size, +prot, MAP_SHARED | (ptr ? MAP_FIXED : 0), m_file, 0));
+#endif
+	}
+
+	u8* shm::map_critical(void* ptr, protection prot)
+	{
+		const auto target = (u8*)((u64)ptr & -0x10000);
+
+#ifdef _WIN32
+		::MEMORY_BASIC_INFORMATION mem;
+		if (!::VirtualQuery(target, &mem, sizeof(mem)) || mem.State != MEM_RESERVE || !::VirtualFree(mem.AllocationBase, 0, MEM_RELEASE))
+		{
+			return nullptr;
+		}
+
+		const auto base = (u8*)mem.AllocationBase;
+		const auto size = mem.RegionSize + (target - base);
+
+		if (base < target && !::VirtualAlloc(base, target - base, MEM_RESERVE, PAGE_NOACCESS))
+		{
+			return nullptr;
+		}
+
+		if (target + m_size < base + size && !::VirtualAlloc(target + m_size, base + size - target - m_size, MEM_RESERVE, PAGE_NOACCESS))
+		{
+			return nullptr;
+		}
+#endif
+
+		return this->map(target, prot);
+	}
+
+	void shm::unmap(void* ptr) const
+	{
+#ifdef _WIN32
+		::UnmapViewOfFile(ptr);
+#else
+		::munmap(ptr, m_size);
+#endif
+	}
+
+	void shm::unmap_critical(void* ptr)
+	{
+		const auto target = (u8*)((u64)ptr & -0x10000);
+
+		this->unmap(target);
+
+#ifdef _WIN32
+		::MEMORY_BASIC_INFORMATION mem, mem2;
+		if (!::VirtualQuery(target - 1, &mem, sizeof(mem)) || !::VirtualQuery(target + m_size, &mem2, sizeof(mem2)))
+		{
+			return;
+		}
+
+		if (mem.State == MEM_RESERVE && !::VirtualFree(mem.AllocationBase, 0, MEM_RELEASE))
+		{
+			return;
+		}
+
+		if (mem2.State == MEM_RESERVE && !::VirtualFree(mem2.AllocationBase, 0, MEM_RELEASE))
+		{
+			return;
+		}
+
+		const auto size1 = mem.State == MEM_RESERVE ? target - (u8*)mem.AllocationBase : 0;
+		const auto size2 = mem2.State == MEM_RESERVE ? mem2.RegionSize : 0;
+
+		if (!::VirtualAlloc(mem.State == MEM_RESERVE ? mem.AllocationBase : target, m_size + size1 + size2, MEM_RESERVE, PAGE_NOACCESS))
+		{
+			return;
+		}
 #endif
 	}
 }

Utilities/VirtualMemory.h

@@ -30,6 +30,56 @@ namespace utils
 	*/
 	void memory_decommit(void* pointer, std::size_t size);
 
+	// Free memory after reserved by memory_reserve, should specify original size
+	void memory_release(void* pointer, std::size_t size);
+
 	// Set memory protection
 	void memory_protect(void* pointer, std::size_t size, protection prot);
+
+	// Shared memory handle
+	class shm
+	{
+#ifdef _WIN32
+		void* m_handle;
+#else
+		int m_file;
+#endif
+		u32 m_size;
+		u8* m_ptr;
+
+	public:
+		explicit shm(u32 size);
+
+		shm(const shm&) = delete;
+
+		~shm();
+
+		// Map shared memory
+		u8* map(void* ptr, protection prot = protection::rw) const;
+
+		// Map shared memory over reserved memory region, which is unsafe (non-atomic) under Win32
+		u8* map_critical(void* ptr, protection prot = protection::rw);
+
+		// Unmap shared memory
+		void unmap(void* ptr) const;
+
+		// Unmap shared memory, undoing map_critical
+		void unmap_critical(void* ptr);
+
+		// Access memory with simple range check
+		u8* get(u32 offset, u32 size) const
+		{
+			if (offset >= m_size || m_size - offset < size)
+			{
+				return nullptr;
+			}
+
+			return m_ptr + offset;
+		}
+
+		u32 size() const
+		{
+			return m_size;
+		}
+	};
 }

rpcs3/Emu/Cell/Modules/sys_heap.cpp

@@ -48,7 +48,7 @@ u32 _sys_heap_memalign(u32 heap, u32 align, u32 size)
 {
 	sysPrxForUser.warning("_sys_heap_memalign(heap=0x%x, align=0x%x, size=0x%x)", heap, align, size);
 
-	return vm::alloc(size, vm::main, std::max<u32>(align, 4096));
+	return vm::alloc(size, vm::main, std::max<u32>(align, 0x10000));
 }
 
 s32 _sys_heap_free(u32 heap, u32 addr)

rpcs3/Emu/Cell/Modules/sys_libc_.cpp

@@ -381,7 +381,7 @@ u32 _sys_memalign(u32 align, u32 size)
 {
 	sysPrxForUser.warning("_sys_memalign(align=0x%x, size=0x%x)", align, size);
 
-	return vm::alloc(size, vm::main, std::max<u32>(align, 4096));
+	return vm::alloc(size, vm::main, std::max<u32>(align, 0x10000));
 }
 
 s32 _sys_free(u32 addr)

rpcs3/Emu/Cell/PPUModule.cpp

@@ -330,7 +330,7 @@ static void ppu_initialize_modules(const std::shared_ptr<ppu_linkage_info>& link
 			// Allocate HLE variable
 			if (variable.second.size >= 4096 || variable.second.align >= 4096)
 			{
-				variable.second.addr = vm::alloc(variable.second.size, vm::main, std::max<u32>(variable.second.align, 4096));
+				variable.second.addr = vm::alloc(variable.second.size, vm::main, std::max<u32>(variable.second.align, 0x10000));
 			}
 			else
 			{

rpcs3/Emu/Cell/PPUThread.cpp

@@ -400,39 +400,32 @@ extern void ppu_remove_breakpoint(u32 addr)
 
 extern bool ppu_patch(u32 addr, u32 value)
 {
-	// TODO: check executable flag
-	if (vm::check_addr(addr, sizeof(u32)))
+	if (g_cfg.core.ppu_decoder == ppu_decoder_type::llvm && Emu.GetStatus() != system_state::ready)
 	{
-		if (g_cfg.core.ppu_decoder == ppu_decoder_type::llvm && Emu.GetStatus() != system_state::ready)
-		{
-			// TODO
-			return false;
-		}
-
-		if (!vm::check_addr(addr, sizeof(u32), vm::page_writable))
-		{
-			utils::memory_protect(vm::g_base_addr + addr, sizeof(u32), utils::protection::rw);
-		}
+		// TODO: support recompilers
+		LOG_FATAL(GENERAL, "Patch failed at 0x%x: LLVM recompiler is used.", addr);
+		return false;
+	}
 
-		vm::write32(addr, value);
+	const auto ptr = vm::get_super_ptr<u32>(addr);
 
-		const u32 _break = ::narrow<u32>(reinterpret_cast<std::uintptr_t>(&ppu_break));
-		const u32 fallback = ::narrow<u32>(reinterpret_cast<std::uintptr_t>(&ppu_fallback));
+	if (!ptr)
+	{
+		LOG_FATAL(GENERAL, "Patch failed at 0x%x: invalid memory address.", addr);
+		return false;
+	}
 
-		if (ppu_ref(addr) != _break && ppu_ref(addr) != fallback)
-		{
-			ppu_ref(addr) = ppu_cache(addr);
-		}
+	*ptr = value;
 
-		if (!vm::check_addr(addr, sizeof(u32), vm::page_writable))
-		{
-			utils::memory_protect(vm::g_base_addr + addr, sizeof(u32), utils::protection::ro);
-		}
+	const u32 _break = ::narrow<u32>(reinterpret_cast<std::uintptr_t>(&ppu_break));
+	const u32 fallback = ::narrow<u32>(reinterpret_cast<std::uintptr_t>(&ppu_fallback));
 
-		return true;
+	if (ppu_ref(addr) != _break && ppu_ref(addr) != fallback)
+	{
+		ppu_ref(addr) = ppu_cache(addr);
 	}
 
-	return false;
+	return true;
 }
 
 std::string ppu_thread::get_name() const