#include "prototypes.h"
#include <stdarg.h>
-
+
#ifdef _EMPTH_POSIX
static pthread_key_t ctx_key;
static int empth_flags;
-static char **udata; /* pointer to out global context */
+static char **udata; /* pointer to out global context */
-static pthread_mutex_t mtx_ctxsw; /* thread in critical section */
+static pthread_mutex_t mtx_ctxsw; /* thread in critical section */
#if 0
extern emp_sig_t panic();
extern emp_sig_t shutdwn();
-
- /* actually it should inherit all this from main but... */
+
+ /* actually it should inherit all this from main but... */
#ifdef SA_SIGINFO
act.sa_flags = SA_SIGINFO;
#endif
- sigemptyset (&act.sa_mask);
+ sigemptyset(&act.sa_mask);
act.sa_handler = shutdwn;
- /* pthreads on Linux use SIGUSR1 (*shrug*) so only catch it if not on
- a Linux box running POSIX threads -- STM */
+ /* pthreads on Linux use SIGUSR1 (*shrug*) so only catch it if not on
+ a Linux box running POSIX threads -- STM */
#if !(defined(__linux__) && defined(_EMPTH_POSIX))
- sigaction (SIGUSR1, &act, NULL);
+ sigaction(SIGUSR1, &act, NULL);
#endif
- sigaction (SIGTERM, &act, NULL);
- sigaction (SIGINT, &act, NULL);
+ sigaction(SIGTERM, &act, NULL);
+ sigaction(SIGINT, &act, NULL);
act.sa_handler = panic;
- sigaction (SIGBUS, &act, NULL);
- sigaction (SIGSEGV, &act, NULL);
- sigaction (SIGILL, &act, NULL);
- sigaction (SIGFPE, &act, NULL);
+ sigaction(SIGBUS, &act, NULL);
+ sigaction(SIGSEGV, &act, NULL);
+ sigaction(SIGILL, &act, NULL);
+ sigaction(SIGFPE, &act, NULL);
act.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &act, NULL);
((empth_t *)ctx)->ep(((empth_t *)ctx)->ud);
empth_exit();
return NULL;
-}
-
+}
+
static void
empth_status(char *format, ...)
{
- va_list ap;
- static struct timeval startTime;
- struct timeval tv;
- char buf[1024];
- int sec, msec;
- empth_t *a;
-
- va_start(ap, format);
- if (empth_flags & EMPTH_PRINT) {
- if (startTime.tv_sec == 0)
- gettimeofday(&startTime, 0);
- gettimeofday(&tv, 0);
- sec = tv.tv_sec - startTime.tv_sec;
- msec = (tv.tv_usec - startTime.tv_usec) / 1000;
- if (msec < 0) {
- sec++;
- msec += 1000;
- }
- vsprintf(buf, format, ap);
- a = empth_self();
- printf("%d:%02d.%03d %17s: %s\n", sec/60, sec%60, msec/10,
- a->name,
- buf);
-
+ va_list ap;
+ static struct timeval startTime;
+ struct timeval tv;
+ char buf[1024];
+ int sec, msec;
+ empth_t *a;
+
+ va_start(ap, format);
+ if (empth_flags & EMPTH_PRINT) {
+ if (startTime.tv_sec == 0)
+ gettimeofday(&startTime, 0);
+ gettimeofday(&tv, 0);
+ sec = tv.tv_sec - startTime.tv_sec;
+ msec = (tv.tv_usec - startTime.tv_usec) / 1000;
+ if (msec < 0) {
+ sec++;
+ msec += 1000;
}
- va_end(ap);
+ vsprintf(buf, format, ap);
+ a = empth_self();
+ printf("%d:%02d.%03d %17s: %s\n", sec / 60, sec % 60, msec / 10,
+ a->name, buf);
+
+ }
+ va_end(ap);
}
int
-empth_init (char **ctx_ptr, int flags)
+empth_init(char **ctx_ptr, int flags)
{
empth_t *ctx;
struct sigaction act;
-
- pthread_key_create(&ctx_key, 0);
+
+ pthread_key_create(&ctx_key, 0);
#ifdef _DECTHREADS_
pthread_mutex_init(&mtx_ctxsw, pthread_mutexattr_default);
#else
pthread_mutex_init(&mtx_ctxsw, 0);
#endif
-
+
act.sa_flags = 0;
- sigemptyset (&act.sa_mask);
+ sigemptyset(&act.sa_mask);
act.sa_handler = empth_alarm;
sigaction(SIGALRM, &act, NULL);
-
+
udata = ctx_ptr;
ctx = (empth_t *)malloc(sizeof(empth_t));
- if(!ctx) {
+ if (!ctx) {
logerror("pthread init failed: not enough memory");
exit(1);
}
ctx->ep = 0;
ctx->ud = 0;
ctx->id = pthread_self();
- ctx->state = 0;
+ ctx->state = 0;
pthread_setspecific(ctx_key, ctx);
- pthread_mutex_lock(&mtx_ctxsw);
+ pthread_mutex_lock(&mtx_ctxsw);
empth_flags = flags;
logerror("pthreads initialized");
return 0;
}
-
+
/*
* prio can be used for setting scheeduling policy but...
* it seems to be optional in POSIX threads and Solaris
* More then that priority is not needed even in lwp threads.
*/
empth_t *
-empth_create (int prio, void (*entry)(), int size, int flags,
- char *name, char *desc, void *ud)
+empth_create(int prio, void (*entry) (), int size, int flags,
+ char *name, char *desc, void *ud)
{
pthread_t t;
pthread_attr_t attr;
empth_t *ctx;
int eno;
-
+
empth_status("creating new thread %s:%s", name, desc);
-
+
ctx = (empth_t *)malloc(sizeof(empth_t));
- if(!ctx) {
- logerror("not enough memoty to create thread: %s (%s)", name, desc);
+ if (!ctx) {
+ logerror("not enough memoty to create thread: %s (%s)", name,
+ desc);
return NULL;
}
ctx->name = strdup(name);
ctx->desc = strdup(desc);
ctx->ud = ud;
- ctx->state = 0;
+ ctx->state = 0;
ctx->ep = entry;
#ifdef _DECTHREADS_
#else
eno = pthread_attr_init(&attr);
#endif
- if(eno) {
+ if (eno) {
logerror("can not create thread attribute %s (%s): %s", name, desc,
strerror(eno));
goto bad;
}
-
#if defined(__linux__)
- /* Linux doesn't let you adjust the stack */
+ /* Linux doesn't let you adjust the stack */
#elif defined(_DECTHREADS_)
/* DEC does not have PTHREAD_STACK_MIN constant */
/* Do not go below default size */
- if(size > pthread_attr_getstacksize(attr))
- pthread_attr_setstacksize(&attr, size);
+ if (size > pthread_attr_getstacksize(attr))
+ pthread_attr_setstacksize(&attr, size);
#else
- if(size < PTHREAD_STACK_MIN)
- size = PTHREAD_STACK_MIN + 1;
+ if (size < PTHREAD_STACK_MIN)
+ size = PTHREAD_STACK_MIN + 1;
pthread_attr_setstacksize(&attr, size);
#endif
-
- pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
#ifdef _DECTHREADS_
eno = pthread_create(&t, attr, empth_start, (void *)ctx) ? errno : 0;
eno = pthread_create(&t, &attr, empth_start, (void *)ctx);
#endif
if (eno) {
- logerror("can not create thread: %s (%s): %s", name, desc,
- strerror(eno));
- goto bad;
+ logerror("can not create thread: %s (%s): %s", name, desc,
+ strerror(eno));
+ goto bad;
}
empth_status("new thread id is %d", t);
return ctx;
pthread_attr_destroy(&attr);
-bad:
+ bad:
pthread_attr_destroy(&attr);
free(ctx);
return NULL;
empth_t *ctx_ptr;
#ifdef _DECTHREADS_
- pthread_getspecific(ctx_key, (pthread_addr_t *)&ctx_ptr);
+ pthread_getspecific(ctx_key, (pthread_addr_t *) & ctx_ptr);
#else
ctx_ptr = (empth_t *)pthread_getspecific(ctx_key);
#endif
}
#endif
-static void
+static void
empth_restorectx(void)
{
empth_t *ctx_ptr;
-
+
#ifdef _DECTHREADS_
- pthread_getspecific(ctx_key, (pthread_addr_t *)&ctx_ptr);
+ pthread_getspecific(ctx_key, (pthread_addr_t *) & ctx_ptr);
#else
ctx_ptr = (empth_t *)pthread_getspecific(ctx_key);
#endif
empth_self(void)
{
#ifdef _DECTHREADS_
- empth_t *ctx_ptr;
-
- pthread_getspecific(ctx_key, (pthread_addr_t *)&ctx_ptr);
- return ctx_ptr;
+ empth_t *ctx_ptr;
+
+ pthread_getspecific(ctx_key, (pthread_addr_t *) & ctx_ptr);
+ return ctx_ptr;
#else
- return (empth_t *)pthread_getspecific(ctx_key);
+ return (empth_t *)pthread_getspecific(ctx_key);
#endif
}
void
-empth_exit (void)
+empth_exit(void)
{
empth_t *ctx_ptr;
pthread_mutex_unlock(&mtx_ctxsw);
empth_status("empth_exit");
#ifdef _DECTHREADS_
- pthread_getspecific(ctx_key, (pthread_addr_t *)&ctx_ptr);
+ pthread_getspecific(ctx_key, (pthread_addr_t *) & ctx_ptr);
#else
ctx_ptr = (empth_t *)pthread_getspecific(ctx_key);
#endif
- /* We want to leave the main thread around forever, until it's time
- for it to die for real (in a shutdown) */
+ /* We want to leave the main thread around forever, until it's time
+ for it to die for real (in a shutdown) */
if (!strcmp(ctx_ptr->name, "Main")) {
- while(1) {
+ while (1) {
#ifdef _DECTHREADS_
- pthread_yield();
+ pthread_yield();
#endif
- sleep(60);
- }
+ sleep(60);
+ }
}
free(ctx_ptr);
pthread_exit(0);
}
-
+
void
-empth_yield (void)
+empth_yield(void)
{
pthread_mutex_unlock(&mtx_ctxsw);
- sleep(10); /* take a nap pthread_yield(); */
+ sleep(10); /* take a nap pthread_yield(); */
pthread_mutex_lock(&mtx_ctxsw);
empth_restorectx();
}
empth_terminate(empth_t *a)
{
/* logerror("calling non supported function empth_terminate: %s:%d",
- __FILE__, __LINE__); */
+ __FILE__, __LINE__); */
empth_status("killing thread %s", a->name);
a->state = EMPTH_KILLED;
#ifndef _DECTHREADS_
/* DEC and OSX do not have pthread_kill. Not sure that cancel is correct. */
- #if (!defined __ppc__)
- pthread_kill(a->id, SIGALRM);
- #endif
+#if (!defined __ppc__)
+ pthread_kill(a->id, SIGALRM);
+#endif
#endif
- return;
+ return;
}
void
fd_set writemask;
struct timeval tv;
int n;
-
+
pthread_mutex_unlock(&mtx_ctxsw);
empth_status("%s select on %d",
- flags == EMPTH_FD_READ ? "read" : "write", fd );
+ flags == EMPTH_FD_READ ? "read" : "write", fd);
while (1) {
tv.tv_sec = 1000000;
tv.tv_usec = 0;
FD_ZERO(&readmask);
FD_ZERO(&writemask);
-
- switch(flags) {
+
+ switch (flags) {
case EMPTH_FD_READ:
FD_SET(fd, &readmask);
break;
empth_exit();
}
- n = select(fd + 1, &readmask, &writemask, (fd_set *)0, &tv);
-
+ n = select(fd + 1, &readmask, &writemask, (fd_set *) 0, &tv);
+
if (n < 0) {
if (errno == EINTR) {
/* go handle the signal */
}
/* strange but we dont get EINTR on select broken by signal */
empth_status("select failed (%s)", strerror(errno));
- goto done;
+ goto done;
return;
}
-
+
if (flags == EMPTH_FD_READ && FD_ISSET(fd, &readmask)) {
empth_status("input ready");
break;
break;
}
}
-
-done:
+
+ done:
pthread_mutex_lock(&mtx_ctxsw);
empth_restorectx();
-
+
}
#ifdef SA_RESTART
act.sa_flags &= ~SA_RESTART;
#endif
- sigemptyset (&act.sa_mask);
+ sigemptyset(&act.sa_mask);
act.sa_handler = empth_alarm;
sigaction(SIGALRM, &act, NULL);
}
{
empth_status("waking up thread %s", a->name);
#ifndef _DECTHREADS_
- #if (!defined __ppc__)
- pthread_kill(a->id, SIGALRM);
- #endif
+#if (!defined __ppc__)
+ pthread_kill(a->id, SIGALRM);
+#endif
#endif
empth_status("waiting for it to run");
/* empth_yield(); */
tv.tv_sec = until - time(NULL);
tv.tv_usec = 0;
do {
- select (0, NULL, NULL, NULL, &tv);
+ select(0, NULL, NULL, NULL, &tv);
} while ((tv.tv_sec = until - time(NULL)) > 0);
empth_status("sleep done. Waiting for lock");
pthread_mutex_lock(&mtx_ctxsw);
empth_sem_t *sm;
sm = (empth_sem_t *)malloc(sizeof(empth_sem_t));
- if(!sm) {
+ if (!sm) {
logerror("out of memory at %s:%d", __FILE__, __LINE__);
return NULL;
}
- strncpy(sm->name, name, sizeof(sm->name)-1);
+ strncpy(sm->name, name, sizeof(sm->name) - 1);
sm->count = cnt;
#ifdef _DECTHREADS_
pthread_mutex_init(&sm->mtx_update, pthread_mutexattr_default);
{
empth_status("signal on semaphore %s:%d", sm->name, sm->count);
pthread_mutex_lock(&sm->mtx_update);
- if(sm->count++ < 0) {
+ if (sm->count++ < 0) {
pthread_mutex_unlock(&sm->mtx_update);
pthread_mutex_lock(&sm->mtx_sem);
pthread_cond_signal(&sm->cnd_sem);
pthread_mutex_unlock(&sm->mtx_sem);
- }
- else
+ } else
pthread_mutex_unlock(&sm->mtx_update);
}
void
-empth_sem_wait (empth_sem_t *sm)
+empth_sem_wait(empth_sem_t *sm)
{
empth_status("wait on semaphore %s:%d", sm->name, sm->count);
pthread_mutex_lock(&sm->mtx_update);
- if(--sm->count < 0) {
+ if (--sm->count < 0) {
pthread_mutex_unlock(&sm->mtx_update);
empth_status("blocking");
pthread_mutex_unlock(&mtx_ctxsw);
pthread_mutex_unlock(&sm->mtx_sem);
pthread_mutex_lock(&mtx_ctxsw);
empth_restorectx();
- }
- else
+ } else
pthread_mutex_unlock(&sm->mtx_update);
}
projects / empserver / blobdiff