mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-07-08 07:51:28 +12:00
236 lines
5 KiB
C++
236 lines
5 KiB
C++
#include "stdafx.h"
|
|
#include "Emu/Memory/Memory.h"
|
|
#include "Emu/System.h"
|
|
#include "Emu/SysCalls/SysCalls.h"
|
|
|
|
#include "Emu/CPU/CPUThreadManager.h"
|
|
#include "Emu/Cell/PPUThread.h"
|
|
#include "sys_cond.h"
|
|
|
|
SysCallBase sys_cond("sys_cond");
|
|
|
|
s32 sys_cond_create(vm::ptr<be_t<u32>> cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr)
|
|
{
|
|
sys_cond.Log("sys_cond_create(cond_id_addr=0x%x, mutex_id=%d, attr_addr=0x%x)",
|
|
cond_id.addr(), mutex_id, attr.GetAddr());
|
|
|
|
if (attr->pshared.ToBE() != se32(0x200))
|
|
{
|
|
sys_cond.Error("Invalid pshared attribute(0x%x)", (u32)attr->pshared);
|
|
return CELL_EINVAL;
|
|
}
|
|
|
|
Mutex* mutex;
|
|
if (!Emu.GetIdManager().GetIDData(mutex_id, mutex))
|
|
{
|
|
return CELL_ESRCH;
|
|
}
|
|
|
|
if (mutex->is_recursive)
|
|
{
|
|
sys_cond.Warning("*** condition on recursive mutex(%d)", mutex_id);
|
|
}
|
|
|
|
Cond* cond = new Cond(mutex, attr->name_u64);
|
|
u32 id = sys_cond.GetNewId(cond, TYPE_COND);
|
|
*cond_id = id;
|
|
mutex->cond_count++;
|
|
sys_cond.Warning("*** condition created [%s] (mutex_id=%d): id = %d", std::string(attr->name, 8).c_str(), mutex_id, id);
|
|
|
|
return CELL_OK;
|
|
}
|
|
|
|
s32 sys_cond_destroy(u32 cond_id)
|
|
{
|
|
sys_cond.Warning("sys_cond_destroy(cond_id=%d)", cond_id);
|
|
|
|
Cond* cond;
|
|
if (!Emu.GetIdManager().GetIDData(cond_id, cond))
|
|
{
|
|
return CELL_ESRCH;
|
|
}
|
|
|
|
if (!cond->m_queue.finalize())
|
|
{
|
|
return CELL_EBUSY;
|
|
}
|
|
|
|
cond->mutex->cond_count--;
|
|
Emu.GetIdManager().RemoveID(cond_id);
|
|
return CELL_OK;
|
|
}
|
|
|
|
s32 sys_cond_signal(u32 cond_id)
|
|
{
|
|
sys_cond.Log("sys_cond_signal(cond_id=%d)", cond_id);
|
|
|
|
Cond* cond;
|
|
if (!Emu.GetIdManager().GetIDData(cond_id, cond))
|
|
{
|
|
return CELL_ESRCH;
|
|
}
|
|
|
|
Mutex* mutex = cond->mutex;
|
|
|
|
if (u32 target = (mutex->protocol == SYS_SYNC_PRIORITY ? cond->m_queue.pop_prio() : cond->m_queue.pop()))
|
|
{
|
|
//cond->signal_stamp = get_system_time();
|
|
cond->signal.lock(target);
|
|
Emu.GetCPU().NotifyThread(target);
|
|
|
|
if (Emu.IsStopped())
|
|
{
|
|
sys_cond.Warning("sys_cond_signal(id=%d) aborted", cond_id);
|
|
}
|
|
}
|
|
|
|
return CELL_OK;
|
|
}
|
|
|
|
s32 sys_cond_signal_all(u32 cond_id)
|
|
{
|
|
sys_cond.Log("sys_cond_signal_all(cond_id=%d)", cond_id);
|
|
|
|
Cond* cond;
|
|
if (!Emu.GetIdManager().GetIDData(cond_id, cond))
|
|
{
|
|
return CELL_ESRCH;
|
|
}
|
|
|
|
Mutex* mutex = cond->mutex;
|
|
|
|
while (u32 target = (mutex->protocol == SYS_SYNC_PRIORITY ? cond->m_queue.pop_prio() : cond->m_queue.pop()))
|
|
{
|
|
cond->signaler = GetCurrentCPUThread()->GetId();
|
|
//cond->signal_stamp = get_system_time();
|
|
cond->signal.lock(target);
|
|
Emu.GetCPU().NotifyThread(target);
|
|
|
|
if (Emu.IsStopped())
|
|
{
|
|
sys_cond.Warning("sys_cond_signal_all(id=%d) aborted", cond_id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
cond->signaler = 0;
|
|
return CELL_OK;
|
|
}
|
|
|
|
s32 sys_cond_signal_to(u32 cond_id, u32 thread_id)
|
|
{
|
|
sys_cond.Log("sys_cond_signal_to(cond_id=%d, thread_id=%d)", cond_id, thread_id);
|
|
|
|
Cond* cond;
|
|
if (!Emu.GetIdManager().GetIDData(cond_id, cond))
|
|
{
|
|
return CELL_ESRCH;
|
|
}
|
|
|
|
if (!Emu.GetIdManager().CheckID(thread_id))
|
|
{
|
|
return CELL_ESRCH;
|
|
}
|
|
|
|
if (!cond->m_queue.invalidate(thread_id))
|
|
{
|
|
return CELL_EPERM;
|
|
}
|
|
|
|
Mutex* mutex = cond->mutex;
|
|
|
|
u32 target = thread_id;
|
|
{
|
|
//cond->signal_stamp = get_system_time();
|
|
cond->signal.lock(target);
|
|
Emu.GetCPU().NotifyThread(target);
|
|
}
|
|
|
|
if (Emu.IsStopped())
|
|
{
|
|
sys_cond.Warning("sys_cond_signal_to(id=%d, to=%d) aborted", cond_id, thread_id);
|
|
}
|
|
|
|
return CELL_OK;
|
|
}
|
|
|
|
s32 sys_cond_wait(u32 cond_id, u64 timeout)
|
|
{
|
|
sys_cond.Log("sys_cond_wait(cond_id=%d, timeout=%lld)", cond_id, timeout);
|
|
|
|
Cond* cond;
|
|
if (!Emu.GetIdManager().GetIDData(cond_id, cond))
|
|
{
|
|
return CELL_ESRCH;
|
|
}
|
|
|
|
Mutex* mutex = cond->mutex;
|
|
u32 tid = GetCurrentPPUThread().GetId();
|
|
|
|
if (mutex->m_mutex.GetOwner() != tid)
|
|
{
|
|
sys_cond.Warning("sys_cond_wait(cond_id=%d) failed (EPERM)", cond_id);
|
|
return CELL_EPERM;
|
|
}
|
|
|
|
cond->m_queue.push(tid);
|
|
|
|
if (mutex->recursive != 1)
|
|
{
|
|
sys_cond.Warning("sys_cond_wait(cond_id=%d): associated mutex had wrong recursive value (%d)", cond_id, mutex->recursive);
|
|
}
|
|
mutex->recursive = 0;
|
|
mutex->m_mutex.unlock(tid, mutex->protocol == SYS_SYNC_PRIORITY ? mutex->m_queue.pop_prio() : mutex->m_queue.pop());
|
|
|
|
u64 counter = 0;
|
|
const u64 max_counter = timeout ? (timeout / 1000) : ~0ull;
|
|
|
|
while (true)
|
|
{
|
|
if (cond->signal.unlock(tid, tid) == SMR_OK)
|
|
{
|
|
//const u64 stamp2 = get_system_time();
|
|
if (SMutexResult res = mutex->m_mutex.trylock(tid))
|
|
{
|
|
if (res != SMR_FAILED)
|
|
{
|
|
goto abort;
|
|
}
|
|
mutex->m_queue.push(tid);
|
|
|
|
switch (mutex->m_mutex.lock(tid))
|
|
{
|
|
case SMR_OK:
|
|
mutex->m_queue.invalidate(tid);
|
|
case SMR_SIGNAL:
|
|
break;
|
|
default:
|
|
goto abort;
|
|
}
|
|
}
|
|
mutex->recursive = 1;
|
|
const volatile u64 stamp = cond->signal_stamp;
|
|
cond->signal.unlock(tid);
|
|
Emu.GetCPU().NotifyThread(cond->signaler);
|
|
//ConLog.Write("sys_cond_wait(): signal latency %lld (minimum %lld)", get_system_time() - stamp, stamp2 - stamp);
|
|
return CELL_OK;
|
|
}
|
|
|
|
SM_Sleep();
|
|
|
|
if (counter++ > max_counter)
|
|
{
|
|
cond->m_queue.invalidate(tid);
|
|
GetCurrentPPUThread().owned_mutexes--; // ???
|
|
return CELL_ETIMEDOUT;
|
|
}
|
|
if (Emu.IsStopped())
|
|
{
|
|
goto abort;
|
|
}
|
|
}
|
|
|
|
abort:
|
|
sys_cond.Warning("sys_cond_wait(id=%d) aborted", cond_id);
|
|
return CELL_OK;
|
|
}
|