int main(int argc, char **argv) {
LOCK_TEST("Lock 0 => 0", PSP_MUTEX_ATTR_FIFO, 0, 0);
LOCK_TEST("Lock 0 => 1", PSP_MUTEX_ATTR_FIFO, 0, 1);
LOCK_TEST("Lock 0 => 2", PSP_MUTEX_ATTR_FIFO, 0, 2);
LOCK_TEST("Lock 0 => -1", PSP_MUTEX_ATTR_FIFO, 0, -1);
LOCK_TEST("Lock 1 => 1", PSP_MUTEX_ATTR_FIFO, 1, 1);
LOCK_TEST("Lock 0 => 2 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, 2);
LOCK_TEST("Lock 0 => -1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, -1);
LOCK_TEST("Lock 1 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, 1);
LOCK_TEST("Lock 1 => INT_MAX - 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, INT_MAX - 1);
LOCK_TEST("Lock 1 => INT_MAX (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, INT_MAX);
LOCK_TEST("Lock INT_MAX => INT_MAX (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, INT_MAX, INT_MAX);
SceUID lockThread = CREATE_SIMPLE_THREAD(lockFunc);
LOCK_TEST_THREAD("Locked 1 => 1", PSP_MUTEX_ATTR_FIFO, 1, 1);
LOCK_TEST_THREAD("Locked 0 => 1", PSP_MUTEX_ATTR_FIFO, 0, 1);
LOCK_TEST_THREAD("Locked 1 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, 1);
LOCK_TEST_THREAD("Locked 0 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, 1);
// Probably we can't manage to delete it at the same time.
SceUID deleteThread = CREATE_SIMPLE_THREAD(deleteMeFunc);
SceUID mutex = sceKernelCreateMutex("lock", 0, 1, NULL);
sceKernelStartThread(deleteThread, sizeof(int), &mutex);
sceKernelDeleteMutex(mutex);
LOCK_TEST_SIMPLE("NULL => 0", 0, 0);
LOCK_TEST_SIMPLE("NULL => 1", 0, 1);
LOCK_TEST_SIMPLE("Invalid => 1", 0xDEADBEEF, 1);
LOCK_TEST_SIMPLE("Deleted => 1", mutex, 1);
BASIC_SCHED_TEST("NULL",
result = sceKernelTryLockMutex(0, 1);
);
void checkMutex(int doDispatch) {
SceUID mutex = sceKernelCreateMutex("mutex", 0, 1, NULL);
dispatchCheckpoint("sceKernelCreateMutex: %08x", mutex >= 0 ? 1 : mutex);
dispatchCheckpoint("sceKernelUnlockMutex: %08x", sceKernelUnlockMutex(mutex, 1));
dispatchCheckpoint("sceKernelLockMutex: %08x", sceKernelLockMutex(mutex, 1, NULL));
dispatchCheckpoint("sceKernelLockMutex invalid: %08x", sceKernelLockMutex(mutex, -1, NULL));
dispatchCheckpoint("sceKernelDeleteMutex: %08x", sceKernelDeleteMutex(mutex));
mutex = sceKernelCreateMutex("test", 0, 1, NULL);
dispatchCheckpoint("sceKernelCreateMutex: %08x", mutex >= 0 ? 1 : mutex);
startLockThreadMutex(mutex);
int state;
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
SceUInt timeout = 300;
dispatchCheckpoint("sceKernelLockMutex: %08x", sceKernelLockMutex(mutex, 1, &timeout));
dispatchCheckpoint("sceKernelUnlockMutex: %08x", sceKernelUnlockMutex(mutex, 1));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
endLockThreadMutex(mutex);
dispatchCheckpoint("sceKernelTryLockMutex: %08x", sceKernelTryLockMutex(mutex, 1));
dispatchCheckpoint("sceKernelDeleteMutex: %08x", sceKernelDeleteMutex(mutex));
}
void console_print(const char *s)
{
int mtx_err = sceKernelTryLockMutex(console_mtx, 1);
netprintf(s);
if (mtx_err == SCE_KERNEL_OK) {
sceKernelUnlockMutex(console_mtx, 1);
}
}
int sub_1026()
{
int ret = 0;
volatile int* address = (int*)0xbfc00700;
if (*address == 0)
{
ret = sceKernelTryLockMutex(meRpc.mutex, 1);//check to see if the me is in use
if (ret >= 0)
sceKernelUnlockMutex(meRpc.mutex, 1);
}
else if (*address != -1)
*address = -2;
return ret;
}
static int deleteMeFunc(SceSize argSize, void* argPointer) {
int result = sceKernelTryLockMutex(*(int*) argPointer, 1);
printf("After delete: %08X\n", result);
return 0;
}
