Use utils::memory_protect

rpcs3/Emu/Memory/vm.cpp

@@ -344,7 +344,7 @@ namespace vm
 
 	bool page_protect(u32 addr, u32 size, u8 flags_test, u8 flags_set, u8 flags_clear)
 	{
-		writer_lock lock(0);
+		writer_lock lock;
 
 		if (!size || (size | addr) % 4096)
 		{

rpcs3/Emu/RSX/D3D12/D3D12MemoryHelpers.cpp

@@ -2,6 +2,7 @@
 #include "stdafx.h"
 #include "stdafx_d3d12.h"
 #include "D3D12MemoryHelpers.h"
+#include "Utilities/VirtualMemory.h"
 
 
 void data_cache::store_and_protect_data(u64 key, u32 start, size_t size, u8 format, size_t w, size_t h, size_t d, size_t m, ComPtr<ID3D12Resource> data)
@@ -18,7 +19,7 @@ void data_cache::protect_data(u64 key, u32 start, size_t size)
 	u32 protected_range_start = start & ~(memory_page_size - 1);
 	u32 protected_range_size = (u32)align(size, memory_page_size);
 	m_protected_ranges.push_back(std::make_tuple(key, protected_range_start, protected_range_size));
-	vm::page_protect(protected_range_start, protected_range_size, 0, 0, vm::page_writable);
+	utils::memory_protect(vm::base(protected_range_start), protected_range_size, utils::protection::ro);
 }
 
 bool data_cache::invalidate_address(u32 addr)
@@ -38,7 +39,7 @@ bool data_cache::invalidate_address(u32 addr)
 			u64 texadrr = std::get<0>(protectedTexture);
 			m_address_to_data[texadrr].first.m_is_dirty = true;
 
-			vm::page_protect(protectedRangeStart, protectedRangeSize, 0, vm::page_writable, 0);
+			utils::memory_protect(vm::base(protectedRangeStart), protectedRangeSize, utils::protection::rw);
 			m_protected_ranges.erase(currentIt);
 			handled = true;
 		}
@@ -61,7 +62,7 @@ void data_cache::unprotect_all()
 	for (auto &protectedTexture : m_protected_ranges)
 	{
 		u32 protectedRangeStart = std::get<1>(protectedTexture), protectedRangeSize = std::get<2>(protectedTexture);
-		vm::page_protect(protectedRangeStart, protectedRangeSize, 0, vm::page_writable, 0);
+		utils::memory_protect(vm::base(protectedRangeStart), protectedRangeSize, utils::protection::rw);
 	}
 }
 

rpcs3/Emu/RSX/GL/GLTextureCache.h

@@ -328,12 +328,12 @@ namespace gl
 					if (!copied)
 					{
 						LOG_WARNING(RSX, "Nothing to copy; Setting section to readable and moving on...");
-						protect(vm::page_readable, 0);
+						protect(utils::protection::ro);
 						return;
 					}
 				}
 
-				protect(vm::page_writable, 0);
+				protect(utils::protection::rw);
 				m_fence.wait_for_signal();
 				flushed = true;
 
@@ -385,7 +385,7 @@ namespace gl
 
 				glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
 				glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
-				protect(vm::page_readable, vm::page_writable);
+				protect(utils::protection::ro);
 			}
 
 			void destroy()
@@ -506,7 +506,7 @@ namespace gl
 					if (rtt.is_dirty())
 					{
 						rtt.reset(base, size);
-						rtt.protect(0, vm::page_readable | vm::page_writable);
+						rtt.protect(utils::protection::no);
 						region = &rtt;
 						break;
 					}
@@ -517,7 +517,7 @@ namespace gl
 					cached_rtt_section section;
 					section.reset(base, size);
 					section.set_dirty(true);
-					section.protect(0, vm::page_readable | vm::page_writable);
+					section.protect(utils::protection::no);
 
 					m_rtt_cache.push_back(section);
 					region = &m_rtt_cache.back();
@@ -535,7 +535,9 @@ namespace gl
 				}
 
 				if (!region->is_locked() || region->is_flushed())
-					region->protect(0, vm::page_readable | vm::page_writable);
+				{
+					region->protect(utils::protection::no);
+				}
 			}
 
 			return region;
@@ -707,7 +709,7 @@ namespace gl
 			std::lock_guard<std::mutex> lock(m_section_mutex);
 
 			cached_texture_section &cached = create_texture(gl_texture.id(), texaddr, get_texture_size(tex), tex.width(), tex.height(), tex.get_exact_mipmap_count());
-			cached.protect(0, vm::page_writable);
+			cached.protect(utils::protection::ro);
 			cached.set_dirty(false);
 
 			//external gl::texture objects should always be undefined/uninitialized!
@@ -731,7 +733,7 @@ namespace gl
 				verify(HERE), region->is_dirty();
 				LOG_WARNING(RSX, "Cell write to bound render target area");
 
-				region->protect(0, vm::page_writable | vm::page_readable);
+				region->protect(utils::protection::no);
 				region->set_dirty(false);
 			}
 
@@ -751,7 +753,7 @@ namespace gl
 					region->unprotect();
 
 				region->reset(base, size);
-				region->protect(0, vm::page_readable | vm::page_writable);
+				region->protect(utils::protection::no);
 			}
 
 			region->set_dimensions(width, height, pitch);

rpcs3/Emu/RSX/VK/VKTextureCache.h

@@ -289,7 +289,7 @@ namespace vk
 
 			region.reset(texaddr, range);
 			region.create(tex.width(), height, depth, tex.get_exact_mipmap_count(), view, image);
-			region.protect(0, vm::page_writable);
+			region.protect(utils::protection::ro);
 			region.set_dirty(false);
 
 			texture_cache_range = region.get_min_max(texture_cache_range);

rpcs3/Emu/RSX/rsx_cache.h

@@ -1,5 +1,6 @@
 #pragma once
 #include <rsx_decompiler.h>
+#include "Utilities/VirtualMemory.h"
 #include "Emu/Memory/vm.h"
 
 namespace rsx
@@ -75,7 +76,7 @@ namespace rsx
 		u32 locked_address_base = 0;
 		u32 locked_address_range = 0;
 
-		u32 memory_protection = 0;
+		utils::protection protection = utils::protection::rw;
 
 		bool locked = false;
 		bool dirty = false;
@@ -117,40 +118,21 @@ namespace rsx
 			locked_address_base = (base & ~4095);
 			locked_address_range = align(base + length, 4096) - locked_address_base;
 
-			memory_protection = vm::page_readable | vm::page_writable;
+			protection = utils::protection::rw;
 
 			locked = false;
 		}
 
-		bool protect(u8 flags_set, u8 flags_clear)
+		void protect(utils::protection prot)
 		{
-			if (vm::page_protect(locked_address_base, locked_address_range, 0, flags_set, flags_clear))
-			{
-				memory_protection &= ~flags_clear;
-				memory_protection |= flags_set;
-
-				locked = memory_protection != (vm::page_readable | vm::page_writable);
-			}
-			else
-				fmt::throw_exception("failed to lock memory @ 0x%X!", locked_address_base);
-
-			return false;
+			utils::memory_protect(vm::base(locked_address_base), locked_address_range, prot);
+			protection = prot;
+			locked = prot != utils::protection::rw;
 		}
 
-		bool unprotect()
+		void unprotect()
 		{
-			u32 flags_set = (vm::page_readable | vm::page_writable) & ~memory_protection;
-
-			if (vm::page_protect(locked_address_base, locked_address_range, 0, flags_set, 0))
-			{
-				memory_protection = (vm::page_writable | vm::page_readable);
-				locked = false;
-				return true;
-			}
-			else
-				fmt::throw_exception("failed to unlock memory @ 0x%X!", locked_address_base);
-
-			return false;
+			return protect(utils::protection::rw);
 		}
 
 		bool overlaps(std::pair<u32, u32> range)