mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-02-04 12:39:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

sys_event_flag...

Browse Source
This commit is contained in:
Nekotekina 2017-02-03 19:27:03 +03:00
parent 3d85a89cc9
commit 26ced19e18
4 changed files with 203 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
rpcs3/Emu/Cell/SPUThread.cpp
View File

@ -867,22 +867,8 @@ bool SPUThread::set_ch_value(u32 ch, u32 value)
LOG_TRACE(SPU, "sys_event_flag_set_bit(id=%d, value=0x%x (flag=%d))", data, value, flag);
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(data);
if (!eflag)
{
return ch_in_mbox.set_values(1, CELL_ESRCH), true;
}
const u64 bitptn = 1ull << flag;
if (~eflag->pattern.fetch_or(bitptn) & bitptn)
{
// notify if the bit was set
eflag->notify_all(lv2_lock);
}
return ch_in_mbox.set_values(1, CELL_OK), true;
// Use the syscall to set flag
return ch_in_mbox.set_values(1, sys_event_flag_set(data, 1ull << flag)), true;
}
else if (code == 192)
{
@ -908,21 +894,8 @@ bool SPUThread::set_ch_value(u32 ch, u32 value)
LOG_TRACE(SPU, "sys_event_flag_set_bit_impatient(id=%d, value=0x%x (flag=%d))", data, value, flag);
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(data);
if (!eflag)
{
return true;
}
const u64 bitptn = 1ull << flag;
if (~eflag->pattern.fetch_or(bitptn) & bitptn)
{
// notify if the bit was set
eflag->notify_all(lv2_lock);
}
// Use the syscall to set flag
sys_event_flag_set(data, 1ull << flag);
return true;
}
else

302
rpcs3/Emu/Cell/lv2/sys_event_flag.cpp
View File

@ -15,35 +15,7 @@ logs::channel sys_event_flag("sys_event_flag", logs::level::notice);
extern u64 get_system_time();
void lv2_event_flag::notify_all(lv2_lock_t)
{
auto pred = [this](cpu_thread* thread) -> bool
{
auto& ppu = static_cast<ppu_thread&>(*thread);
// load pattern and mode from registers
const u64 bitptn = ppu.gpr[4];
const u32 mode = static_cast<u32>(ppu.gpr[5]);
// check specific pattern
if (check_pattern(bitptn, mode))
{
// save pattern
ppu.gpr[4] = clear_pattern(bitptn, mode);
thread->set_signal();
return true;
}
return false;
};
// check all waiters; protocol is ignored in current implementation
sq.erase(std::remove_if(sq.begin(), sq.end(), pred), sq.end());
}
s32 sys_event_flag_create(vm::ptr<u32> id, vm::ptr<sys_event_flag_attribute_t> attr, u64 init)
error_code sys_event_flag_create(vm::ptr<u32> id, vm::ptr<sys_event_flag_attribute_t> attr, u64 init)
{
sys_event_flag.warning("sys_event_flag_create(id=*0x%x, attr=*0x%x, init=0x%llx)", id, attr, init);
@ -74,48 +46,55 @@ s32 sys_event_flag_create(vm::ptr<u32> id, vm::ptr<sys_event_flag_attribute_t> a
return CELL_EINVAL;
}
*id = idm::make<lv2_obj, lv2_event_flag>(init, protocol, type, attr->name_u64);
if (const u32 _id = idm::make<lv2_obj, lv2_event_flag>(protocol, type, attr->name_u64, init))
{
*id = _id;
return CELL_OK;
}
return CELL_OK;
return CELL_EAGAIN;
}
s32 sys_event_flag_destroy(u32 id)
error_code sys_event_flag_destroy(u32 id)
{
sys_event_flag.warning("sys_event_flag_destroy(id=0x%x)", id);
LV2_LOCK;
const auto flag = idm::withdraw<lv2_obj, lv2_event_flag>(id, [&](lv2_event_flag& flag) -> CellError
{
if (flag.waiters)
{
return CELL_EBUSY;
}
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(id);
return {};
});
if (!eflag)
if (!flag)
{
return CELL_ESRCH;
}
if (!eflag->sq.empty())
if (flag.ret)
{
return CELL_EBUSY;
return flag.ret;
}
idm::remove<lv2_obj, lv2_event_flag>(id);
return CELL_OK;
}
s32 sys_event_flag_wait(ppu_thread& ppu, u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result, u64 timeout)
error_code sys_event_flag_wait(ppu_thread& ppu, u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result, u64 timeout)
{
sys_event_flag.trace("sys_event_flag_wait(id=0x%x, bitptn=0x%llx, mode=0x%x, result=*0x%x, timeout=0x%llx)", id, bitptn, mode, result, timeout);
const u64 start_time = get_system_time();
// If this syscall is called through the SC instruction, these registers must already contain corresponding values.
// But let's fixup them (in the case of explicit function call or something) because these values are used externally.
// Fix function arguments for external access
ppu.gpr[4] = bitptn;
ppu.gpr[5] = mode;
ppu.gpr[6] = 0;
LV2_LOCK;
if (result) *result = 0; // This is very annoying.
// Always set result
if (result) *result = ppu.gpr[6];
if (!lv2_event_flag::check_mode(mode))
{
@ -123,75 +102,89 @@ s32 sys_event_flag_wait(ppu_thread& ppu, u32 id, u64 bitptn, u32 mode, vm::ptr<u
return CELL_EINVAL;
}
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(id);
const auto flag = idm::get<lv2_obj, lv2_event_flag>(id, [&](lv2_event_flag& flag) -> CellError
{
if (flag.pattern.atomic_op(lv2_event_flag::check_pattern, bitptn, mode, &ppu.gpr[6]))
{
// TODO: is it possible to return EPERM in this case?
return {};
}
if (!eflag)
semaphore_lock lock(flag.mutex);
if (flag.pattern.atomic_op(lv2_event_flag::check_pattern, bitptn, mode, &ppu.gpr[6]))
{
return {};
}
if (flag.type == SYS_SYNC_WAITER_SINGLE && flag.sq.size())
{
return CELL_EPERM;
}
flag.waiters++;
flag.sq.emplace_back(&ppu);
return CELL_EBUSY;
});
if (!flag)
{
return CELL_ESRCH;
}
if (eflag->type == SYS_SYNC_WAITER_SINGLE && eflag->sq.size() > 0)
if (flag.ret)
{
return CELL_EPERM;
if (flag.ret != CELL_EBUSY)
{
return flag.ret;
}
}
if (eflag->check_pattern(bitptn, mode))
else
{
const u64 pattern = eflag->clear_pattern(bitptn, mode);
if (result) *result = pattern;
if (result) *result = ppu.gpr[6];
return CELL_OK;
}
// add waiter; protocol is ignored in current implementation
sleep_entry<cpu_thread> waiter(eflag->sq, ppu);
// SLEEP
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)
{
if (result) *result = eflag->pattern;
semaphore_lock lock(flag->mutex);
return CELL_ETIMEDOUT;
if (!flag->unqueue(flag->sq, &ppu))
{
timeout = 0;
continue;
}
flag->waiters--;
if (result) *result = flag->pattern;
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();
}
}
// load pattern saved upon signaling
if (result)
{
*result = ppu.gpr[4];
}
// check cause
if (ppu.gpr[5] == 0)
{
return CELL_ECANCELED;
}
return CELL_OK;
if (result) *result = ppu.gpr[6];
return not_an_error(ppu.gpr[5] ? CELL_OK : CELL_ECANCELED);
}
s32 sys_event_flag_trywait(u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result)
error_code sys_event_flag_trywait(u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result)
{
sys_event_flag.trace("sys_event_flag_trywait(id=0x%x, bitptn=0x%llx, mode=0x%x, result=*0x%x)", id, bitptn, mode, result);
LV2_LOCK;
if (result) *result = 0; // This is very annoying.
if (result) *result = 0;
if (!lv2_event_flag::check_mode(mode))
{
@ -199,129 +192,164 @@ s32 sys_event_flag_trywait(u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result)
return CELL_EINVAL;
}
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(id);
u64 pattern;
if (!eflag)
const auto flag = idm::check<lv2_obj, lv2_event_flag>(id, [&](lv2_event_flag& flag)
{
return flag.pattern.atomic_op(lv2_event_flag::check_pattern, bitptn, mode, &pattern);
});
if (!flag)
{
return CELL_ESRCH;
}
if (eflag->check_pattern(bitptn, mode))
if (!flag.ret)
{
const u64 pattern = eflag->clear_pattern(bitptn, mode);
return not_an_error(CELL_EBUSY);
}
if (result) *result = pattern;
if (result) *result = pattern;
return CELL_OK;
}
error_code sys_event_flag_set(u32 id, u64 bitptn)
{
// Warning: may be called from SPU thread.
sys_event_flag.trace("sys_event_flag_set(id=0x%x, bitptn=0x%llx)", id, bitptn);
const auto flag = idm::get<lv2_obj, lv2_event_flag>(id);
if (!flag)
{
return CELL_ESRCH;
}
if ((flag->pattern & bitptn) == bitptn)
{
return CELL_OK;
}
return CELL_EBUSY;
}
semaphore_lock lock(flag->mutex);
s32 sys_event_flag_set(u32 id, u64 bitptn)
{
sys_event_flag.trace("sys_event_flag_set(id=0x%x, bitptn=0x%llx)", id, bitptn);
LV2_LOCK;
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(id);
if (!eflag)
// Sort sleep queue in required order
if (flag->protocol != SYS_SYNC_FIFO)
{
return CELL_ESRCH;
std::stable_sort(flag->sq.begin(), flag->sq.end(), [](cpu_thread* a, cpu_thread* b)
{
return static_cast<ppu_thread*>(a)->prio < static_cast<ppu_thread*>(b)->prio;
});
}
if (bitptn && ~eflag->pattern.fetch_or(bitptn) & bitptn)
// Process all waiters in single atomic op
flag->pattern.atomic_op([&](u64& value)
{
eflag->notify_all(lv2_lock);
}
value |= bitptn;
for (auto cpu : flag->sq)
{
auto& ppu = static_cast<ppu_thread&>(*cpu);
const u64 pattern = ppu.gpr[4];
const u64 mode = ppu.gpr[5];
ppu.gpr[3] = lv2_event_flag::check_pattern(value, pattern, mode, &ppu.gpr[6]);
}
});
// Remove waiters
const auto tail = std::remove_if(flag->sq.begin(), flag->sq.end(), [&](cpu_thread* cpu)
{
auto& ppu = static_cast<ppu_thread&>(*cpu);
if (ppu.gpr[3])
{
flag->waiters--;
ppu.set_signal();
return true;
}
return false;
});
flag->sq.erase(tail, flag->sq.end());
return CELL_OK;
}
s32 sys_event_flag_clear(u32 id, u64 bitptn)
error_code sys_event_flag_clear(u32 id, u64 bitptn)
{
sys_event_flag.trace("sys_event_flag_clear(id=0x%x, bitptn=0x%llx)", id, bitptn);
LV2_LOCK;
const auto flag = idm::check<lv2_obj, lv2_event_flag>(id, [&](lv2_event_flag& flag)
{
flag.pattern &= bitptn;
});
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(id);
if (!eflag)
if (!flag)
{
return CELL_ESRCH;
}
eflag->pattern &= bitptn;
return CELL_OK;
}
s32 sys_event_flag_cancel(u32 id, vm::ptr<u32> num)
error_code sys_event_flag_cancel(u32 id, vm::ptr<u32> num)
{
sys_event_flag.trace("sys_event_flag_cancel(id=0x%x, num=*0x%x)", id, num);
LV2_LOCK;
if (num) *num = 0;
if (num)
{
*num = 0;
}
const auto flag = idm::get<lv2_obj, lv2_event_flag>(id);
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(id);
if (!eflag)
if (!flag)
{
return CELL_ESRCH;
}
if (num)
{
*num = static_cast<u32>(eflag->sq.size());
}
semaphore_lock lock(flag->mutex);
const u64 pattern = eflag->pattern;
// Get current pattern
const u64 pattern = flag->pattern;
// signal all threads to return CELL_ECANCELED
for (auto& thread : eflag->sq)
// Set count
*num = ::size32(flag->sq);
// Signal all threads to return CELL_ECANCELED
while (auto thread = flag->schedule<ppu_thread>(flag->sq, flag->protocol))
{
auto& ppu = static_cast<ppu_thread&>(*thread);
// save existing pattern
ppu.gpr[4] = pattern;
// clear "mode" as a sign of cancellation
ppu.gpr[5] = 0;
thread->set_signal();
flag->waiters--;
}
eflag->sq.clear();
return CELL_OK;
}
s32 sys_event_flag_get(u32 id, vm::ptr<u64> flags)
error_code sys_event_flag_get(u32 id, vm::ptr<u64> flags)
{
sys_event_flag.trace("sys_event_flag_get(id=0x%x, flags=*0x%x)", id, flags);
LV2_LOCK;
if (!flags)
{
return CELL_EFAULT;
}
const auto eflag = idm::get<lv2_obj, lv2_event_flag>(id);
if (!eflag)
const auto flag = idm::check<lv2_obj, lv2_event_flag>(id, [](lv2_event_flag& flag)
{
*flags = 0; // This is very annoying.
return +flag.pattern;
});
if (!flag)
{
*flags = 0;
return CELL_ESRCH;
}
*flags = eflag->pattern;
*flags = flag.ret;
return CELL_OK;
}

70
rpcs3/Emu/Cell/lv2/sys_event_flag.h
View File

@ -40,9 +40,10 @@ struct lv2_event_flag final : lv2_obj
const s32 type;
const u64 name;
semaphore<> mutex;
atomic_t<u32> waiters{0};
atomic_t<u64> pattern;
sleep_queue<cpu_thread> sq;
std::deque<cpu_thread*> sq;
lv2_event_flag(u32 protocol, s32 type, u64 name, u64 pattern)
: protocol(protocol)
@ -55,7 +56,8 @@ struct lv2_event_flag final : lv2_obj
{
}
static inline bool check_mode(u32 mode)
// Check mode arg
static bool check_mode(u32 mode)
{
switch (mode & 0xf)
{
@ -75,54 +77,46 @@ struct lv2_event_flag final : lv2_obj
return true;
}
bool check_pattern(u64 bitptn, u32 mode)
// Check and clear pattern (must be atomic op)
static bool check_pattern(u64& pattern, u64 bitptn, u64 mode, u64* result)
{
if ((mode & 0xf) == SYS_EVENT_FLAG_WAIT_AND)
// Write pattern
if (result)
{
return (pattern & bitptn) == bitptn;
*result = pattern;
}
else if ((mode & 0xf) == SYS_EVENT_FLAG_WAIT_OR)
{
return (pattern & bitptn) != 0;
}
else
{
fmt::throw_exception("Unknown mode (0x%x)" HERE, mode);
}
}
u64 clear_pattern(u64 bitptn, u32 mode)
{
// Check pattern
if ((mode & 0xf) == SYS_EVENT_FLAG_WAIT_AND && (pattern & bitptn) != bitptn ||
(mode & 0xf) == SYS_EVENT_FLAG_WAIT_OR && (pattern & bitptn) == 0)
{
return false;
}
// Clear pattern if necessary
if ((mode & ~0xf) == SYS_EVENT_FLAG_WAIT_CLEAR)
{
return pattern.fetch_and(~bitptn);
pattern &= ~bitptn;
}
else if ((mode & ~0xf) == SYS_EVENT_FLAG_WAIT_CLEAR_ALL)
{
return pattern.exchange(0);
pattern = 0;
}
else if ((mode & ~0xf) == 0)
{
return pattern;
}
else
{
fmt::throw_exception("Unknown mode (0x%x)" HERE, mode);
}
}
void notify_all(lv2_lock_t);
return true;
}
};
// Aux
class ppu_thread;
// SysCalls
s32 sys_event_flag_create(vm::ps3::ptr<u32> id, vm::ps3::ptr<sys_event_flag_attribute_t> attr, u64 init);
s32 sys_event_flag_destroy(u32 id);
s32 sys_event_flag_wait(ppu_thread& ppu, u32 id, u64 bitptn, u32 mode, vm::ps3::ptr<u64> result, u64 timeout);
s32 sys_event_flag_trywait(u32 id, u64 bitptn, u32 mode, vm::ps3::ptr<u64> result);
s32 sys_event_flag_set(u32 id, u64 bitptn);
s32 sys_event_flag_clear(u32 id, u64 bitptn);
s32 sys_event_flag_cancel(u32 id, vm::ps3::ptr<u32> num);
s32 sys_event_flag_get(u32 id, vm::ps3::ptr<u64> flags);
// Syscalls
error_code sys_event_flag_create(vm::ps3::ptr<u32> id, vm::ps3::ptr<sys_event_flag_attribute_t> attr, u64 init);
error_code sys_event_flag_destroy(u32 id);
error_code sys_event_flag_wait(ppu_thread& ppu, u32 id, u64 bitptn, u32 mode, vm::ps3::ptr<u64> result, u64 timeout);
error_code sys_event_flag_trywait(u32 id, u64 bitptn, u32 mode, vm::ps3::ptr<u64> result);
error_code sys_event_flag_set(u32 id, u64 bitptn);
error_code sys_event_flag_clear(u32 id, u64 bitptn);
error_code sys_event_flag_cancel(u32 id, vm::ps3::ptr<u32> num);
error_code sys_event_flag_get(u32 id, vm::ps3::ptr<u64> flags);

3
rpcs3/Gui/KernelExplorer.cpp
View File

@ -229,7 +229,8 @@ void KernelExplorer::Update()
case SYS_EVENT_FLAG_OBJECT:
{
auto& ef = static_cast<lv2_event_flag&>(obj);
m_tree->AppendItem(node, fmt::format("Event Flag: ID = 0x%08x \"%s\", Type = 0x%x, Pattern = 0x%llx", id, +name64(ef.name), ef.type, ef.pattern.load()));
m_tree->AppendItem(node, fmt::format("Event Flag: ID = 0x%08x \"%s\", Type = 0x%x, Pattern = 0x%llx, Wq = %zu", id, +name64(ef.name),
ef.type, ef.pattern.load(), +ef.waiters));
break;
}
default: