void checkLwMutex(int doDispatch) {
SceLwMutexWorkarea workarea;
dispatchCheckpoint("sceKernelCreateLwMutex: %08x", sceKernelCreateLwMutex(&workarea, "lwmutex", 0, 1, NULL));
dispatchCheckpoint("sceKernelUnlockLwMutex: %08x", sceKernelUnlockLwMutex(&workarea, 1));
dispatchCheckpoint("sceKernelLockLwMutex: %08x", sceKernelLockLwMutex(&workarea, 1, NULL));
dispatchCheckpoint("sceKernelLockLwMutex invalid: %08x", sceKernelLockLwMutex(&workarea, -1, NULL));
dispatchCheckpoint("sceKernelDeleteLwMutex: %08x", sceKernelDeleteLwMutex(&workarea));
dispatchCheckpoint("sceKernelCreateLwMutex: %08x", sceKernelCreateLwMutex(&workarea, "lwmutex", 0, 1, NULL));
startLockThreadLwMutex(&workarea);
int state;
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
SceUInt timeout = 300;
dispatchCheckpoint("sceKernelLockLwMutex: %08x", sceKernelLockLwMutex(&workarea, 1, &timeout));
dispatchCheckpoint("sceKernelUnlockLwMutex: %08x", sceKernelUnlockLwMutex(&workarea, 1));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
endLockThreadLwMutex(&workarea);
dispatchCheckpoint("sceKernelTryLockLwMutex: %08x", sceKernelTryLockLwMutex_600(&workarea, 1));
dispatchCheckpoint("sceKernelDeleteLwMutex: %08x", sceKernelDeleteLwMutex(&workarea));
}
void execPriorityTests(int attr, int deleteInstead) {
SceUID threads[5];
int test[5] = {1, 2, 3, 4, 5};
int result;
sceKernelCreateLwMutex(&workarea, "mutex1", attr, 1, NULL);
int i;
for (i = 0; i < 5; i++) {
threads[i] = CREATE_PRIORITY_THREAD(threadFunction, 0x16 - i);
sceKernelStartThread(threads[i], sizeof(int), (void*)&test[i]);
}
// This one intentionally is an invalid unlock.
sceKernelDelayThread(1000);
printf("Unlocking...\n");
result = sceKernelUnlockLwMutex(&workarea, 2);
sceKernelDelayThread(5000);
printf("Unlocked 2? %08X\n", result);
if (!deleteInstead)
{
sceKernelDelayThread(1000);
printf("Unlocking...\n");
result = sceKernelUnlockLwMutex(&workarea, 1);
sceKernelDelayThread(5000);
printf("Unlocked 1? %08X\n", result);
}
sceKernelDelayThread(1000);
printf("Delete: %08X\n", sceKernelDeleteLwMutex(&workarea));
printf("\n\n");
}
int main(int argc, char **argv) {
SceLwMutexWorkarea workarea, workarea1, workarea2;
int result1, result2;
// Crash.
//CREATE_TEST("NULL workarea", NULL, "test", 0, 0, NULL);
CREATE_TEST("NULL name", &workarea, NULL, 0, 0, NULL);
CREATE_TEST("Blank name", &workarea, "", 0, 0, NULL);
CREATE_TEST("Long name", &workarea, "1234567890123456789012345678901234567890123456789012345678901234", 0, 0, NULL);
CREATE_TEST("Weird attr", &workarea, "create", 1, 0, NULL);
CREATE_TEST("0x100 attr", &workarea, "create", 0x100, 0, NULL);
CREATE_TEST("0x200 attr", &workarea, "create", 0x200, 0, NULL);
CREATE_TEST("0x300 attr", &workarea, "create", 0x300, 0, NULL);
CREATE_TEST("0x3FF attr", &workarea, "create", 0x3FF, 0, NULL);
CREATE_TEST("0x400 attr", &workarea, "create", 0x400, 0, NULL);
CREATE_TEST("Positive count", &workarea, "create", 0, 1, NULL);
CREATE_TEST("Negative count", &workarea, "create", 0, -1, NULL);
CREATE_TEST("Count = -5", &workarea, "create", 0, -5, NULL);
CREATE_TEST("Count = 2", &workarea, "create", 0, 2, NULL);
CREATE_TEST("Negative count (recursive)", &workarea, "create", 0x200, -1, NULL);
CREATE_TEST("Count = -5 (recursive)", &workarea, "create", 0x200, -5, NULL);
CREATE_TEST("Count = 2 (recursive)", &workarea, "create", 0x200, 2, NULL);
CREATE_TEST("Medium count (recursive)", &workarea, "create", 0x200, 255, NULL);
CREATE_TEST("Large count (recursive)", &workarea, "create", 0x200, 65537, NULL);
result1 = sceKernelCreateLwMutex(&workarea1, "create", 0, 0, NULL);
result2 = sceKernelCreateLwMutex(&workarea2, "create", 0, 0, NULL);
if (result1 == 0 && result2 == 0) {
printf("Two with same name: OK\n");
} else {
printf("Two with same name: Failed (%X, %X)\n", result1, result2);
}
sceKernelDeleteLwMutex(&workarea1);
sceKernelDeleteLwMutex(&workarea2);
sceKernelCreateLwMutex(&workarea, "create1", 0, 0, NULL);
CREATE_TEST("Two with same workarea", &workarea, "create2", 0, 0, NULL);
// Leaks.
BASIC_SCHED_TEST("NULL name",
result = sceKernelCreateLwMutex(&workarea, NULL, 0, 0, NULL);
);
static void psp_audio_free(void *data)
{
SceUInt timeout = 100000;
psp_audio_t* psp = (psp_audio_t*)data;
if(!psp)
return;
psp->running = false;
#if defined(VITA)
sceKernelWaitThreadEnd(psp->thread, NULL, &timeout);
sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->lock);
sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->cond_lock);
sceKernelDeleteLwCond(&psp->cond);
#else
sceKernelWaitThreadEnd(psp->thread, &timeout);
#endif
free(psp->buffer);
sceKernelDeleteThread(psp->thread);
free(psp->zeroBuffer);
free(psp);
}
int main(int argc, char **argv) {
SceLwMutexWorkarea workarea, workarea1, workarea2;
sceKernelCreateLwMutex(&workarea, "delete", 0, 0, NULL);
DELETE_TEST("Normal", &workarea);
// Crash.
//DELETE_TEST("NULL", 0);
DELETE_TEST("Invalid", (void*) 0xDEADBEEF);
DELETE_TEST("Deleted", &workarea);
sceKernelCreateLwMutex(&workarea1, "delete", 0, 0, NULL);
memcpy(&workarea2, &workarea1, sizeof(SceLwMutexWorkarea));
sceKernelDeleteLwMutex(&workarea1);
DELETE_TEST("Copy", &workarea2);
FAKE_LWMUTEX(workarea, 0, 0);
DELETE_TEST("Fake", &workarea2);
BASIC_SCHED_TEST("Delete other",
result = sceKernelDeleteLwMutex(&workarea2);
);
void _free_vita_heap(void) {
// Destroy the sbrk mutex
sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)_newlib_sbrk_mutex);
// Free the heap memblock to avoid memory leakage.
sceKernelFreeMemBlock(_newlib_heap_memblock);
if(_newlib_vm_memblock)
sceKernelFreeMemBlock(_newlib_vm_memblock);
_newlib_vm_memblock = 0;
_newlib_heap_memblock = 0;
_newlib_heap_base = 0;
_newlib_heap_cur = 0;
}
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);
LOCK_TEST_TIMEOUT("Lock 0 => 0", PSP_MUTEX_ATTR_FIFO, 0, 0, 500);
LOCK_TEST_TIMEOUT("Lock 0 => 1", PSP_MUTEX_ATTR_FIFO, 0, 1, 500);
LOCK_TEST_TIMEOUT("Lock 0 => 2", PSP_MUTEX_ATTR_FIFO, 0, 2, 500);
LOCK_TEST_TIMEOUT("Lock 0 => -1", PSP_MUTEX_ATTR_FIFO, 0, -1, 500);
LOCK_TEST_TIMEOUT("Lock 1 => 1", PSP_MUTEX_ATTR_FIFO, 1, 1, 500);
LOCK_TEST_TIMEOUT("Lock 0 => 2 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, 2, 500);
LOCK_TEST_TIMEOUT("Lock 0 => -1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, -1, 500);
LOCK_TEST_TIMEOUT("Lock 1 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, 1, 500);
LOCK_TEST_TIMEOUT("Zero timeout", PSP_MUTEX_ATTR_FIFO, 0, 1, 0);
SceUID lockThread = CREATE_SIMPLE_THREAD(lockFunc);
LOCK_TEST_TIMEOUT_THREAD("Locked 1 => 1", PSP_MUTEX_ATTR_FIFO, 1, 1, 500);
LOCK_TEST_TIMEOUT_THREAD("Locked 0 => 1", PSP_MUTEX_ATTR_FIFO, 0, 1, 500);
LOCK_TEST_TIMEOUT_THREAD("Locked 1 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 1, 1, 500);
LOCK_TEST_TIMEOUT_THREAD("Locked 0 => 1 (recursive)", PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0, 1, 500);
LOCK_TEST_TIMEOUT_THREAD("Locked zero timeout", PSP_MUTEX_ATTR_FIFO, 0, 1, 0);
SceUID deleteThread = CREATE_SIMPLE_THREAD(deleteMeFunc);
SceLwMutexWorkarea workarea;
void *workareaPtr = &workarea;
sceKernelCreateLwMutex(&workarea, "lock", 0, 1, NULL);
sceKernelStartThread(deleteThread, sizeof(void*), &workareaPtr);
sceKernelDelayThread(500);
sceKernelDeleteLwMutex(&workarea);
// Crash.
//LOCK_TEST_SIMPLE("NULL => 0", 0, 0);
//LOCK_TEST_SIMPLE("NULL => 1", 0, 1);
//LOCK_TEST_SIMPLE("Invalid => 1", (void*) 0xDEADBEEF, 1);
LOCK_TEST_SIMPLE("Deleted => 1", &workarea, 1);
BASIC_SCHED_TEST("Zero",
result = sceKernelLockLwMutex(&workarea2, 0, NULL);
);
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);
flushschedf();
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);
SceLwMutexWorkarea workarea;
sceKernelCreateLwMutex(&workarea, "lock", 0, 1, NULL);
void *workareaPtr = &workarea;
sceKernelStartThread(deleteThread, sizeof(int), &workareaPtr);
sceKernelDeleteLwMutex(&workarea);
flushschedf();
// Crashes.
//LOCK_TEST_SIMPLE("NULL => 0", 0, 0);
//LOCK_TEST_SIMPLE("NULL => 1", 0, 1);
//LOCK_TEST_SIMPLE("Invalid => 1", (void*) 0xDEADBEEF, 1);
LOCK_TEST_SIMPLE("Deleted => 1", &workarea, 1);
BASIC_SCHED_TEST("Zero",
result = sceKernelTryLockLwMutex(&workarea2, 0);
);
