empire/empserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Import of Empire 4.2.12

Browse source
This commit is contained in:
Markus Armbruster 2003-08-23 12:23:04 +00:00
commit d8b7fdfae1
817 changed files with 126589 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

60
src/lib/empthread/Makefile Normal file
View file

@ -0,0 +1,60 @@
#
# Empire - A multi-player, client/server Internet based war game.
# Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
# Ken Stevens, Steve McClure
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# ---
#
# See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
# related information and legal notices. It is expected that any future
# projects/authors will amend these files as needed.
#
# Makefile - Wolfpack, 1996
# Note that these could have been listed 1 per line, but I chose to just
# stick them all together this way to shorten the file.
include ../../../build.conf
include ../../make.src
include ../../make.defs
LIB = $(SRCDIR)/lib/libempth.a
NTLIB = $(SRCDIR)\lib\libempth.lib
OBJS = lwp.o pthread.o ntthread.o
NTOBJS = lwp.obj pthread.obj ntthread.obj
all: $(LIB)
nt: $(NTLIB)
$(NTLIB): $(NTOBJS)
-del /q $@
lib /OUT:$@ /DEBUGTYPE:CV $(NTOBJS)
$(LIB): $(OBJS)
rm -f $(LIB)
ar cq $(LIB) $(OBJS)
$(RANLIB) $(LIB)
clean:
-(rm -f $(OBJS))
-(del /q $(NTOBJS))
include ../../make.rules
include Makedepend

147
src/lib/empthread/lwp.c Normal file
View file

@ -0,0 +1,147 @@
/*
* Empire - A multi-player, client/server Internet based war game.
* Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* ---
*
* See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
* related information and legal notices. It is expected that any future
* projects/authors will amend these files as needed.
*
* ---
*
* lwp.c: Interface from Empire threads to LWP threads
*
* Known contributors to this file:
* Sasha Mikheev
*/
#include <stdio.h>
#include "prototypes.h"
#include "empthread.h"
#ifdef _EMPTH_LWP
int
empth_init (char **ctx, int flags)
{
lwpInitSystem(7, ctx, flags);
return 0;
}
empth_t *
empth_create (int prio, void (*entry)(), int size, int flags, char *name,
char *desc, void *ud)
{
/* inherit flags */
if(!flags)
flags = LwpCurrent->flags;
return lwpCreate(prio, entry, size, flags, name, desc, 0, 0, ud);
}
#if 0
/* This is unused now? */
void
empth_setctx(void *ctx)
{
/* lwp does it automatically */
return;
}
#endif
empth_t *
empth_self(void)
{
return LwpCurrent;
}
void
empth_exit (void)
{
time_t now;
/* We want to leave the main thread around forever, until it's time
for it to die for real (in a shutdown) */
if (!strcmp(LwpCurrent->name, "Main")) {
while(1) {
time(&now);
lwpSleepUntil(now + 60);
}
}
lwpExit();
}
void
empth_yield (void)
{
/* a hack! */
lwpReschedule();
}
void
empth_terminate(empth_t *a)
{
lwpTerminate(a);
}
void
empth_select(int fd, int flags)
{
lwpSleepFd(fd, flags);
}
void
empth_wakeup(empth_t *a)
{
lwpWakeupFd(a);
}
void
empth_sleep(long int until)
{
lwpSleepUntil(until);
}
empth_sem_t *
empth_sem_create(char *name, int cnt)
{
return lwpCreateSem(name, cnt);
}
void
empth_sem_signal(empth_sem_t *sm)
{
lwpSignal(sm);
}
void
empth_sem_wait (empth_sem_t *sm)
{
lwpWait(sm);
}
emp_sig_t
empth_alarm(int sig)
{
/* no way we can be here while using LWP threads */
panic(sig);
}
#endif

728
src/lib/empthread/ntthread.c Normal file
View file

@ -0,0 +1,728 @@
/*
* Empire - A multi-player, client/server Internet based war game.
* Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* ---
*
* See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
* related information and legal notices. It is expected that any future
* projects/authors will amend these files as needed.
*
* ---
*
* ntthread.c: Interface from Empire threads to Windows NT threads
*
* Known contributors to this file:
* Doug Hay, 1998
* Steve McClure, 1998
*/
/*
* EMPTHREADs for Windows NT.
*
* Actually, threads for any Win32 platform,
* like Win95, Win98, WinCE, and whatever other
* toy OSs are in our future from Microsoft.
*
* WIN32 has a full pre-emptive threading environment.
* But, Empire can not handle pre-emptive threading.
* Thus, we will use the threads, but limit the preemption
* using a Mutex semaphore.
*
*/
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include "misc.h"
#include "empthread.h"
#include "prototypes.h"
#if defined(_WIN32) && defined(_EMPTH_WIN32)
#include <windows.h>
#include <process.h>
#define loc_MIN_THREAD_STACK 16384
/************************
* loc_Thread_t
*
* The REAL empth_t thread structure.
* The external world only gets
* a void pointer to this.
*/
typedef struct {
/* The thread name, passed in at create time. */
char szName[17];
/* The thread description, passed in at create time. */
char szDesc[80];
/* True if this is the main line, and not a real thread. */
BOOL bMainThread;
/* The user data passed in at create time. */
void *pvUserData;
/* True if this thread has been killed. */
BOOL bKilled;
/* The entry function for the thread. */
void (*pfnEntry)(void *);
/* The system thread ID. */
unsigned long ulThreadID;
/* An Event sem that the thread will wait/sleep on. */
HANDLE hThreadEvent;
} loc_Thread_t;
/************************
* loc_Sem_t
*
* The REAL empth_sem_t structure.
* The external world only gets
* a void pointer to this.
*/
typedef struct {
char szName[17];
/* An exclusion semaphore for this sem. */
HANDLE hMutex;
/* An Event sem that the thread(s) will sleep on. */
HANDLE hEvent;
/* The count variable */
int count;
} loc_Sem_t;
static struct
{
/* This is the thread exclusion/non-premption mutex. */
/* The running thread has this MUTEX, and all others are */
/* either blocked on it, or waiting for some OS response. */
HANDLE hThreadMutex;
/* This is the thread startup event sem. */
/* We use this to lockstep when we are starting up threads. */
HANDLE hThreadStartEvent;
/* The Thread Local Storage index. We store the pThread pointer */
/* for each thread at this index. */
DWORD dwTLSIndex;
/* The current running thread. */
loc_Thread_t *pCurThread;
/* Ticks at start */
unsigned long ulTickAtStart;
/* Pointer out to global context. "player". */
/* From empth_init parameter. */
char **ppvUserData;
/* Global flags. From empth_init parameter. */
int flags;
} loc_GVAR;
/************************
* loc_debug
*
* Print out the current thread's status??
*/
static void
loc_debug(const char *pszFmt, ...)
{
va_list vaList;
unsigned long ulCurTick;
unsigned long ulRunTick;
unsigned long ulMs, ulSec, ulMin, ulHr;
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
char buf[1024];
if ((loc_GVAR.flags & EMPTH_PRINT) != 0) {
/* Ticks are in milliseconds */
ulCurTick = GetTickCount();
ulRunTick = ulCurTick - loc_GVAR.ulTickAtStart;
ulMs = ulRunTick % 1000L;
ulSec = (ulRunTick / 1000L) % 60L;
ulMin = (ulRunTick / (60L * 1000L)) % 60L;
ulHr = (ulRunTick / (60L * 60L * 1000L));
va_start(vaList, pszFmt);
vsprintf(buf, pszFmt, vaList);
va_end(vaList);
if (pThread) {
printf("%ld:%02ld:%02ld.%03ld %17s: %s\n",
ulHr, ulMin, ulSec, ulMs,
pThread->szName,
buf);
} else {
printf("%ld:%02ld:%02ld.%03ld %17s: %s\n",
ulHr, ulMin, ulSec, ulMs,
"UNKNOWN",
buf);
}
}
}
/************************
* loc_FreeThreadInfo
*
*/
static void
loc_FreeThreadInfo(loc_Thread_t *pThread)
{
if (pThread) {
if (pThread->hThreadEvent)
CloseHandle(pThread->hThreadEvent);
memset(pThread, 0, sizeof(*pThread));
free(pThread);
}
}
/************************
* loc_RunThisThread
*
* This thread wants to run.
* When this function returns, the
* globals are set to this thread info,
* and the thread owns the MUTEX sem.
*/
static void
loc_RunThisThread()
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
if (pThread->bKilled) {
if (!pThread->bMainThread) {
TlsSetValue(loc_GVAR.dwTLSIndex, NULL);
loc_FreeThreadInfo(pThread);
_endthread();
}
}
/* Get the MUTEX semaphore, wait forever. */
WaitForSingleObject(loc_GVAR.hThreadMutex, INFINITE);
if (!loc_GVAR.pCurThread) {
/* Set the globals to this thread. */
*loc_GVAR.ppvUserData = pThread->pvUserData;
loc_GVAR.pCurThread = pThread;
} else {
/* Hmm, a problem, eh? */
logerror("RunThisThread, someone already running.");
}
}
/************************
* loc_BlockThisThread
*
* This thread was running. It no longer wants to.
*/
static void
loc_BlockThisThread()
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
if (loc_GVAR.pCurThread == pThread) {
/* Reset the globals back to original */
loc_GVAR.pCurThread = NULL;
*loc_GVAR.ppvUserData = NULL;
/* Release the MUTEX */
ReleaseMutex(loc_GVAR.hThreadMutex);
} else {
/* Hmm, this thread was not the running one. */
logerror("BlockThisThread, not running.");
}
}
/************************
* loc_SleepThisThread
*/
static void
loc_SleepThisThread(unsigned long ulMillisecs)
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
/* Make sure the event thread is clean. */
ResetEvent(pThread->hThreadEvent);
/* Get the MUTEX semaphore, wait the number of MS */
WaitForSingleObject(pThread->hThreadEvent, ulMillisecs);
}
/************************
* empth_threadMain
*
* This is the main line of each thread.
* This is really a static local func....
*/
void
empth_threadMain(void *pvData)
{
loc_Thread_t *pThread = (loc_Thread_t *)pvData;
/* Out of here... */
if (!pvData) return;
/* Store pThread on this thread. */
TlsSetValue(loc_GVAR.dwTLSIndex, pvData);
/* Get the ID of the thread. */
pThread->ulThreadID = GetCurrentThreadId();
/* Signal that the thread has started. */
SetEvent(loc_GVAR.hThreadStartEvent);
/* Switch to this thread context */
loc_RunThisThread();
/* Run the thread. */
if (pThread->pfnEntry)
pThread->pfnEntry(pThread->pvUserData);
/* Kill the thread. */
empth_exit();
}
/************************
* empth_init
*
* Initialize the thread environment.
*
* This is called from the program
* main line.
*/
int
empth_init (char **ctx_ptr, int flags)
{
loc_Thread_t *pThread = NULL;
loc_GVAR.ulTickAtStart = GetTickCount();
loc_GVAR.ppvUserData = ctx_ptr;
loc_GVAR.flags = flags;
loc_GVAR.dwTLSIndex = TlsAlloc();
/* Create the thread mutex sem. */
/* Initally unowned. */
loc_GVAR.hThreadMutex = CreateMutex(NULL, FALSE, NULL);
if (!loc_GVAR.hThreadMutex) {
logerror("Failed to create mutex");
return 0;
}
/* Create the thread start event sem. */
/* Automatic state reset. */
loc_GVAR.hThreadStartEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!loc_GVAR.hThreadStartEvent) {
logerror("Failed to create mutex");
return 0;
}
/* Create the global Thread context. */
pThread = (loc_Thread_t *) malloc(sizeof(*pThread));
if (!pThread) {
logerror("not enough memory to create main thread.");
return 0;
}
memset(pThread, 0, sizeof(*pThread));
strncpy(pThread->szName, "Main", sizeof(pThread->szName)-1);
strncpy(pThread->szDesc, "The main process", sizeof(pThread->szDesc)-1);
pThread->ulThreadID = GetCurrentThreadId();
pThread->bMainThread = TRUE;
TlsSetValue(loc_GVAR.dwTLSIndex, pThread);
/* Make this the running thread. */
loc_RunThisThread();
logerror("NT pthreads initialized");
return 0;
}
/************************
* empth_create
*
* Create a new thread.
*
* prio - priority, not particularly useful in our context.
* entry - entry point function for thread.
* size - stack size.
* flags - debug control.
* LWP_STACKCHECK - not needed
* name - name of the thread, for debug.
* desc - description of thread, for debug.
* ud - "user data". The "ctx_ptr" gets this value
* when the thread is active.
* It is also passed to the entry function...
*/
empth_t *
empth_create (int prio, void (*entry)(), int size, int flags,
char *name, char *desc, void *ud)
{
loc_Thread_t *pThread = NULL;
loc_debug("creating new thread %s:%s", name, desc);
pThread = (loc_Thread_t *) malloc(sizeof(*pThread));
if (!pThread) {
logerror("not enough memory to create thread: %s (%s)", name, desc);
return NULL;
}
memset(pThread, 0, sizeof(*pThread));
strncpy(pThread->szName, name, sizeof(pThread->szName)-1);
strncpy(pThread->szDesc, desc, sizeof(pThread->szDesc)-1);
pThread->pvUserData = ud;
pThread->pfnEntry = entry;
pThread->bMainThread = FALSE;
/* Create thread event sem, auto reset. */
pThread->hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if (size < loc_MIN_THREAD_STACK)
size = loc_MIN_THREAD_STACK;
pThread->ulThreadID = _beginthread(empth_threadMain, size,
(void *)pThread);
if (pThread->ulThreadID == -1) {
logerror("can not create thread: %s (%s): %s", name, desc,
strerror(errno));
goto bad;
}
loc_debug("new thread id is %ld", pThread->ulThreadID);
return pThread;
bad:
if (pThread) {
loc_FreeThreadInfo(pThread);
}
return NULL;
}
/************************
* empth_self
*/
empth_t *
empth_self(void)
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
return pThread;
}
/************************
* empth_exit
*/
void
empth_exit (void)
{
s_char *getlogfile();
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
loc_BlockThisThread();
loc_debug("empth_exit");
if (pThread->bMainThread) {
char buf[20];
/* The main line. Wait forever. */
if (getlogfile() == (s_char *)0)
loginit();
printf("log file: %s\n", getlogfile());
while (1) {
printf("\nEmpire Server>");
fgets(buf, sizeof(buf), stdin);
if (!strnicmp(buf, "quit", 4))
break;
}
TlsSetValue(loc_GVAR.dwTLSIndex, NULL);
loc_FreeThreadInfo(pThread);
} else {
TlsSetValue(loc_GVAR.dwTLSIndex, NULL);
loc_FreeThreadInfo(pThread);
_endthread();
}
}
/************************
* empth_yield
*
* Yield processing to another thread.
*/
void
empth_yield (void)
{
loc_BlockThisThread();
loc_RunThisThread();
}
/************************
* empth_terminate
*
* Kill off the thread.
*/
void
empth_terminate(empth_t *a)
{
loc_Thread_t *pThread = (loc_Thread_t *) a;
loc_debug("killing thread %s", pThread->szName);
pThread->bKilled = TRUE;
SetEvent(pThread->hThreadEvent);
}
/************************
* empth_select
*
* Do a select on the given file.
* Wait for IO on it.
*
* This would be one of the main functions used within
* gen\io.c
*/
void
empth_select(int fd, int flags)
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
fd_set readmask;
fd_set writemask;
struct lwpProc *proc;
struct timeval tv;
int n;
loc_debug("%s select on %d",
flags == EMPTH_FD_READ ? "read" : "write", fd );
loc_BlockThisThread();
while (1) {
tv.tv_sec = 1000000;
tv.tv_usec = 0;
FD_ZERO(&readmask);
FD_ZERO(&writemask);
switch(flags) {
case EMPTH_FD_READ:
FD_SET(fd, &readmask);
break;
case EMPTH_FD_WRITE:
FD_SET(fd, &writemask);
break;
default:
logerror("bad flag %d passed to empth_select", flags);
empth_exit();
}
n = select(fd + 1, &readmask, &writemask, (fd_set *)0, &tv);
if (n < 0) {
if (errno == EINTR) {
/* go handle the signal */
loc_debug("select broken by signal");
goto done;
return;
}
/* strange but we dont get EINTR on select broken by signal */
loc_debug("select failed (%s)", strerror(errno));
goto done;
return;
}
if (flags == EMPTH_FD_READ && FD_ISSET(fd, &readmask)) {
loc_debug("input ready");
break;
}
if (flags == EMPTH_FD_WRITE && FD_ISSET(fd, &writemask)) {
loc_debug("output ready");
break;
}
}
done:
loc_RunThisThread();
}
/************************
* empth_alarm
*/
emp_sig_t
empth_alarm(int sig)
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
loc_debug("got alarm signal %d", sig);
/* Let it run if it is blocked like... */
SetEvent(pThread->hThreadEvent);
}
/************************
* empth_wakeup
*
* Wake up the specified thread.
*/
void
empth_wakeup(empth_t *a)
{
loc_Thread_t *pThread = (loc_Thread_t *)a;
loc_debug("waking up thread %s", pThread->szName);
/* Let it run if it is blocked... */
SetEvent(pThread->hThreadEvent);
}
/************************
* empth_sleep
*
* Put the given thread to sleep...
*/
void
empth_sleep(long until)
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
unsigned long ulSec;
ulSec = until - time(0);
loc_debug("going to sleep %ld sec", ulSec);
loc_BlockThisThread();
WaitForSingleObject(pThread->hThreadEvent, (ulSec * 1000));
loc_debug("sleep done. Waiting to run.");
loc_RunThisThread();
}
/************************
* empth_sem_create
*
* Create a signalling semaphore.
*/
empth_sem_t *
empth_sem_create(char *name, int cnt)
{
loc_Sem_t *pSem;
pSem = (loc_Sem_t *) malloc(sizeof(*pSem));
if (!pSem) {
logerror("out of memory at %s:%d", __FILE__, __LINE__);
return NULL;
}
memset(pSem, 0, sizeof(pSem));
strncpy(pSem->szName, name, sizeof(pSem->szName)-1);
pSem->hMutex = CreateMutex(NULL, FALSE, NULL);
pSem->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
pSem->count = cnt;
return pSem;
}
/************************
* empth_sem_signal
*
* Hit/signal the specified semaphore.
*/
void
empth_sem_signal(empth_sem_t *sm)
{
loc_Sem_t *pSem = (loc_Sem_t *) sm;
loc_debug("signal on semaphore %s:%d", pSem->szName, pSem->count);
/* Wait for the Semaphore */
WaitForSingleObject(pSem->hMutex, INFINITE);
if (pSem->count++ < 0) {
SetEvent(pSem->hEvent);
}
ReleaseMutex(pSem->hMutex);
}
/************************
* empth_sem_wait
*
* Wait for the specified signal semaphore
* to be signaled.
*/
void
empth_sem_wait (empth_sem_t *sm)
{
loc_Thread_t *pThread =
(loc_Thread_t *) TlsGetValue(loc_GVAR.dwTLSIndex);
loc_Sem_t *pSem = (loc_Sem_t *) sm;
loc_debug("wait on semaphore %s:%d", pSem->szName, pSem->count);
/* Remove the thread from the running state. */
loc_BlockThisThread();
/* Wait for the Semaphore */
WaitForSingleObject(pSem->hMutex, INFINITE);
if (--pSem->count < 0) {
loc_debug("blocking");
ReleaseMutex(pSem->hMutex);
WaitForSingleObject(pSem->hEvent, INFINITE);
loc_debug("waking up");
}
else
ReleaseMutex(pSem->hMutex);
loc_RunThisThread();
}
#endif /* _WIN32 */

518
src/lib/empthread/pthread.c Normal file
View file

@ -0,0 +1,518 @@
/*
* Empire - A multi-player, client/server Internet based war game.
* Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
* Ken Stevens, Steve McClure
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* ---
*
* See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
* related information and legal notices. It is expected that any future
* projects/authors will amend these files as needed.
*
* ---
*
* pthread.c: Interface from Empire threads to POSIX threads
*
* Known contributors to this file:
* Sasha Mikheev
* Steve McClure, 1998
*/
#include <stdio.h>
#if !defined(_WIN32)
#include <sys/time.h>
#include <unistd.h>
#endif
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include "misc.h"
#include "empthread.h"
#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 pthread_mutex_t mtx_ctxsw; /* thread in critical section */
#if 0
static void empth_setctx _PROTO((void *));
#endif
static void empth_restorectx _PROTO(());
void *
empth_start(void *ctx)
{
struct sigaction act;
extern emp_sig_t panic();
extern emp_sig_t shutdwn();
/* actually it should inherit all this from main but... */
#ifdef SA_SIGINFO
act.sa_flags = SA_SIGINFO;
#endif
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 */
#if !(defined(__linux__) && defined(_EMPTH_POSIX))
sigaction (SIGUSR1, &act, NULL);
#endif
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);
act.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &act, NULL);
act.sa_handler = empth_alarm;
sigaction(SIGALRM, &act, NULL);
((empth_t *)ctx)->id = pthread_self();
pthread_setspecific(ctx_key, ctx);
pthread_mutex_lock(&mtx_ctxsw);
*udata = ((empth_t *)ctx)->ud;
((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_end(ap);
}
int
empth_init (char **ctx_ptr, int flags)
{
empth_t *ctx;
struct sigaction act;
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);
act.sa_handler = empth_alarm;
sigaction(SIGALRM, &act, NULL);
udata = ctx_ptr;
ctx = (empth_t *)malloc(sizeof(empth_t));
if(!ctx) {
logerror("pthread init failed: not enough memory");
exit(1);
}
ctx->name = "Main";
ctx->desc = "empire main";
ctx->ep = 0;
ctx->ud = 0;
ctx->id = pthread_self();
ctx->state = 0;
pthread_setspecific(ctx_key, ctx);
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
* for example just ignores it.
* 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)
{
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);
return NULL;
}
ctx->name = strdup(name);
ctx->desc = strdup(desc);
ctx->ud = ud;
ctx->state = 0;
ctx->ep = entry;
#ifdef _DECTHREADS_
eno = pthread_attr_init(&attr) ? errno : 0;
#else
eno = pthread_attr_init(&attr);
#endif
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 */
#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);
#else
if(size < PTHREAD_STACK_MIN)
size = PTHREAD_STACK_MIN + 1;
pthread_attr_setstacksize(&attr, size);
#endif
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
#ifdef _DECTHREADS_
eno = pthread_create(&t, attr, empth_start, (void *)ctx) ? errno : 0;
#else
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;
}
empth_status("new thread id is %d", t);
return ctx;
pthread_attr_destroy(&attr);
bad:
pthread_attr_destroy(&attr);
free(ctx);
return NULL;
}
#if 0
static void
empth_setctx(void *ct)
{
empth_t *ctx_ptr;
#ifdef _DECTHREADS_
pthread_getspecific(ctx_key, (pthread_addr_t *)&ctx_ptr);
#else
ctx_ptr = (empth_t *)pthread_getspecific(ctx_key);
#endif
ctx_ptr->ud = ct;
*udata = ((empth_t *)ctx_ptr)->ud;
pthread_setspecific(ctx_key, (void *)ctx_ptr);
empth_status("context saved");
}
#endif
static void
empth_restorectx(void)
{
empth_t *ctx_ptr;
#ifdef _DECTHREADS_
pthread_getspecific(ctx_key, (pthread_addr_t *)&ctx_ptr);
#else
ctx_ptr = (empth_t *)pthread_getspecific(ctx_key);
#endif
*udata = (char *)ctx_ptr->ud;
if (ctx_ptr->state == EMPTH_KILLED) {
empth_status("i am dead");
empth_exit();
}
empth_status("context restored");
}
empth_t *
empth_self(void)
{
#ifdef _DECTHREADS_
empth_t *ctx_ptr;
pthread_getspecific(ctx_key, (pthread_addr_t *)&ctx_ptr);
return ctx_ptr;
#else
return (empth_t *)pthread_getspecific(ctx_key);
#endif
}
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);
#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) */
if (!strcmp(ctx_ptr->name, "Main")) {
while(1) {
#ifdef _DECTHREADS_
pthread_yield();
#endif
sleep(60);
}
}
free(ctx_ptr);
pthread_exit(0);
}
void
empth_yield (void)
{
pthread_mutex_unlock(&mtx_ctxsw);
sleep(10); /* take a nap pthread_yield(); */
pthread_mutex_lock(&mtx_ctxsw);
empth_restorectx();
}
void
empth_terminate(empth_t *a)
{
/* logerror("calling non supported function empth_terminate: %s:%d",
__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
#endif
return;
}
void
empth_select(int fd, int flags)
{
fd_set readmask;
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 );
while (1) {
tv.tv_sec = 1000000;
tv.tv_usec = 0;
FD_ZERO(&readmask);
FD_ZERO(&writemask);
switch(flags) {
case EMPTH_FD_READ:
FD_SET(fd, &readmask);
break;
case EMPTH_FD_WRITE:
FD_SET(fd, &writemask);
break;
default:
logerror("bad flag %d passed to empth_select", flags);
empth_exit();
}
n = select(fd + 1, &readmask, &writemask, (fd_set *)0, &tv);
if (n < 0) {
if (errno == EINTR) {
/* go handle the signal */
empth_status("select broken by signal");
goto done;
return;
}
/* strange but we dont get EINTR on select broken by signal */
empth_status("select failed (%s)", strerror(errno));
goto done;
return;
}
if (flags == EMPTH_FD_READ && FD_ISSET(fd, &readmask)) {
empth_status("input ready");
break;
}
if (flags == EMPTH_FD_WRITE && FD_ISSET(fd, &writemask)) {
empth_status("output ready");
break;
}
}
done:
pthread_mutex_lock(&mtx_ctxsw);
empth_restorectx();
}
emp_sig_t
empth_alarm(int sig)
{
struct sigaction act;
empth_status("got alarm signal");
#ifdef SA_RESTART
act.sa_flags &= ~SA_RESTART;
#endif
sigemptyset (&act.sa_mask);
act.sa_handler = empth_alarm;
sigaction(SIGALRM, &act, NULL);
}
void
empth_wakeup(empth_t *a)
{
empth_status("waking up thread %s", a->name);
#ifndef _DECTHREADS_
#if (!defined __ppc__)
pthread_kill(a->id, SIGALRM);
#endif
#endif
empth_status("waiting for it to run");
/* empth_yield(); */
}
void
empth_sleep(long until)
{
struct timeval tv;
empth_status("going to sleep %ld sec", until - time(0));
pthread_mutex_unlock(&mtx_ctxsw);
tv.tv_sec = until - time(NULL);
tv.tv_usec = 0;
do {
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_restorectx();
}
empth_sem_t *
empth_sem_create(char *name, int cnt)
{
empth_sem_t *sm;
sm = (empth_sem_t *)malloc(sizeof(empth_sem_t));
if(!sm) {
logerror("out of memory at %s:%d", __FILE__, __LINE__);
return NULL;
}
strncpy(sm->name, name, sizeof(sm->name)-1);
sm->count = cnt;
#ifdef _DECTHREADS_
pthread_mutex_init(&sm->mtx_update, pthread_mutexattr_default);
pthread_mutex_init(&sm->mtx_sem, pthread_mutexattr_default);
pthread_cond_init(&sm->cnd_sem, pthread_condattr_default);
#else
pthread_mutex_init(&sm->mtx_update, 0);
pthread_mutex_init(&sm->mtx_sem, 0);
pthread_cond_init(&sm->cnd_sem, 0);
#endif
return sm;
}
void
empth_sem_signal(empth_sem_t *sm)
{
empth_status("signal on semaphore %s:%d", sm->name, sm->count);
pthread_mutex_lock(&sm->mtx_update);
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
pthread_mutex_unlock(&sm->mtx_update);
}
void
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) {
pthread_mutex_unlock(&sm->mtx_update);
empth_status("blocking");
pthread_mutex_unlock(&mtx_ctxsw);
pthread_mutex_lock(&sm->mtx_sem);
pthread_cond_wait(&sm->cnd_sem, &sm->mtx_sem);
empth_status("waking up");
pthread_mutex_unlock(&sm->mtx_sem);
pthread_mutex_lock(&mtx_ctxsw);
empth_restorectx();
}
else
pthread_mutex_unlock(&sm->mtx_update);
}
#endif