mirrors/rpcs3
0
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-08-13 11:39:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Use utils::memory_protect

Browse source
This commit is contained in:
Nekotekina 2017-03-13 13:15:08 +03:00
commit 78703cfe47
5 changed files with 26 additions and 41 deletions
Download patch file Download diff file Expand all files Collapse all files

2
rpcs3/Emu/Memory/vm.cpp
View file

@ -344,7 +344,7 @@ namespace vm
bool page_protect(u32 addr, u32 size, u8 flags_test, u8 flags_set, u8 flags_clear) 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) if (!size || (size | addr) % 4096)
{ {

7
rpcs3/Emu/RSX/D3D12/D3D12MemoryHelpers.cpp
View file

@ -2,6 +2,7 @@
#include "stdafx.h" #include "stdafx.h"
#include "stdafx_d3d12.h" #include "stdafx_d3d12.h"
#include "D3D12MemoryHelpers.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) 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_start = start & ~(memory_page_size - 1);
u32 protected_range_size = (u32)align(size, memory_page_size); 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)); 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) bool data_cache::invalidate_address(u32 addr)
@ -38,7 +39,7 @@ bool data_cache::invalidate_address(u32 addr)
u64 texadrr = std::get<0>(protectedTexture); u64 texadrr = std::get<0>(protectedTexture);
m_address_to_data[texadrr].first.m_is_dirty = true; 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); m_protected_ranges.erase(currentIt);
handled = true; handled = true;
} }
@ -61,7 +62,7 @@ void data_cache::unprotect_all()
for (auto &protectedTexture : m_protected_ranges) for (auto &protectedTexture : m_protected_ranges)
{ {
u32 protectedRangeStart = std::get<1>(protectedTexture), protectedRangeSize = std::get<2>(protectedTexture); 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);
} }
} }

20
rpcs3/Emu/RSX/GL/GLTextureCache.h
View file

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

2
rpcs3/Emu/RSX/VK/VKTextureCache.h
View file

@ -289,7 +289,7 @@ namespace vk
region.reset(texaddr, range); region.reset(texaddr, range);
region.create(tex.width(), height, depth, tex.get_exact_mipmap_count(), view, image); 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); region.set_dirty(false);
texture_cache_range = region.get_min_max(texture_cache_range); texture_cache_range = region.get_min_max(texture_cache_range);

36
rpcs3/Emu/RSX/rsx_cache.h
View file

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