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 simpleTest() {
int mutexid;
printf("sceKernelCreateMutex:0x%08X\n", mutexid = sceKernelCreateMutex("test", PSP_MUTEX_ATTR_FIFO, 0));
{
printf("sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
printf("sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
printf("sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
}
int main(int argc, char **argv) {
SceUID mutex;
int i;
u32 options[32];
memset(options, 0, sizeof(options));
checkpointNext("Names:");
createTest(" NULL name", NULL, 0, 0, NULL);
createTest(" Blank name", "", 0, 0, NULL);
createTest(" Long name", "1234567890123456789012345678901234567890123456789012345678901234", 0, 0, NULL);
SceUID mutex1 = sceKernelCreateMutex("create", 0, 0, NULL);
SceUID mutex2 = sceKernelCreateMutex("create", 0, 0, NULL);
if (mutex1 > 0 && mutex2 > 0) {
checkpoint(" Two with same name: OK");
} else {
checkpoint(" Two with same name: Failed (%X, %X)", mutex1, mutex2);
}
sceKernelDeleteMutex(mutex1);
sceKernelDeleteMutex(mutex2);
checkpointNext("Attributes:");
const static int attrs[] = {1, 0x100, 0x200, 0x400, 0x800, 0xB00, 0xBFF, 0xC00, 0x1000, 0x2000, 0x4000, 0x8000, 0x10000};
for (i = 0; i < ARRAY_SIZE(attrs); ++i) {
char temp[32];
sprintf(temp, " %x", attrs[i]);
createTest(temp, "create", attrs[i], 0, NULL);
}
checkpointNext("Counts:");
createTest(" Negative count", "create", 0, -1, NULL);
createTest(" Positive count", "create", 0, 1, NULL);
createTest(" Large count", "create", 0, 65537, NULL);
checkpointNext("Option sizes:");
const static int optionSizes[] = {-1, 0, 1, 4, 8, 16, 32, 64, 256, 0x7FFFFFFF};
for (i = 0; i < ARRAY_SIZE(optionSizes); ++i) {
char temp[32];
sprintf(temp, " %d", optionSizes[i]);
options[0] = optionSizes[i];
createTest(temp, "create", 0, 1, options);
}
checkpointNext("Scheduling:");
BASIC_SCHED_TEST("NULL name",
mutex = sceKernelCreateMutex(NULL, 0, 0, NULL);
result = mutex > 0 ? 1 : mutex;
);
/***
* Shuts down the audio systems and frees the buffers.
*/
void audio_shutdown()
{
int i;
stop_audio = 1;
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (audio_status[i].ThreadHandle != -1)
{
sceKernelDeleteThread(audio_status[i].ThreadHandle);
}
audio_status[i].ThreadHandle = -1;
}
for (i = 0; i < AUDIO_CHANNELS; i++)
{
if (audio_status[i].Handle != -1)
{
sceAudioOutReleasePort(audio_status[i].Handle);
audio_status[i].Handle = -1;
}
}
free_buffers();
sceKernelDeleteMutex(audio_mutex);
}
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 ftp_fini()
{
if (ftp_initialized) {
/* In order to "stop" the blocking sceNetAccept,
* we have to close the server socket; this way
* the accept call will return an error */
sceNetSocketClose(server_sockfd);
/* Wait until the server threads ends */
sceKernelWaitThreadEnd(server_thid, NULL, NULL);
/* To close the clients we have to do the same:
* we have to iterate over all the clients
* and shutdown their sockets */
client_list_thread_end();
/* Delete the client list mutex */
sceKernelDeleteMutex(client_list_mtx);
client_list = NULL;
sceNetCtlTerm();
sceNetTerm();
if (net_memory) {
free(net_memory);
net_memory = NULL;
}
ftp_initialized = 0;
}
}
void recursiveTest() {
int mutexid;
printf("sceKernelCreateMutex:0x%08X\n", mutexid = sceKernelCreateMutex("test", PSP_MUTEX_ATTR_FIFO | PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0));
{
printf("[0]sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
{
printf("[1]sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
{
printf("[2]sceKernelLockMutex:0x%08X\n", sceKernelLockMutex(mutexid, 1, NULL));
printf("[2]sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("[1]sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("[0]sceKernelUnlockMutex:0x%08X\n", sceKernelUnlockMutex(mutexid, 1));
}
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
printf("sceKernelDeleteMutex:0x%08X\n", sceKernelDeleteMutex(mutexid));
}
inline void createTest(const char *title, const char *name, u32 attr, int count, void *options) {
SceUID mutex = sceKernelCreateMutex(name, attr, count, options);
if (mutex > 0) {
checkpoint(NULL);
schedf("%s: ", title);
schedfMutex(mutex);
sceKernelDeleteMutex(mutex);
} else {
checkpoint("%s: Failed (%X)", title, mutex);
}
}
void console_fini()
{
if (console_initialzed) {
sceKernelDeleteMutex(console_mtx);
sceNetSocketClose(sock);
sceNetTerm();
if (net_memory) {
free(net_memory);
net_memory = NULL;
}
}
}
void multipleTest() {
int threads[N_THREADS];
int n;
semaid = sceKernelCreateSema("sema1", 0, 0, 255, NULL);
mutexid = sceKernelCreateMutex("mutex", PSP_MUTEX_ATTR_FIFO | PSP_MUTEX_ATTR_ALLOW_RECURSIVE, 0);
{
for (n = 0; n < N_THREADS; n++) {
sceKernelStartThread(threads[n] = sceKernelCreateThread("multipleTestThread", (void *)&multipleTestThread, 0x12, 0x10000, 0, NULL), sizeof(int), &n);
}
sceKernelSignalSema(semaid, N_THREADS);
for (n = 0; n < N_THREADS; n++) {
sceKernelWaitThreadEnd(threads[n], NULL);
}
}
sceKernelDeleteMutex(mutexid);
}
