Just a bunch of fixups

Utilities/JIT.cpp

@@ -88,9 +88,7 @@ static u8* add_jit_memory(std::size_t size, uint align)
 
 	if (olda != newa) [[unlikely]]
 	{
-#ifdef CAN_OVERCOMMIT
-		madvise(pointer + olda, newa - olda, MADV_WILLNEED);
-#else
+#ifndef CAN_OVERCOMMIT
 		// Commit more memory
 		utils::memory_commit(pointer + olda, newa - olda, Prot);
 #endif

Utilities/Thread.cpp

@@ -74,6 +74,7 @@
 
 #include "sync.h"
 #include "util/logs.hpp"
+#include "Emu/Memory/vm_locking.h"
 
 LOG_CHANNEL(sig_log, "SIG");
 LOG_CHANNEL(sys_log, "SYS");

Utilities/VirtualMemory.cpp

@@ -112,6 +112,7 @@ namespace utils
 #else
 		const u64 ptr64 = reinterpret_cast<u64>(pointer);
 		verify(HERE), ::mprotect(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), +prot) != -1;
+		verify(HERE), ::madvise(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), MADV_WILLNEED) != -1;
 #endif
 	}
 
@@ -120,7 +121,13 @@ namespace utils
 #ifdef _WIN32
 		verify(HERE), ::VirtualFree(pointer, size, MEM_DECOMMIT);
 #else
+		const u64 ptr64 = reinterpret_cast<u64>(pointer);
 		verify(HERE), ::mmap(pointer, size, PROT_NONE, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0) != reinterpret_cast<void*>(-1);
+#ifdef MADV_FREE
+		verify(HERE), ::madvise(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), MADV_FREE) != -1;
+#else
+		verify(HERE), ::madvise(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), MADV_DONTNEED) != -1;
+#endif
 #endif
 	}
 
@@ -130,7 +137,14 @@ namespace utils
 		memory_decommit(pointer, size);
 		memory_commit(pointer, size, prot);
 #else
+		const u64 ptr64 = reinterpret_cast<u64>(pointer);
+#ifdef MADV_FREE
+		verify(HERE), ::madvise(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), MADV_FREE) != -1;
+#else
+		verify(HERE), ::madvise(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), MADV_DONTNEED) != -1;
+#endif
 		verify(HERE), ::mmap(pointer, size, +prot, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0) != reinterpret_cast<void*>(-1);
+		verify(HERE), ::madvise(reinterpret_cast<void*>(ptr64 & -4096), size + (ptr64 & 4095), MADV_WILLNEED) != -1;
 #endif
 	}
 
@@ -178,7 +192,9 @@ namespace utils
 		verify(HERE), m_file >= 0;
 		verify(HERE), ::ftruncate(m_file, m_size) >= 0;
 #else
-		while ((m_file = ::shm_open("/rpcs3-mem1", O_RDWR | O_CREAT | O_EXCL, S_IWUSR | S_IRUSR)) == -1)
+		const std::string name = "/rpcs3-mem-" + std::to_string(reinterpret_cast<u64>(this));
+
+		while ((m_file = ::shm_open(name.c_str(), O_RDWR | O_CREAT | O_EXCL, S_IWUSR | S_IRUSR)) == -1)
 		{
 			if (errno == EMFILE)
 			{
@@ -188,7 +204,7 @@ namespace utils
 			verify(HERE), errno == EEXIST;
 		}
 
-		verify(HERE), ::shm_unlink("/rpcs3-mem1") >= 0;
+		verify(HERE), ::shm_unlink(name.c_str()) >= 0;
 		verify(HERE), ::ftruncate(m_file, m_size) >= 0;
 #endif
 	}

Utilities/types.h

@@ -49,7 +49,7 @@
 #endif
 
 #define SAFE_BUFFERS __attribute__((no_stack_protector))
-#define NEVER_INLINE __attribute__((noinline))
+#define NEVER_INLINE __attribute__((noinline)) inline
 #define FORCE_INLINE __attribute__((always_inline)) inline
 #define RESTRICT __restrict__
 

rpcs3/Emu/CPU/CPUThread.cpp

@@ -575,11 +575,6 @@ cpu_thread::cpu_thread(u32 id)
 
 bool cpu_thread::check_state() noexcept
 {
-	if (state & cpu_flag::dbg_pause)
-	{
-		g_fxo->get<gdb_server>()->pause_from(this);
-	}
-
 	bool cpu_sleep_called = false;
 	bool cpu_can_stop = true;
 	bool escape, retval;
@@ -607,7 +602,7 @@ bool cpu_thread::check_state() noexcept
 				store = true;
 			}
 
-			if (flags & cpu_flag::signal)
+			if (cpu_can_stop && flags & cpu_flag::signal)
 			{
 				flags -= cpu_flag::signal;
 				cpu_sleep_called = false;
@@ -617,8 +612,8 @@ bool cpu_thread::check_state() noexcept
 			// Atomically clean wait flag and escape
 			if (!(flags & (cpu_flag::exit + cpu_flag::dbg_global_stop + cpu_flag::ret + cpu_flag::stop)))
 			{
-				// Check pause flags which hold thread inside check_state
-				if (flags & (cpu_flag::pause + cpu_flag::suspend + cpu_flag::dbg_global_pause + cpu_flag::dbg_pause + cpu_flag::memory))
+				// Check pause flags which hold thread inside check_state (ignore suspend on cpu_flag::temp)
+				if (flags & (cpu_flag::pause + cpu_flag::dbg_global_pause + cpu_flag::dbg_pause + cpu_flag::memory + (cpu_can_stop ? cpu_flag::suspend : cpu_flag::pause)))
 				{
 					if (!(flags & cpu_flag::wait))
 					{
@@ -674,12 +669,12 @@ bool cpu_thread::check_state() noexcept
 			return retval;
 		}
 
-		if (!cpu_sleep_called && state0 & cpu_flag::suspend)
+		if (cpu_can_stop && !cpu_sleep_called && state0 & cpu_flag::suspend)
 		{
 			cpu_sleep();
 			cpu_sleep_called = true;
 
-			if (cpu_can_stop && s_tls_thread_slot != umax)
+			if (s_tls_thread_slot != umax)
 			{
 				// Exclude inactive threads from the suspend list (optimization)
 				std::lock_guard lock(g_fxo->get<cpu_counter>()->cpu_suspend_lock);
@@ -690,8 +685,13 @@ bool cpu_thread::check_state() noexcept
 			continue;
 		}
 
-		if (state0 & (cpu_flag::suspend + cpu_flag::dbg_global_pause + cpu_flag::dbg_pause))
+		if (state0 & ((cpu_can_stop ? cpu_flag::suspend : cpu_flag::dbg_pause) + cpu_flag::dbg_global_pause + cpu_flag::dbg_pause))
 		{
+			if (state0 & cpu_flag::dbg_pause)
+			{
+				g_fxo->get<gdb_server>()->pause_from(this);
+			}
+
 			thread_ctrl::wait();
 		}
 		else

rpcs3/Emu/Cell/Modules/sys_prx_.cpp

@@ -39,7 +39,7 @@ error_code sys_prx_load_module(ppu_thread& ppu, vm::cptr<char> path, u64 flags,
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_load_module(path, flags, pOpt);
+	return _sys_prx_load_module(ppu, path, flags, pOpt);
 }
 
 error_code sys_prx_load_module_by_fd(ppu_thread& ppu, s32 fd, u64 offset, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
@@ -48,7 +48,7 @@ error_code sys_prx_load_module_by_fd(ppu_thread& ppu, s32 fd, u64 offset, u64 fl
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_load_module_by_fd(fd, offset, flags, pOpt);
+	return _sys_prx_load_module_by_fd(ppu, fd, offset, flags, pOpt);
 }
 
 error_code sys_prx_load_module_on_memcontainer(ppu_thread& ppu, vm::cptr<char> path, u32 mem_ct, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
@@ -57,7 +57,7 @@ error_code sys_prx_load_module_on_memcontainer(ppu_thread& ppu, vm::cptr<char> p
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_load_module_on_memcontainer(path, mem_ct, flags, pOpt);
+	return _sys_prx_load_module_on_memcontainer(ppu, path, mem_ct, flags, pOpt);
 }
 
 error_code sys_prx_load_module_on_memcontainer_by_fd(ppu_thread& ppu, s32 fd, u64 offset, u32 mem_ct, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
@@ -66,7 +66,7 @@ error_code sys_prx_load_module_on_memcontainer_by_fd(ppu_thread& ppu, s32 fd, u6
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_load_module_on_memcontainer_by_fd(fd, offset, mem_ct, flags, pOpt);
+	return _sys_prx_load_module_on_memcontainer_by_fd(ppu, fd, offset, mem_ct, flags, pOpt);
 }
 
 error_code sys_prx_load_module_list(ppu_thread& ppu, s32 count, vm::cpptr<char> path_list, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
@@ -75,7 +75,7 @@ error_code sys_prx_load_module_list(ppu_thread& ppu, s32 count, vm::cpptr<char>
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_load_module_list(count, convert_path_list(path_list, count), flags, pOpt, id_list);
+	return _sys_prx_load_module_list(ppu, count, convert_path_list(path_list, count), flags, pOpt, id_list);
 }
 
 error_code sys_prx_load_module_list_on_memcontainer(ppu_thread& ppu, s32 count, vm::cpptr<char> path_list, u32 mem_ct, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt, vm::ptr<u32> id_list)
@@ -84,7 +84,7 @@ error_code sys_prx_load_module_list_on_memcontainer(ppu_thread& ppu, s32 count,
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_load_module_list_on_memcontainer(count, convert_path_list(path_list, count), mem_ct, flags, pOpt, id_list);
+	return _sys_prx_load_module_list_on_memcontainer(ppu, count, convert_path_list(path_list, count), mem_ct, flags, pOpt, id_list);
 }
 
 error_code sys_prx_start_module(ppu_thread& ppu, u32 id, u32 args, vm::ptr<void> argp, vm::ptr<s32> result, u64 flags, vm::ptr<void> pOpt)
@@ -103,7 +103,7 @@ error_code sys_prx_start_module(ppu_thread& ppu, u32 id, u32 args, vm::ptr<void>
 	opt->cmd  = 1;
 	opt->entry2.set(-1);
 
-	const error_code res = _sys_prx_start_module(id, flags, opt);
+	const error_code res = _sys_prx_start_module(ppu, id, flags, opt);
 
 	if (res < 0)
 	{
@@ -115,7 +115,7 @@ error_code sys_prx_start_module(ppu_thread& ppu, u32 id, u32 args, vm::ptr<void>
 	opt->cmd = 2;
 	opt->res = *result;
 
-	_sys_prx_start_module(id, flags, opt);
+	_sys_prx_start_module(ppu, id, flags, opt);
 
 	return CELL_OK;
 }
@@ -136,7 +136,7 @@ error_code sys_prx_stop_module(ppu_thread& ppu, u32 id, u32 args, vm::ptr<void>
 	opt->cmd  = 1;
 	opt->entry2.set(-1);
 
-	const error_code res = _sys_prx_stop_module(id, flags, opt);
+	const error_code res = _sys_prx_stop_module(ppu, id, flags, opt);
 
 	if (res < 0)
 	{
@@ -148,7 +148,7 @@ error_code sys_prx_stop_module(ppu_thread& ppu, u32 id, u32 args, vm::ptr<void>
 	opt->cmd = 2;
 	opt->res = *result;
 
-	_sys_prx_stop_module(id, flags, opt);
+	_sys_prx_stop_module(ppu, id, flags, opt);
 
 	return CELL_OK;
 }
@@ -159,7 +159,7 @@ error_code sys_prx_unload_module(ppu_thread& ppu, u32 id, u64 flags, vm::ptr<sys
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_unload_module(id, flags, pOpt);
+	return _sys_prx_unload_module(ppu, id, flags, pOpt);
 }
 
 error_code sys_prx_register_library(ppu_thread& ppu, vm::ptr<void> lib_entry)
@@ -168,7 +168,7 @@ error_code sys_prx_register_library(ppu_thread& ppu, vm::ptr<void> lib_entry)
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_register_library(lib_entry);
+	return _sys_prx_register_library(ppu, lib_entry);
 }
 
 error_code sys_prx_unregister_library(ppu_thread& ppu, vm::ptr<void> lib_entry)
@@ -177,7 +177,7 @@ error_code sys_prx_unregister_library(ppu_thread& ppu, vm::ptr<void> lib_entry)
 
 	sys_lwmutex_locker lock(ppu, g_ppu_prx_lwm);
 
-	return _sys_prx_unregister_library(lib_entry);
+	return _sys_prx_unregister_library(ppu, lib_entry);
 }
 
 error_code sys_prx_get_module_list(ppu_thread& ppu, u64 flags, vm::ptr<sys_prx_get_module_list_t> info)
@@ -198,7 +198,7 @@ error_code sys_prx_get_module_list(ppu_thread& ppu, u64 flags, vm::ptr<sys_prx_g
 	opt->unk    = 0;
 
 	// Call the syscall
-	const s32 res = _sys_prx_get_module_list(2, opt);
+	const s32 res = _sys_prx_get_module_list(ppu, 2, opt);
 
 	info->max   = opt->max;
 	info->count = opt->count;
@@ -221,10 +221,10 @@ error_code sys_prx_get_module_info(ppu_thread& ppu, u32 id, u64 flags, vm::ptr<s
 	opt->info = info;
 
 	// Call the syscall
-	return _sys_prx_get_module_info(id, 0, opt);
+	return _sys_prx_get_module_info(ppu, id, 0, opt);
 }
 
-error_code sys_prx_get_module_id_by_name(vm::cptr<char> name, u64 flags, vm::ptr<sys_prx_get_module_id_by_name_option_t> pOpt)
+error_code sys_prx_get_module_id_by_name(ppu_thread& ppu, vm::cptr<char> name, u64 flags, vm::ptr<sys_prx_get_module_id_by_name_option_t> pOpt)
 {
 	sysPrxForUser.trace("sys_prx_get_module_id_by_name(name=%s, flags=0x%x, pOpt=*0x%x)", name, flags, pOpt);
 
@@ -234,15 +234,15 @@ error_code sys_prx_get_module_id_by_name(vm::cptr<char> name, u64 flags, vm::ptr
 	}
 
 	// Call the syscall
-	return _sys_prx_get_module_id_by_name(name, u64{0}, vm::null);
+	return _sys_prx_get_module_id_by_name(ppu, name, u64{0}, vm::null);
 }
 
-error_code sys_prx_get_module_id_by_address(u32 addr)
+error_code sys_prx_get_module_id_by_address(ppu_thread& ppu, u32 addr)
 {
 	sysPrxForUser.trace("sys_prx_get_module_id_by_address()");
 
 	// Call the syscall
-	return _sys_prx_get_module_id_by_address(addr);
+	return _sys_prx_get_module_id_by_address(ppu, addr);
 }
 
 error_code sys_prx_exitspawn_with_level()
@@ -256,7 +256,7 @@ error_code sys_prx_get_my_module_id(ppu_thread& ppu, ppu_thread& _do, ppu_thread
 	sysPrxForUser.trace("sys_prx_get_my_module_id()");
 
 	// Call the syscall using the LR
-	return _sys_prx_get_module_id_by_address(static_cast<u32>(ppu.lr));
+	return _sys_prx_get_module_id_by_address(ppu, static_cast<u32>(ppu.lr));
 }
 
 void sysPrxForUser_sys_prx_init()

rpcs3/Emu/Cell/SPUDisAsm.cpp

@@ -80,14 +80,15 @@ std::pair<bool, v128> SPUDisAsm::try_get_const_value(u32 reg, u32 pc) const
 				// Aligned stack assumption
 				if (op0.ra == 1u)
 				{
-					u32 size;
+					u32 size = 0;
 
 					switch (type)
 					{
 					case spu_itype::CBD: size = 1; break;
 					case spu_itype::CHD: size = 2; break;
 					case spu_itype::CWD: size = 4; break;
 					case spu_itype::CDD: size = 8; break;
+					default: ASSUME(0);
 					}
 
 					const u32 index = (~op0.i7 & 0xf) / size;
@@ -99,6 +100,7 @@ std::pair<bool, v128> SPUDisAsm::try_get_const_value(u32 reg, u32 pc) const
 					case 2: res._u16[index] = 0x0203; break;
 					case 4: res._u32[index] = 0x00010203; break;
 					case 8: res._u64[index] = 0x0001020304050607ull; break;
+					default: ASSUME(0);
 					}
 
 					return {true, res};
@@ -112,7 +114,7 @@ std::pair<bool, v128> SPUDisAsm::try_get_const_value(u32 reg, u32 pc) const
 
 				for (s32 i = 0; i < 16; i++)
 				{
-					res._u8[i] = (op0.i16 & (1 << i)) ? 0xFF : 0x00; 
+					res._u8[i] = (op0.i16 & (1 << i)) ? 0xFF : 0x00;
 				}
 
 				return { true, res };

rpcs3/Emu/Cell/lv2/lv2.cpp

@@ -1,6 +1,7 @@
 #include "stdafx.h"
 #include "Emu/System.h"
 #include "Emu/Memory/vm_ptr.h"
+#include "Emu/Memory/vm_locking.h"
 
 #include "Emu/Cell/PPUFunction.h"
 #include "Emu/Cell/ErrorCodes.h"
@@ -1114,6 +1115,26 @@ DECLARE(lv2_obj::g_waiting);
 
 thread_local DECLARE(lv2_obj::g_to_awake);
 
+void lv2_obj::sleep(cpu_thread& cpu, const u64 timeout)
+{
+	vm::temporary_unlock(cpu);
+	std::lock_guard{g_mutex}, sleep_unlocked(cpu, timeout);
+	g_to_awake.clear();
+}
+
+bool lv2_obj::awake(cpu_thread* const thread, s32 prio)
+{
+	vm::temporary_unlock();
+	std::lock_guard lock(g_mutex);
+	return awake_unlocked(thread, prio);
+}
+
+bool lv2_obj::yield(cpu_thread& thread)
+{
+	vm::temporary_unlock(thread);
+	return awake(&thread, yield_cmd);
+}
+
 void lv2_obj::sleep_unlocked(cpu_thread& thread, u64 timeout)
 {
 	const u64 start_time = get_guest_system_time();

rpcs3/Emu/Cell/lv2/sys_ppu_thread.cpp

@@ -6,6 +6,7 @@
 #include "Emu/Cell/ErrorCodes.h"
 #include "Emu/Cell/PPUThread.h"
 #include "Emu/Cell/PPUCallback.h"
+#include "Emu/Memory/vm_locking.h"
 #include "sys_event.h"
 #include "sys_process.h"
 #include "sys_mmapper.h"