RPCS3/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2026-10-12 02:09:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

vm: Fix confusing enum flags naming

Browse Source
This commit is contained in:
Elad
2026-09-26 13:17:00 +03:00
parent 13eaa2b03c
commit a70f698569
7 changed files with 36 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Utilities/bin_patch.cpp
+1 -1
View File
@@ -964,7 +964,7 @@ static usz apply_modification(std::vector<u32>& applied, patch_engine::patch_inf
const u32 alloc_size = utils::align(static_cast<u32>(p.value.long_value) + alloc_at % 4096, 4096);
// Allocate map if needed, if allocated flags will indicate that bit 62 is set (unique identifier)
auto alloc_map = vm::reserve_map(vm::any, alloc_at & -0x10000, utils::align(alloc_size, 0x10000), vm::page_size_64k | (1ull << 62));
auto alloc_map = vm::reserve_map(vm::any, alloc_at & -0x10000, utils::align(alloc_size, 0x10000), vm::block_size_64k | (1ull << 62));
u64 flags = vm::alloc_unwritable;
rpcs3/Emu/Cell/PPUModule.cpp
+4 -4
View File
@@ -2247,7 +2247,7 @@ bool ppu_load_exec(const ppu_exec_object& elf, bool virtual_load, const std::str
if (has_private_ppu_executable_area)
{
if (!vm::reserve_map(vm::any, 0x10000, 0x0FFF0000, vm::page_size_64k))
if (!vm::reserve_map(vm::any, 0x10000, 0x0FFF0000, vm::block_size_64k))
{
ppu_loader.error("ppu_load_exec(): Failed to map PPU_PRIVATE (sdk_version=0x%x)", sdk_version);
return false;
@@ -2258,7 +2258,7 @@ bool ppu_load_exec(const ppu_exec_object& elf, bool virtual_load, const std::str
if (is_vm_main_512)
{
if (!vm::reserve_map(vm::main, has_private_ppu_executable_area ? 0x10000000 : 0x10000, 0x1FFF0000 + (has_private_ppu_executable_area ? 0x10000 : 0), vm::page_size_64k))
if (!vm::reserve_map(vm::main, has_private_ppu_executable_area ? 0x10000000 : 0x10000, 0x1FFF0000 + (has_private_ppu_executable_area ? 0x10000 : 0), vm::block_size_64k))
{
ppu_loader.error("ppu_load_exec(): Failed to map vm::main (sdk_version=0x%x)", sdk_version);
return false;
@@ -2271,7 +2271,7 @@ bool ppu_load_exec(const ppu_exec_object& elf, bool virtual_load, const std::str
ppu_loader.error("ppu_load_exec(): Unexpected segments state, report to developers!");
}
if (!vm::reserve_map(vm::main, has_private_ppu_executable_area ? 0x10000000 : 0x10000, 0x0FFF0000 + (has_private_ppu_executable_area ? 0x10000 : 0), vm::page_size_64k))
if (!vm::reserve_map(vm::main, has_private_ppu_executable_area ? 0x10000000 : 0x10000, 0x0FFF0000 + (has_private_ppu_executable_area ? 0x10000 : 0), vm::block_size_64k))
{
ppu_loader.error("ppu_load_exec(): Failed to map vm::main (sdk_version=0x%x)", sdk_version);
return false;
@@ -2374,7 +2374,7 @@ bool ppu_load_exec(const ppu_exec_object& elf, bool virtual_load, const std::str
else if (![&]() -> bool
{
// 1M pages if it is RSX shared
const u32 area_flags = (_seg.flags >> 28) ? vm::page_size_1m : vm::page_size_64k;
const u32 area_flags = (_seg.flags >> 28) ? vm::block_size_1m : vm::block_size_64k;
const u32 alloc_at = has_private_ppu_executable_area && addr >= 0x10000000 ? 0x10000000 : std::max<u32>(addr & -0x10000000, 0x10000);
const auto area = vm::reserve_map(vm::any, alloc_at, 0x10000000, area_flags);
rpcs3/Emu/Cell/RawSPUThread.cpp
+2 -2
View File
@@ -495,7 +495,7 @@ void spu_load_exec(const spu_exec_object& elf)
spu_thread::g_raw_spu_ctr++;
auto spu = idm::make_ptr<named_thread<spu_thread>>(nullptr, 0, "test_spu", 0);
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, vm::page_size_64k));
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, vm::block_size_64k));
spu->map_ls(*spu->shm, spu->ls);
for (const auto& prog : elf.progs)
@@ -556,7 +556,7 @@ void spu_load_rel_exec(const spu_rel_object& elf)
spu_thread::g_raw_spu_ctr++;
auto spu = idm::make_ptr<named_thread<spu_thread>>(nullptr, 0, "test_spu", 0);
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, vm::page_size_64k));
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, vm::block_size_64k));
spu->map_ls(*spu->shm, spu->ls);
u32 total_memsize = 0;
rpcs3/Emu/Cell/lv2/sys_memory.cpp
+1 -1
View File
@@ -107,7 +107,7 @@ struct sys_memory_address_table
{
constexpr u32 _256mb = 0x10000000;
const auto location = align == 0x10000 ? vm::user64k : vm::user1m;
const u64 flags = (align == 0x10000 ? vm::page_size_64k : vm::page_size_1m) | vm::bf0_0x1;
const u64 flags = (align == 0x10000 ? vm::block_size_64k : vm::block_size_1m) | vm::bf0_0x1;
const u32 area_size = utils::align(size, _256mb);
const auto area = vm::reserve_map(location, 0, area_size, flags);
rpcs3/Emu/Cell/lv2/sys_spu.cpp
+3 -3
View File
@@ -867,7 +867,7 @@ error_code sys_spu_thread_initialize(ppu_thread& ppu, vm::ptr<u32> thread, u32 g
// alloc_hidden indicates falloc to allocate page with no access rights in base memory
auto& spu = group->threads[inited];
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, static_cast<u64>(vm::page_size_64k) | static_cast<u64>(vm::alloc_hidden)));
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, static_cast<u64>(vm::block_size_64k) | static_cast<u64>(vm::alloc_hidden)));
spu->map_ls(*spu->shm, spu->ls);
group->args[inited] = {args.arg1, args.arg2, args.arg3, args.arg4};
@@ -2484,7 +2484,7 @@ error_code sys_raw_spu_create(ppu_thread& ppu, vm::ptr<u32> id, vm::ptr<void> at
}
const auto spu = idm::make_ptr<named_thread<spu_thread>>(nullptr, index, "", index);
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, vm::page_size_64k));
ensure(vm::get(vm::spu)->falloc(spu->vm_offset(), SPU_LS_SIZE, &spu->shm, vm::block_size_64k));
spu->map_ls(*spu->shm, spu->ls);
spu_thread::g_raw_spu_id[index] = idm::last_id();
@@ -2543,7 +2543,7 @@ error_code sys_isolated_spu_create(ppu_thread& ppu, vm::ptr<u32> id, vm::ptr<voi
const auto thread = idm::make_ptr<named_thread<spu_thread>>(nullptr, index, "", index, true);
ensure(vm::get(vm::spu)->falloc(thread->vm_offset(), SPU_LS_SIZE, &thread->shm, vm::page_size_64k));
ensure(vm::get(vm::spu)->falloc(thread->vm_offset(), SPU_LS_SIZE, &thread->shm, vm::block_size_64k));
thread->map_ls(*thread->shm, thread->ls);
thread->gpr[3] = v128::from64(0, arg1);
rpcs3/Emu/Memory/vm.cpp
+20 -20
View File
@@ -744,7 +744,7 @@ namespace vm
}
// If native page size exceeds 4096, don't map native pages (expected to be always mapped in this case)
const bool is_noop = bflags & page_size_4k && utils::get_page_size() > 4096;
const bool is_noop = bflags & block_size_4k && utils::get_page_size() > 4096;
// Lock range being mapped
auto range_lock = _lock_main_range_lock(range_allocation, addr, size);
@@ -959,7 +959,7 @@ namespace vm
}
// If native page size exceeds 4096, don't unmap native pages (always mapped)
const bool is_noop = bflags & page_size_4k && utils::get_page_size() > 4096;
const bool is_noop = bflags & block_size_4k && utils::get_page_size() > 4096;
// Determine deallocation size
u32 size = 0;
@@ -1197,11 +1197,11 @@ namespace vm
flags |= page_executable;
}
if ((bflags & page_size_mask) == page_size_64k)
if ((bflags & block_size_mask) == block_size_64k)
{
flags |= page_64k_size;
}
else if (!(bflags & (page_size_mask & ~page_size_1m)))
else if (!(bflags & (block_size_mask & ~block_size_1m)))
{
flags |= page_1m_size;
}
@@ -1221,7 +1221,7 @@ namespace vm
std::remove_reference_t<decltype(map)>::value_type* result = nullptr;
// Check eligibility
if (!_this || !(page_size_mask & _this->flags) || _this->addr < 0x20000000 || _this->addr >= 0xC0000000)
if (!_this || !(block_size_mask & _this->flags) || _this->addr < 0x20000000 || _this->addr >= 0xC0000000)
{
return result;
}
@@ -1269,12 +1269,12 @@ namespace vm
static constexpr u64 process_block_flags(u64 flags)
{
if ((flags & page_size_mask) == 0)
if ((flags & block_size_mask) == 0)
{
flags |= page_size_1m;
flags |= block_size_1m;
}
if (flags & page_size_4k)
if (flags & block_size_4k)
{
flags |= preallocated;
}
@@ -1318,7 +1318,7 @@ namespace vm
// Special path for whole-allocated areas allowing 4k granularity
m_common = std::make_shared<utils::shm>(size, fmt::format("_block_x%08x", addr));
if (!map_critical(vm::_ptr<u8>(addr), this->flags & page_size_4k && utils::get_page_size() > 4096 ? utils::protection::rw : utils::protection::no) || !map_critical(vm::get_super_ptr(addr), utils::protection::rw))
if (!map_critical(vm::_ptr<u8>(addr), this->flags & block_size_4k && utils::get_page_size() > 4096 ? utils::protection::rw : utils::protection::no) || !map_critical(vm::get_super_ptr(addr), utils::protection::rw))
{
fmt::throw_exception("Memory mapping failed (addr=0x%x, size=0x%x, flags=0x%x): %s", addr, size, flags, map_error);
}
@@ -1419,7 +1419,7 @@ namespace vm
}
// Determine minimal alignment
const u32 min_page_size = flags & page_size_4k ? 0x1000 : 0x10000;
const u32 min_page_size = flags & block_size_4k ? 0x1000 : 0x10000;
// Align to minimal page size
const u32 size = utils::align(orig_size, min_page_size) + (flags & stack_guarded ? 0x2000 : 0);
@@ -1491,7 +1491,7 @@ namespace vm
}
// Determine minimal alignment
const u32 min_page_size = flags & page_size_4k ? 0x1000 : 0x10000;
const u32 min_page_size = flags & block_size_4k ? 0x1000 : 0x10000;
// Take address misalignment into account
const u32 size0 = orig_size + addr % min_page_size;
@@ -1839,7 +1839,7 @@ namespace vm
if (flags & preallocated)
{
m_common = std::make_shared<utils::shm>(size, fmt::format("_block_x%08x", addr));
m_common->map_critical(vm::base(addr), this->flags & page_size_4k && utils::get_page_size() > 4096 ? utils::protection::rw : utils::protection::no);
m_common->map_critical(vm::base(addr), this->flags & block_size_4k && utils::get_page_size() > 4096 ? utils::protection::rw : utils::protection::no);
m_common->map_critical(vm::get_super_ptr(addr));
}
@@ -1875,13 +1875,13 @@ namespace vm
pflags |= alloc_hidden;
}
if ((flags & page_size_64k) == page_size_64k)
if ((flags & block_size_64k) == block_size_64k)
{
pflags |= page_size_64k;
pflags |= block_size_64k;
}
else if (!(flags & (page_size_mask & ~page_size_1m)))
else if (!(flags & (block_size_mask & ~block_size_1m)))
{
pflags |= page_size_1m;
pflags |= block_size_1m;
}
// Map the memory through the same method as alloc() and falloc()
@@ -2129,7 +2129,7 @@ namespace vm
if (location == vm::main || addr == 0x00010000)
{
// Special
loc = std::make_shared<block_t>(addr, area_size, page_size_64k | preallocated);
loc = std::make_shared<block_t>(addr, area_size, block_size_64k | preallocated);
}
else
{
@@ -2287,9 +2287,9 @@ namespace vm
nullptr, // user 64k pages
nullptr, // user 1m pages
nullptr, // rsx context
std::make_shared<block_t>(0xC0000000, 0x10000000, page_size_64k | preallocated), // video
std::make_shared<block_t>(0xD0000000, 0x10000000, page_size_4k | preallocated | stack_guarded | bf0_0x1), // stack
std::make_shared<block_t>(0xE0000000, 0x20000000, page_size_64k), // SPU reserved
std::make_shared<block_t>(0xC0000000, 0x10000000, block_size_64k | preallocated), // video
std::make_shared<block_t>(0xD0000000, 0x10000000, block_size_4k | preallocated | stack_guarded | bf0_0x1), // stack
std::make_shared<block_t>(0xE0000000, 0x20000000, block_size_64k), // SPU reserved
};
std::memset(g_reservations, 0, sizeof(g_reservations));
rpcs3/Emu/Memory/vm.h
+5 -5
View File
@@ -121,10 +121,10 @@ namespace vm
enum block_flags_3
{
page_size_4k = 0x100, // SYS_MEMORY_PAGE_SIZE_4K
page_size_64k = 0x200, // SYS_MEMORY_PAGE_SIZE_64K
page_size_1m = 0x400, // SYS_MEMORY_PAGE_SIZE_1M
page_size_mask = 0xF00, // SYS_MEMORY_PAGE_SIZE_MASK
block_size_4k = 0x100, // SYS_MEMORY_PAGE_SIZE_4K
block_size_64k = 0x200, // SYS_MEMORY_PAGE_SIZE_64K
block_size_1m = 0x400, // SYS_MEMORY_PAGE_SIZE_1M
block_size_mask = 0xF00, // SYS_MEMORY_PAGE_SIZE_MASK
stack_guarded = 0x10,
preallocated = 0x20, // nonshareable
@@ -222,7 +222,7 @@ namespace vm
std::shared_ptr<block_t> get(memory_location_t location, u32 addr = 0);
// Allocate segment at specified location, does nothing if exists already
std::shared_ptr<block_t> reserve_map(memory_location_t location, u32 addr, u32 area_size, u64 flags = page_size_64k);
std::shared_ptr<block_t> reserve_map(memory_location_t location, u32 addr, u32 area_size, u64 flags = block_size_64k);
// Get PS3 virtual memory address from the provided pointer (nullptr or pointer from outside is always converted to 0)
// Super memory is allowed as well