Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
/*
** File: foreign.c
** Description: Testing various functions w/ foreign threads
**
** We create a thread and get it to call exactly one runtime function.
** The thread is allowed to be created by some other environment that
** NSPR, but it does not announce itself to the runtime prior to calling
** in.
**
** The goal: try to survive.
**
*/
#include "prcvar.h"
#include "prenv.h"
#include "prerror.h"
#include "prinit.h"
#include "prinrval.h"
#include "prio.h"
#include "prlock.h"
#include "prlog.h"
#include "prmem.h"
#include "prthread.h"
#include "prtypes.h"
#include "prprf.h"
#include "plgetopt.h"
#include <stdio.h>
#include <stdlib.h>
static enum {
thread_nspr,
thread_pthread,
thread_sproc,
thread_win32
} thread_provider;
typedef void (*StartFn)(void*);
typedef struct StartObject {
StartFn start;
void* arg;
} StartObject;
static PRFileDesc* output;
static int _debug_on = 0;
#define DEFAULT_THREAD_COUNT 10
#define DPRINTF(arg) \
if (_debug_on) PR_fprintf arg
#if defined(_PR_PTHREADS)
# include <pthread.h>
# include "md/_pth.h"
static void* pthread_start(void* arg) {
StartFn start = ((StartObject*)arg)->start;
void* data = ((StartObject*)arg)->arg;
PR_Free(arg);
start(data);
return NULL;
} /* pthread_start */
#endif /* defined(_PR_PTHREADS) */
#if defined(WIN32)
# include <windows.h>
# include <process.h> /* for _beginthreadex() */
static PRUintn __stdcall windows_start(void* arg) {
StartObject* so = (StartObject*)arg;
StartFn start = so->start;
void* data = so->arg;
PR_Free(so);
start(data);
return 0;
} /* windows_start */
#endif /* defined(WIN32) */
static PRStatus NSPRPUB_TESTS_CreateThread(StartFn start, void* arg) {
PRStatus rv;
switch (thread_provider) {
case thread_nspr: {
PRThread* thread =
PR_CreateThread(PR_USER_THREAD, start, arg, PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD, 0);
rv = (NULL == thread) ? PR_FAILURE : PR_SUCCESS;
} break;
case thread_pthread:
#if defined(_PR_PTHREADS)
{
int rv;
pthread_t id;
pthread_attr_t tattr;
StartObject* start_object;
start_object = PR_NEW(StartObject);
PR_ASSERT(NULL != start_object);
start_object->start = start;
start_object->arg = arg;
rv = _PT_PTHREAD_ATTR_INIT(&tattr);
PR_ASSERT(0 == rv);
rv = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
PR_ASSERT(0 == rv);
rv = pthread_attr_setstacksize(&tattr, 64 * 1024);
PR_ASSERT(0 == rv);
rv = _PT_PTHREAD_CREATE(&id, tattr, pthread_start, start_object);
(void)_PT_PTHREAD_ATTR_DESTROY(&tattr);
return (0 == rv) ? PR_SUCCESS : PR_FAILURE;
}
#else
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
rv = PR_FAILURE;
break;
#endif /* defined(_PR_PTHREADS) */
case thread_sproc:
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
rv = PR_FAILURE;
break;
case thread_win32:
#if defined(WIN32)
{
void* th;
PRUintn id;
StartObject* start_object;
start_object = PR_NEW(StartObject);
PR_ASSERT(NULL != start_object);
start_object->start = start;
start_object->arg = arg;
th = (void*)_beginthreadex(
NULL, /* LPSECURITY_ATTRIBUTES - pointer to thread security attributes
*/
0U, /* DWORD - initial thread stack size, in bytes */
windows_start, /* LPTHREAD_START_ROUTINE - pointer to thread function
*/
start_object, /* LPVOID - argument for new thread */
STACK_SIZE_PARAM_IS_A_RESERVATION, /*DWORD dwCreationFlags - creation
flags */
&id /* LPDWORD - pointer to returned thread identifier */);
rv = (NULL == th) ? PR_FAILURE : PR_SUCCESS;
}
#else
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
rv = PR_FAILURE;
#endif
break;
default:
PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
rv = PR_FAILURE;
}
return rv;
} /* NSPRPUB_TESTS_CreateThread */
static void PR_CALLBACK lazyEntry(void* arg) {
PR_ASSERT(NULL == arg);
} /* lazyEntry */
static void OneShot(void* arg) {
PRUintn pdkey;
PRLock* lock;
PRFileDesc* fd;
PRDir* dir;
PRFileDesc* pair[2];
PRIntn test = (PRIntn)arg;
for (test = 0; test < 12; ++test) {
switch (test) {
case 0:
lock = PR_NewLock();
DPRINTF((output, "Thread[0x%x] called PR_NewLock\n",
PR_GetCurrentThread()));
PR_DestroyLock(lock);
break;
case 1:
(void)PR_SecondsToInterval(1);
DPRINTF((output, "Thread[0x%x] called PR_SecondsToInterval\n",
PR_GetCurrentThread()));
break;
case 2:
(void)PR_CreateThread(PR_USER_THREAD, lazyEntry, NULL,
PR_PRIORITY_NORMAL, PR_LOCAL_THREAD,
PR_UNJOINABLE_THREAD, 0);
DPRINTF((output, "Thread[0x%x] called PR_CreateThread\n",
PR_GetCurrentThread()));
break;
case 3:
fd = PR_Open("foreign.tmp", PR_CREATE_FILE | PR_RDWR, 0666);
DPRINTF(
(output, "Thread[0x%x] called PR_Open\n", PR_GetCurrentThread()));
PR_Close(fd);
break;
case 4:
fd = PR_NewUDPSocket();
DPRINTF((output, "Thread[0x%x] called PR_NewUDPSocket\n",
PR_GetCurrentThread()));
PR_Close(fd);
break;
case 5:
fd = PR_NewTCPSocket();
DPRINTF((output, "Thread[0x%x] called PR_NewTCPSocket\n",
PR_GetCurrentThread()));
PR_Close(fd);
break;
case 6:
#define TEMP_DIR "./tmp"
PR_MkDir(TEMP_DIR, 0700);
dir = PR_OpenDir(TEMP_DIR);
DPRINTF((output, "Thread[0x%x] called PR_OpenDir\n",
PR_GetCurrentThread()));
PR_CloseDir(dir);
break;
case 7:
(void)PR_NewThreadPrivateIndex(&pdkey, NULL);
DPRINTF((output, "Thread[0x%x] called PR_NewThreadPrivateIndex\n",
PR_GetCurrentThread()));
break;
case 8:
(void)PR_GetEnv("PATH");
DPRINTF(
(output, "Thread[0x%x] called PR_GetEnv\n", PR_GetCurrentThread()));
break;
case 9:
(void)PR_NewTCPSocketPair(pair);
DPRINTF((output, "Thread[0x%x] called PR_NewTCPSocketPair\n",
PR_GetCurrentThread()));
PR_Close(pair[0]);
PR_Close(pair[1]);
break;
case 10:
PR_SetConcurrency(2);
DPRINTF((output, "Thread[0x%x] called PR_SetConcurrency\n",
PR_GetCurrentThread()));
break;
case 11:
PR_SetThreadPriority(PR_GetCurrentThread(), PR_PRIORITY_HIGH);
DPRINTF((output, "Thread[0x%x] called PR_SetThreadPriority\n",
PR_GetCurrentThread()));
break;
default:
break;
} /* switch() */
}
} /* OneShot */
int main(int argc, char** argv) {
PRStatus rv;
PRInt32 thread_cnt = DEFAULT_THREAD_COUNT;
PLOptStatus os;
PLOptState* opt = PL_CreateOptState(argc, argv, "dt:");
#if defined(WIN32)
thread_provider = thread_win32;
#elif defined(_PR_PTHREADS)
thread_provider = thread_pthread;
#else
thread_provider = thread_nspr;
#endif
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) {
if (PL_OPT_BAD == os) {
continue;
}
switch (opt->option) {
case 'd': /* debug mode */
_debug_on = 1;
break;
case 't': /* thread count */
thread_cnt = atoi(opt->value);
break;
default:
break;
}
}
PL_DestroyOptState(opt);
PR_SetConcurrency(2);
output = PR_GetSpecialFD(PR_StandardOutput);
while (thread_cnt-- > 0) {
rv = NSPRPUB_TESTS_CreateThread(OneShot, (void*)thread_cnt);
PR_ASSERT(PR_SUCCESS == rv);
PR_Sleep(PR_MillisecondsToInterval(5));
}
PR_Sleep(PR_SecondsToInterval(3));
return (PR_SUCCESS == PR_Cleanup()) ? 0 : 1;
} /* main */
/* foreign.c */