sys_lwcond, sys_lwmutex

rpcs3/Emu/Cell/Modules/sys_lwcond_.cpp

@@ -11,11 +11,17 @@ extern logs::channel sysPrxForUser;
 
 s32 sys_lwcond_create(vm::ptr<sys_lwcond_t> lwcond, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwcond_attribute_t> attr)
 {
-	sysPrxForUser.warning("sys_lwcond_create(lwcond=*0x%x, lwmutex=*0x%x, attr=*0x%x)", lwcond, lwmutex, attr);
+	sysPrxForUser.trace("sys_lwcond_create(lwcond=*0x%x, lwmutex=*0x%x, attr=*0x%x)", lwcond, lwmutex, attr);
 
-	lwcond->lwcond_queue = idm::make<lv2_obj, lv2_lwcond>(reinterpret_cast<u64&>(attr->name));
+	vm::var<u32> out_id;
-	lwcond->lwmutex = lwmutex;
 
+	if (s32 res = _sys_lwcond_create(out_id, lwmutex->sleep_queue, lwcond, attr->name_u64, 0))
+	{
+		return res;
+	}
+
+	lwcond->lwmutex      = lwmutex;
+	lwcond->lwcond_queue = *out_id;
 	return CELL_OK;
 }
 
@@ -23,14 +29,13 @@ s32 sys_lwcond_destroy(vm::ptr<sys_lwcond_t> lwcond)
 {
 	sysPrxForUser.trace("sys_lwcond_destroy(lwcond=*0x%x)", lwcond);
 
-	const s32 res = _sys_lwcond_destroy(lwcond->lwcond_queue);
+	if (s32 res = _sys_lwcond_destroy(lwcond->lwcond_queue))
-
-	if (res == CELL_OK)
 	{
-		lwcond->lwcond_queue = lwmutex_dead;
+		return res;
 	}
 
-	return res;
+	lwcond->lwcond_queue = lwmutex_dead;
+	return CELL_OK;
 }
 
 s32 sys_lwcond_signal(ppu_thread& ppu, vm::ptr<sys_lwcond_t> lwcond)

rpcs3/Emu/Cell/Modules/sys_lwmutex_.cpp

@@ -11,13 +11,13 @@ extern logs::channel sysPrxForUser;
 
 s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attribute_t> attr)
 {
-	sysPrxForUser.warning("sys_lwmutex_create(lwmutex=*0x%x, attr=*0x%x)", lwmutex, attr);
+	sysPrxForUser.trace("sys_lwmutex_create(lwmutex=*0x%x, attr=*0x%x)", lwmutex, attr);
 
-	const bool recursive = attr->recursive == SYS_SYNC_RECURSIVE;
+	const u32 recursive = attr->recursive;
 
-	if (!recursive && attr->recursive != SYS_SYNC_NOT_RECURSIVE)
+	if (recursive != SYS_SYNC_RECURSIVE && recursive != SYS_SYNC_NOT_RECURSIVE)
 	{
-		sysPrxForUser.error("sys_lwmutex_create(): invalid recursive attribute (0x%x)", attr->recursive);
+		sysPrxForUser.error("sys_lwmutex_create(): invalid recursive attribute (0x%x)", recursive);
 		return CELL_EINVAL;
 	}
 
@@ -31,11 +31,17 @@ s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attri
 	default: sysPrxForUser.error("sys_lwmutex_create(): invalid protocol (0x%x)", protocol); return CELL_EINVAL;
 	}
 
+	vm::var<u32> out_id;
+
+	if (s32 res = _sys_lwmutex_create(out_id, protocol, lwmutex, 0x80000001, attr->name_u64, 0))
+	{
+		return res;
+	}
+
 	lwmutex->lock_var.store({ lwmutex_free, 0 });
 	lwmutex->attribute = attr->recursive | attr->protocol;
 	lwmutex->recursive_count = 0;
-	lwmutex->sleep_queue = idm::make<lv2_obj, lv2_lwmutex>(protocol, reinterpret_cast<u64&>(attr->name));
+	lwmutex->sleep_queue = *out_id;
-
 	return CELL_OK;
 }
 

rpcs3/Emu/Cell/lv2/sys_event_flag.h

@@ -34,6 +34,9 @@ struct lv2_event_flag final : lv2_obj
 	static const u32 id_base = 0x98000000;
 
 	const u32 protocol;
+	const u32 shared;
+	const u64 key;
+	const s32 flags;
 	const s32 type;
 	const u64 name;
 
@@ -41,11 +44,14 @@ struct lv2_event_flag final : lv2_obj
 
 	sleep_queue<cpu_thread> sq;
 
-	lv2_event_flag(u64 pattern, u32 protocol, s32 type, u64 name)
+	lv2_event_flag(u32 protocol, s32 type, u64 name, u64 pattern)
-		: pattern(pattern)
+		: protocol(protocol)
-		, protocol(protocol)
+		, shared(0)
+		, key(0)
+		, flags(0)
 		, type(type)
 		, name(name)
+		, pattern(pattern)
 	{
 	}
 

rpcs3/Emu/Cell/lv2/sys_lwcond.cpp

@@ -8,208 +8,294 @@
 #include "sys_lwmutex.h"
 #include "sys_lwcond.h"
 
-#include <algorithm>
+namespace vm { using namespace ps3; }
 
 logs::channel sys_lwcond("sys_lwcond", logs::level::notice);
 
 extern u64 get_system_time();
 
-void lv2_lwcond::notify(lv2_lock_t, cpu_thread* thread, const std::shared_ptr<lv2_lwmutex>& mutex, bool mode2)
+error_code _sys_lwcond_create(vm::ptr<u32> lwcond_id, u32 lwmutex_id, vm::ptr<sys_lwcond_t> control, u64 name, u32 arg5)
-{
-	auto& ppu = static_cast<ppu_thread&>(*thread);
-
-	ppu.gpr[3] = mode2;  // set to return CELL_EBUSY
-
-	if (!mode2)
-	{
-		if (!mutex->signaled)
-		{
-			return mutex->sq.emplace_back(thread);
-		}
-
-		mutex->signaled--;
-	}
-
-	thread->set_signal();
-}
-
-s32 _sys_lwcond_create(vm::ptr<u32> lwcond_id, u32 lwmutex_id, vm::ptr<sys_lwcond_t> control, u64 name, u32 arg5)
 {
 	sys_lwcond.warning("_sys_lwcond_create(lwcond_id=*0x%x, lwmutex_id=0x%x, control=*0x%x, name=0x%llx, arg5=0x%x)", lwcond_id, lwmutex_id, control, name, arg5);
 
-	*lwcond_id = idm::make<lv2_obj, lv2_lwcond>(name);
+	// Temporarily
+	if (!idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id))
+	{
+		return CELL_ESRCH;
+	}
 
-	return CELL_OK;
+	if (const u32 id = idm::make<lv2_obj, lv2_lwcond>(name, lwmutex_id))
+	{
+		*lwcond_id = id;
+		return CELL_OK;
+	}
+
+	return CELL_EAGAIN;
 }
 
-s32 _sys_lwcond_destroy(u32 lwcond_id)
+error_code _sys_lwcond_destroy(u32 lwcond_id)
 {
 	sys_lwcond.warning("_sys_lwcond_destroy(lwcond_id=0x%x)", lwcond_id);
 
-	LV2_LOCK;
+	const auto cond = idm::withdraw<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> CellError
+	{
+		if (cond.waiters)
+		{
+			return CELL_EBUSY;
+		}
 
-	const auto cond = idm::get<lv2_obj, lv2_lwcond>(lwcond_id);
+		return {};
+	});
 
 	if (!cond)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (!cond->sq.empty())
+	if (cond.ret)
 	{
-		return CELL_EBUSY;
+		return cond.ret;
 	}
 
-	idm::remove<lv2_obj, lv2_lwcond>(lwcond_id);
-
 	return CELL_OK;
 }
 
-s32 _sys_lwcond_signal(u32 lwcond_id, u32 lwmutex_id, u32 ppu_thread_id, u32 mode)
+error_code _sys_lwcond_signal(u32 lwcond_id, u32 lwmutex_id, u32 ppu_thread_id, u32 mode)
 {
 	sys_lwcond.trace("_sys_lwcond_signal(lwcond_id=0x%x, lwmutex_id=0x%x, ppu_thread_id=0x%x, mode=%d)", lwcond_id, lwmutex_id, ppu_thread_id, mode);
 
-	LV2_LOCK;
+	// Mode 1: lwmutex was initially owned by the calling thread
+	// Mode 2: lwmutex was not owned by the calling thread and waiter hasn't been increased
+	// Mode 3: lwmutex was forcefully owned by the calling thread
 
-	const auto cond = idm::get<lv2_obj, lv2_lwcond>(lwcond_id);
+	if (mode < 1 || mode > 3)
-	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id);
-
-	if (!cond || (lwmutex_id && !mutex))
-	{
-		return CELL_ESRCH;
-	}
-
-	if (mode != 1 && mode != 2 && mode != 3)
 	{
 		fmt::throw_exception("Unknown mode (%d)" HERE, mode);
 	}
 
-	// mode 1: lightweight mutex was initially owned by the calling thread
+	lv2_lwmutex* mutex = nullptr;
-	// mode 2: lightweight mutex was not owned by the calling thread and waiter hasn't been increased
-	// mode 3: lightweight mutex was forcefully owned by the calling thread
 
-	// pick waiter; protocol is ignored in current implementation
+	const auto cond = idm::check<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> cpu_thread*
-	const auto found = !~ppu_thread_id ? cond->sq.begin() : std::find_if(cond->sq.begin(), cond->sq.end(), [=](cpu_thread* thread)
 	{
-		return thread->id == ppu_thread_id;
+		mutex = idm::check_unlocked<lv2_obj, lv2_lwmutex>(lwmutex_id);
+
+		if (mutex && cond.waiters)
+		{
+			semaphore_lock lock(mutex->mutex);
+
+			cpu_thread* result = nullptr;
+
+			if (ppu_thread_id != -1)
+			{
+				for (auto cpu : cond.sq)
+				{
+					if (cpu->id == ppu_thread_id)
+					{
+						verify(HERE), cond.unqueue(cond.sq, cpu);
+						result = cpu;
+						break;
+					}
+				}
+			}
+			else
+			{
+				result = cond.schedule<ppu_thread>(cond.sq, mutex->protocol);
+			}
+
+			if (result)
+			{
+				cond.waiters--;
+
+				static_cast<ppu_thread*>(result)->gpr[3] = mode == 2;
+
+				if (mode != 2 && !mutex->signaled.fetch_op([](u32& v) { if (v) v--; }))
+				{
+					mutex->sq.emplace_back(result);
+					result = nullptr;
+					mode = 2; // Enforce CELL_OK
+				}
+
+				return result;
+			}
+		}
+
+		return nullptr;
 	});
-
+	
-	if (found == cond->sq.end())
+	if ((lwmutex_id && !mutex) || !cond)
 	{
-		if (mode == 1)
+		return CELL_ESRCH;
-		{
-			return CELL_EPERM;
-		}
-		else if (mode == 2)
-		{
-			return CELL_OK;
-		}
-		else
-		{
-			return ~ppu_thread_id ? CELL_ENOENT : CELL_EPERM;
-		}
 	}
 
-	// signal specified waiting thread
+	if (cond.ret)
-	cond->notify(lv2_lock, *found, mutex, mode == 2);
+	{
-
+		cond.ret->set_signal();
-	cond->sq.erase(found);
+	}
+	else if (mode == 2)
+	{
+		return CELL_OK;
+	}
+	else if (mode == 1 || ppu_thread_id == -1)
+	{
+		return not_an_error(CELL_EPERM);
+	}
+	else
+	{
+		return not_an_error(CELL_ENOENT);
+	}
 
 	return CELL_OK;
 }
 
-s32 _sys_lwcond_signal_all(u32 lwcond_id, u32 lwmutex_id, u32 mode)
+error_code _sys_lwcond_signal_all(u32 lwcond_id, u32 lwmutex_id, u32 mode)
 {
 	sys_lwcond.trace("_sys_lwcond_signal_all(lwcond_id=0x%x, lwmutex_id=0x%x, mode=%d)", lwcond_id, lwmutex_id, mode);
 
-	LV2_LOCK;
+	// Mode 1: lwmutex was initially owned by the calling thread
+	// Mode 2: lwmutex was not owned by the calling thread and waiter hasn't been increased
 
-	const auto cond = idm::get<lv2_obj, lv2_lwcond>(lwcond_id);
+	if (mode < 1 || mode > 2)
-	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id);
-
-	if (!cond || (lwmutex_id && !mutex))
-	{
-		return CELL_ESRCH;
-	}
-
-	if (mode != 1 && mode != 2)
 	{
 		fmt::throw_exception("Unknown mode (%d)" HERE, mode);
 	}
 
-	// mode 1: lightweight mutex was initially owned by the calling thread
+	std::basic_string<cpu_thread*> threads;
-	// mode 2: lightweight mutex was not owned by the calling thread and waiter hasn't been increased
 
-	// signal all waiting threads; protocol is ignored in current implementation
+	lv2_lwmutex* mutex = nullptr;
-	for (auto& thread : cond->sq)
+
+	const auto cond = idm::check<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> u32
 	{
-		cond->notify(lv2_lock, thread, mutex, mode == 2);
+		mutex = idm::check_unlocked<lv2_obj, lv2_lwmutex>(lwmutex_id);
+
+		if (mutex && cond.waiters)
+		{
+			semaphore_lock lock(mutex->mutex);
+
+			u32 result = 0;
+
+			while (const auto cpu = cond.schedule<ppu_thread>(cond.sq, mutex->protocol))
+			{
+				cond.waiters--;
+
+				static_cast<ppu_thread*>(cpu)->gpr[3] = mode == 2;
+
+				if (mode != 2 && !mutex->signaled.fetch_op([](u32& v) { if (v) v--; }))
+				{
+					mutex->sq.emplace_back(cpu);
+				}
+				else
+				{
+					threads.push_back(cpu);
+				}
+
+				result++;
+			}
+
+			return result;
+		}
+
+		return 0;
+	});
+
+	if ((lwmutex_id && !mutex) || !cond)
+	{
+		return CELL_ESRCH;
 	}
 
-	// in mode 1, return the amount of threads signaled
+	// TODO: signal only one thread
-	const s32 result = mode == 2 ? CELL_OK : static_cast<s32>(cond->sq.size());
+	for (auto cpu : threads)
+	{
+		cpu->set_signal();
+	}
 
-	cond->sq.clear();
+	if (mode == 1)
+	{
+		// Mode 1: return the amount of threads (TODO)
+		return not_an_error(cond.ret);
+	}
 
-	return result;
+	return CELL_OK;
 }
 
-s32 _sys_lwcond_queue_wait(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u64 timeout)
+error_code _sys_lwcond_queue_wait(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u64 timeout)
 {
 	sys_lwcond.trace("_sys_lwcond_queue_wait(lwcond_id=0x%x, lwmutex_id=0x%x, timeout=0x%llx)", lwcond_id, lwmutex_id, timeout);
 
 	const u64 start_time = get_system_time();
 
-	LV2_LOCK;
+	std::shared_ptr<lv2_lwmutex> mutex;
 
-	const auto cond = idm::get<lv2_obj, lv2_lwcond>(lwcond_id);
+	const auto cond = idm::get<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> cpu_thread*
-	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id);
+	{
+		mutex = idm::get_unlocked<lv2_obj, lv2_lwmutex>(lwmutex_id);
+
+		if (!mutex)
+		{
+			return nullptr;
+		}
+
+		semaphore_lock lock(mutex->mutex);
+
+		// Add a waiter
+		cond.waiters++;
+		cond.sq.emplace_back(&ppu);
+
+		// Process lwmutex sleep queue
+		if (const auto cpu = mutex->schedule<ppu_thread>(mutex->sq, mutex->protocol))
+		{
+			return cpu;
+		}
+
+		mutex->signaled++;
+		return nullptr;
+	});
 
 	if (!cond || !mutex)
 	{
 		return CELL_ESRCH;
 	}
 
-	// finalize unlocking the mutex
+	if (cond.ret)
-	mutex->unlock(lv2_lock);
+	{
+		cond.ret->set_signal();
+	}
 
-	// add waiter; protocol is ignored in current implementation
+	// SLEEP
-	sleep_entry<cpu_thread> waiter(cond->sq, ppu);
-
-	// potential mutex waiter (not added immediately)
-	sleep_entry<cpu_thread> mutex_waiter(cond->sq, ppu, defer_sleep);
 
 	while (!ppu.state.test_and_reset(cpu_flag::signal))
 	{
-		CHECK_EMU_STATUS;
+		if (timeout)
-
-		if (timeout && waiter)
 		{
 			const u64 passed = get_system_time() - start_time;
 
 			if (passed >= timeout)
 			{
-				// try to reown the mutex if timed out
+				semaphore_lock lock(mutex->mutex);
-				if (mutex->signaled)
-				{
-					mutex->signaled--;
 
-					return CELL_EDEADLK;
+				if (!cond->unqueue(cond->sq, &ppu))
-				}
-				else
 				{
-					return CELL_ETIMEDOUT;
+					timeout = 0;
+					continue;
 				}
+
+				cond->waiters--;
+
+				if (mutex->signaled.fetch_op([](u32& v) { if (v) v--; }))
+				{
+					return not_an_error(CELL_EDEADLK);
+				}
+
+				return not_an_error(CELL_ETIMEDOUT);
 			}
 
-			LV2_UNLOCK, thread_ctrl::wait_for(timeout - passed);
+			thread_ctrl::wait_for(timeout - passed);
 		}
 		else
 		{
-			LV2_UNLOCK, thread_ctrl::wait();
+			thread_ctrl::wait();
 		}
 	}
 
-	// return cause
+	// Return cause
-	return ppu.gpr[3] ? CELL_EBUSY : CELL_OK;
+	return not_an_error(ppu.gpr[3] ? CELL_EBUSY : CELL_OK);
 }

rpcs3/Emu/Cell/lv2/sys_lwcond.h

@@ -1,19 +1,21 @@
 #pragma once
 
-#include "Utilities/SleepQueue.h"
+#include "sys_sync.h"
-
-namespace vm { using namespace ps3; }
 
 struct sys_lwmutex_t;
 
 struct sys_lwcond_attribute_t
 {
-	char name[8];
+	union
+	{
+		char name[8];
+		u64 name_u64;
+	};
 };
 
 struct sys_lwcond_t
 {
-	vm::bptr<sys_lwmutex_t> lwmutex;
+	vm::ps3::bptr<sys_lwmutex_t> lwmutex;
 	be_t<u32> lwcond_queue; // lwcond pseudo-id
 };
 
@@ -22,23 +24,25 @@ struct lv2_lwcond final : lv2_obj
 	static const u32 id_base = 0x97000000;
 
 	const u64 name;
+	const u32 lwid;
 
-	sleep_queue<cpu_thread> sq;
+	atomic_t<u32> waiters{0};
+	std::deque<cpu_thread*> sq;
 
-	lv2_lwcond(u64 name)
+	lv2_lwcond(u64 name, u32 lwid)
 		: name(name)
+		, lwid(lwid)
 	{
 	}
-
-	void notify(lv2_lock_t, cpu_thread* thread, const std::shared_ptr<lv2_lwmutex>& mutex, bool mode2);
 };
 
 // Aux
 class ppu_thread;
 
-// SysCalls
+// Syscalls
-s32 _sys_lwcond_create(vm::ptr<u32> lwcond_id, u32 lwmutex_id, vm::ptr<sys_lwcond_t> control, u64 name, u32 arg5);
+
-s32 _sys_lwcond_destroy(u32 lwcond_id);
+error_code _sys_lwcond_create(vm::ps3::ptr<u32> lwcond_id, u32 lwmutex_id, vm::ps3::ptr<sys_lwcond_t> control, u64 name, u32 arg5);
-s32 _sys_lwcond_signal(u32 lwcond_id, u32 lwmutex_id, u32 ppu_thread_id, u32 mode);
+error_code _sys_lwcond_destroy(u32 lwcond_id);
-s32 _sys_lwcond_signal_all(u32 lwcond_id, u32 lwmutex_id, u32 mode);
+error_code _sys_lwcond_signal(u32 lwcond_id, u32 lwmutex_id, u32 ppu_thread_id, u32 mode);
-s32 _sys_lwcond_queue_wait(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u64 timeout);
+error_code _sys_lwcond_signal_all(u32 lwcond_id, u32 lwmutex_id, u32 mode);
+error_code _sys_lwcond_queue_wait(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u64 timeout);

rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp

@@ -13,27 +13,7 @@ logs::channel sys_lwmutex("sys_lwmutex", logs::level::notice);
 
 extern u64 get_system_time();
 
-void lv2_lwmutex::unlock(lv2_lock_t)
+error_code _sys_lwmutex_create(vm::ptr<u32> lwmutex_id, u32 protocol, vm::ptr<sys_lwmutex_t> control, u32 arg4, u64 name, u32 arg6)
-{
-	if (signaled)
-	{
-		fmt::throw_exception("Unexpected" HERE);
-	}
-
-	if (sq.size())
-	{
-		const auto thread = sq.front();
-		thread->set_signal();
-
-		sq.pop_front();
-	}
-	else
-	{
-		signaled++;
-	}
-}
-
-s32 _sys_lwmutex_create(vm::ptr<u32> lwmutex_id, u32 protocol, vm::ptr<sys_lwmutex_t> control, u32 arg4, u64 name, u32 arg6)
 {
 	sys_lwmutex.warning("_sys_lwmutex_create(lwmutex_id=*0x%x, protocol=0x%x, control=*0x%x, arg4=0x%x, name=0x%llx, arg6=0x%x)", lwmutex_id, protocol, control, arg4, name, arg6);
 
@@ -48,120 +28,172 @@ s32 _sys_lwmutex_create(vm::ptr<u32> lwmutex_id, u32 protocol, vm::ptr<sys_lwmut
 		fmt::throw_exception("Unknown arguments (arg4=0x%x, arg6=0x%x)" HERE, arg4, arg6);
 	}
 
-	*lwmutex_id = idm::make<lv2_obj, lv2_lwmutex>(protocol, name);
+	if (const u32 id = idm::make<lv2_obj, lv2_lwmutex>(protocol, control, name))
+	{
+		*lwmutex_id = id;
+		return CELL_OK;
+	}
 
-	return CELL_OK;
+	return CELL_EAGAIN;
 }
 
-s32 _sys_lwmutex_destroy(u32 lwmutex_id)
+error_code _sys_lwmutex_destroy(u32 lwmutex_id)
 {
 	sys_lwmutex.warning("_sys_lwmutex_destroy(lwmutex_id=0x%x)", lwmutex_id);
 
-	LV2_LOCK;
+	const auto mutex = idm::withdraw<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex) -> CellError
+	{
+		semaphore_lock lock(mutex.mutex);
 
-	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id);
+		if (!mutex.sq.empty())
+		{
+			return CELL_EBUSY;
+		}
+
+		return {};
+	});
 
 	if (!mutex)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (!mutex->sq.empty())
+	if (mutex.ret)
 	{
-		return CELL_EBUSY;
+		return mutex.ret;
 	}
 
-	idm::remove<lv2_obj, lv2_lwmutex>(lwmutex_id);
-
 	return CELL_OK;
 }
 
-s32 _sys_lwmutex_lock(ppu_thread& ppu, u32 lwmutex_id, u64 timeout)
+error_code _sys_lwmutex_lock(ppu_thread& ppu, u32 lwmutex_id, u64 timeout)
 {
 	sys_lwmutex.trace("_sys_lwmutex_lock(lwmutex_id=0x%x, timeout=0x%llx)", lwmutex_id, timeout);
 
 	const u64 start_time = get_system_time();
 
-	LV2_LOCK;
+	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex)
+	{
+		if (u32 value = mutex.signaled)
+		{
+			if (mutex.signaled.compare_and_swap_test(value, value - 1))
+			{
+				return true;
+			}
+		}
 
-	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id);
+		semaphore_lock lock(mutex.mutex);
+
+		if (u32 value = mutex.signaled)
+		{
+			if (mutex.signaled.compare_and_swap_test(value, value - 1))
+			{
+				return true;
+			}
+		}
+
+		mutex.sq.emplace_back(&ppu);
+		return false;
+	});
 
 	if (!mutex)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (mutex->signaled)
+	if (mutex.ret)
 	{
-		mutex->signaled--;
-
 		return CELL_OK;
 	}
 
-	// add waiter; protocol is ignored in current implementation
+	// SLEEP
-	sleep_entry<cpu_thread> waiter(mutex->sq, ppu);
 
 	while (!ppu.state.test_and_reset(cpu_flag::signal))
 	{
-		CHECK_EMU_STATUS;
-
 		if (timeout)
 		{
 			const u64 passed = get_system_time() - start_time;
 
 			if (passed >= timeout)
 			{
-				return CELL_ETIMEDOUT;
+				semaphore_lock lock(mutex->mutex);
+
+				if (!mutex->unqueue(mutex->sq, &ppu))
+				{
+					timeout = 0;
+					continue;
+				}
+
+				return not_an_error(CELL_ETIMEDOUT);
 			}
 
-			LV2_UNLOCK, thread_ctrl::wait_for(timeout - passed);
+			thread_ctrl::wait_for(timeout - passed);
 		}
 		else
 		{
-			LV2_UNLOCK, thread_ctrl::wait();
+			thread_ctrl::wait();
 		}
 	}
 
 	return CELL_OK;
 }
 
-s32 _sys_lwmutex_trylock(u32 lwmutex_id)
+error_code _sys_lwmutex_trylock(u32 lwmutex_id)
 {
 	sys_lwmutex.trace("_sys_lwmutex_trylock(lwmutex_id=0x%x)", lwmutex_id);
 
-	LV2_LOCK;
+	const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex)
+	{
+		if (u32 value = mutex.signaled)
+		{
+			if (mutex.signaled.compare_and_swap_test(value, value - 1))
+			{
+				return true;
+			}
+		}
 
-	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id);
+		return false;
+	});
 
 	if (!mutex)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (!mutex->sq.empty() || !mutex->signaled)
+	if (!mutex.ret)
 	{
-		return CELL_EBUSY;
+		return not_an_error(CELL_EBUSY);
 	}
 
-	mutex->signaled--;
-
 	return CELL_OK;
 }
 
-s32 _sys_lwmutex_unlock(u32 lwmutex_id)
+error_code _sys_lwmutex_unlock(u32 lwmutex_id)
 {
 	sys_lwmutex.trace("_sys_lwmutex_unlock(lwmutex_id=0x%x)", lwmutex_id);
 
-	LV2_LOCK;
+	const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex) -> cpu_thread*
+	{
+		semaphore_lock lock(mutex.mutex);
 
-	const auto mutex = idm::get<lv2_obj, lv2_lwmutex>(lwmutex_id);
+		if (const auto cpu = mutex.schedule<ppu_thread>(mutex.sq, mutex.protocol))
+		{
+			return cpu;
+		}
+
+		mutex.signaled++;
+		return nullptr;
+	});
 
 	if (!mutex)
 	{
 		return CELL_ESRCH;
 	}
 
-	mutex->unlock(lv2_lock);
+	if (mutex.ret)
+	{
+		mutex.ret->set_signal();
+	}
 
 	return CELL_OK;
 }

rpcs3/Emu/Cell/lv2/sys_lwmutex.h

@@ -6,7 +6,12 @@ struct sys_lwmutex_attribute_t
 {
 	be_t<u32> protocol;
 	be_t<u32> recursive;
-	char name[8];
+
+	union
+	{
+		char name[8];
+		u64 name_u64;
+	};
 };
 
 enum : u32
@@ -49,28 +54,28 @@ struct lv2_lwmutex final : lv2_obj
 	static const u32 id_base = 0x95000000;
 
 	const u32 protocol;
+	const vm::ps3::ptr<sys_lwmutex_t> control;
 	const u64 name;
 
-	// this object is not truly a mutex and its syscall names may be wrong, it's probably a sleep queue or something
+	semaphore<> mutex;
-	atomic_t<u32> signaled{ 0 };
+	atomic_t<u32> signaled{0};
+	std::deque<cpu_thread*> sq;
 
-	sleep_queue<cpu_thread> sq;
+	lv2_lwmutex(u32 protocol, vm::ps3::ptr<sys_lwmutex_t> control, u64 name)
-
-	lv2_lwmutex(u32 protocol, u64 name)
 		: protocol(protocol)
+		, control(control)
 		, name(name)
 	{
 	}
-
-	void unlock(lv2_lock_t);
 };
 
 // Aux
 class ppu_thread;
 
-// SysCalls
+// Syscalls
-s32 _sys_lwmutex_create(vm::ps3::ptr<u32> lwmutex_id, u32 protocol, vm::ps3::ptr<sys_lwmutex_t> control, u32 arg4, u64 name, u32 arg6);
+
-s32 _sys_lwmutex_destroy(u32 lwmutex_id);
+error_code _sys_lwmutex_create(vm::ps3::ptr<u32> lwmutex_id, u32 protocol, vm::ps3::ptr<sys_lwmutex_t> control, u32 arg4, u64 name, u32 arg6);
-s32 _sys_lwmutex_lock(ppu_thread& ppu, u32 lwmutex_id, u64 timeout);
+error_code _sys_lwmutex_destroy(u32 lwmutex_id);
-s32 _sys_lwmutex_trylock(u32 lwmutex_id);
+error_code _sys_lwmutex_lock(ppu_thread& ppu, u32 lwmutex_id, u64 timeout);
-s32 _sys_lwmutex_unlock(u32 lwmutex_id);
+error_code _sys_lwmutex_trylock(u32 lwmutex_id);
+error_code _sys_lwmutex_unlock(u32 lwmutex_id);

rpcs3/Emu/System.cpp

@@ -520,6 +520,15 @@ s32 error_code::error_report(const fmt_type_info* sup, u64 arg)
 
 				break;
 			}
+			case CELL_ESRCH:
+			{
+				if (ppu.m_name == "_sys_MixerChStripMain" && std::memcmp(ppu.last_function, "sys_lwmutex_lock", 17) == 0)
+				{
+					level = logs::level::trace;
+				}
+
+				break;
+			}
 			}
 
 			if (ppu.last_function)

rpcs3/Gui/KernelExplorer.cpp

@@ -204,7 +204,7 @@ void KernelExplorer::Update()
 		case SYS_LWMUTEX_OBJECT:
 		{
 			auto& lwm = static_cast<lv2_lwmutex&>(obj);
-			m_tree->AppendItem(node, fmt::format("LWMutex: ID = 0x%08x \"%s\"", id, +name64(lwm.name)));
+			m_tree->AppendItem(node, fmt::format("LWMutex: ID = 0x%08x \"%s\", Wq = %zu", id, +name64(lwm.name), lwm.sq.size()));
 			break;
 		}
 		case SYS_TIMER_OBJECT:
@@ -223,7 +223,7 @@ void KernelExplorer::Update()
 		case SYS_LWCOND_OBJECT:
 		{
 			auto& lwc = static_cast<lv2_cond&>(obj);
-			m_tree->AppendItem(node, fmt::format("LWCond: ID = 0x%08x \"%s\"", id, +name64(lwc.name)));
+			m_tree->AppendItem(node, fmt::format("LWCond: ID = 0x%08x \"%s\", Waiters = %zu", id, +name64(lwc.name), +lwc.waiters));
 			break;
 		}
 		case SYS_EVENT_FLAG_OBJECT: