2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1986-2008, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * See files README, COPYING and CREDITS in the root of the source
23 * tree for related information and legal notices. It is expected
24 * that future projects/authors will amend these files as needed.
28 * ntthread.c: Interface from Empire threads to Windows NT threads
30 * Known contributors to this file:
33 * Ron Koenderink, 2004-2008
37 * EMPTHREADs for Windows NT.
39 * Actually, threads for any Win32 platform, like Win95, Win98, WinCE,
40 * and whatever other toy OSs are in our future from Microsoft.
42 * WIN32 has a full pre-emptive threading environment. But Empire can
43 * not handle pre-emptive threading. Thus, we will use the threads,
44 * but limit the preemption using a Mutex.
53 #include <sys/types.h>
59 /* Note: unistd.h(posixio.c) is not thread-safe.
60 * It may be used *only* while holding hThreadMutex.
64 #include "empthread.h"
65 #include "prototypes.h"
68 #define loc_MIN_THREAD_STACK 16384
70 /************************
75 /* The thread name, passed in at create time. */
78 /* True if this is the main line, and not a real thread. */
81 /* The user data passed in at create time. */
84 /* True if this thread has been killed. */
87 /* The entry function for the thread. */
88 void (*pfnEntry) (void *);
90 /* The system thread ID. */
91 unsigned long ulThreadID;
93 /* An Mutex that the thread will wait/sleep on. */
98 /************************
102 * must hold at function call, return, sleep
103 * and resume from sleep.
115 * if read-locked without writers contending:
121 * if read-locked with writers contending:
124 * nwrite > 0 #writers blocked
130 * nwrite > 0 #writers blocked + 1
133 * To ensure consistency, state normally changes only while the
134 * thread changing it holds hThreadMutex.
138 char *name; /* The lock name, passed in at create time. */
139 HANDLE can_read; /* Manual event -- allows read locks */
140 HANDLE can_write; /* Auto-reset event -- allows write locks */
141 int nread; /* number of active readers */
142 int nwrite; /* total number of writers (active and waiting) */
145 /* This is the thread exclusion/non-premption mutex. */
146 /* The running thread has this MUTEX, and all others are */
147 /* either blocked on it, or waiting for some OS response. */
148 static HANDLE hThreadMutex;
150 /* This is the thread startup event. */
151 /* We use this to lockstep when we are starting up threads. */
152 static HANDLE hThreadStartEvent;
154 /* This is an event used to wakeup the main thread */
155 /* to start the shutdown sequence. */
156 static HANDLE hShutdownEvent;
158 /* The Thread Local Storage index. We store the pThread pointer */
159 /* for each thread at this index. */
160 static DWORD dwTLSIndex;
162 /* The current running thread. */
163 static empth_t *pCurThread;
166 static unsigned long ulTickAtStart;
168 /* Pointer out to global context. "player". */
169 /* From empth_init parameter. */
170 static void **ppvUserData;
172 /* Global flags. From empth_init parameter. */
173 static int global_flags;
175 static void loc_debug(const char *, ...) ATTRIBUTE((format(printf, 1, 2)));
177 /************************
180 * Print out the current thread's status??
183 loc_debug(const char *pszFmt, ...)
186 unsigned long ulCurTick;
187 unsigned long ulRunTick;
188 unsigned long ulMs, ulSec, ulMin, ulHr;
189 empth_t *pThread = TlsGetValue(dwTLSIndex);
192 if ((global_flags & EMPTH_PRINT) != 0) {
194 /* Ticks are in milliseconds */
195 ulCurTick = GetTickCount();
197 ulRunTick = ulCurTick - ulTickAtStart;
198 ulMs = ulRunTick % 1000L;
199 ulSec = (ulRunTick / 1000L) % 60L;
200 ulMin = (ulRunTick / (60L * 1000L)) % 60L;
201 ulHr = (ulRunTick / (60L * 60L * 1000L));
203 va_start(vaList, pszFmt);
204 vsprintf(buf, pszFmt, vaList);
208 printf("%ld:%02ld:%02ld.%03ld %17s: %s\n",
209 ulHr, ulMin, ulSec, ulMs, pThread->szName, buf);
211 printf("%ld:%02ld:%02ld.%03ld %17s: %s\n",
212 ulHr, ulMin, ulSec, ulMs, "UNKNOWN", buf);
218 /************************
222 loc_FreeThreadInfo(empth_t *pThread)
225 if (pThread->hThreadEvent)
226 CloseHandle(pThread->hThreadEvent);
227 if (pThread->szName != NULL)
228 free(pThread->szName);
229 memset(pThread, 0, sizeof(*pThread));
234 /************************
237 * This thread wants to run.
238 * When this function returns, the globals are set to this thread
239 * info, and the thread owns the MUTEX.
242 loc_RunThisThread(HANDLE hWaitObject)
244 HANDLE hWaitObjects[2];
246 empth_t *pThread = TlsGetValue(dwTLSIndex);
248 if (pThread->bKilled) {
249 if (!pThread->bMainThread) {
250 TlsSetValue(dwTLSIndex, NULL);
251 loc_FreeThreadInfo(pThread);
256 hWaitObjects[0] = hThreadMutex;
257 hWaitObjects[1] = hWaitObject;
259 WaitForMultipleObjects(hWaitObject ? 2 : 1, hWaitObjects,
263 /* Set the globals to this thread. */
264 *ppvUserData = pThread->pvUserData;
266 pCurThread = pThread;
268 /* Hmm, a problem, eh? */
269 logerror("RunThisThread, someone already running.");
273 /************************
274 * loc_BlockThisThread
276 * This thread was running. It no longer wants to.
279 loc_BlockThisThread(void)
281 empth_t *pThread = TlsGetValue(dwTLSIndex);
283 if (pCurThread == pThread) {
284 /* Reset the globals back to original */
289 /* Release the MUTEX */
290 ReleaseMutex(hThreadMutex);
292 /* Hmm, this thread was not the running one. */
293 logerror("BlockThisThread, not running.");
297 /************************
300 * Ctrl-C, Ctrl-Break, Window-Closure, User-Logging-Off or
301 * System-Shutdown will initiate a shutdown.
302 * This is done by calling empth_request_shutdown()
305 loc_Exit_Handler(DWORD fdwCtrlType)
307 switch (fdwCtrlType) {
309 case CTRL_CLOSE_EVENT:
310 case CTRL_BREAK_EVENT:
311 case CTRL_LOGOFF_EVENT:
312 case CTRL_SHUTDOWN_EVENT:
313 empth_request_shutdown();
320 /************************
323 * This is the main line of each thread.
324 * This is really a static local func....
325 * Note: As the POSIX compatibility layer is not thread safe
326 * this function can not open or create any files or sockets until
327 * loc_RunThisThread() is called
330 empth_threadMain(void *pvData)
332 empth_t *pThread = pvData;
338 /* Store pThread on this thread. */
339 TlsSetValue(dwTLSIndex, pvData);
341 /* Get the ID of the thread. */
342 pThread->ulThreadID = GetCurrentThreadId();
344 /* Signal that the thread has started. */
345 SetEvent(hThreadStartEvent);
347 /* Switch to this thread context */
348 loc_RunThisThread(NULL);
350 /* Run the thread. */
351 if (pThread->pfnEntry)
352 pThread->pfnEntry(pThread->pvUserData);
354 /* Kill the thread. */
358 /************************
361 * Initialize the thread environment.
363 * This is called from the program main line.
366 empth_init(void **ctx_ptr, int flags)
368 empth_t *pThread = NULL;
370 ulTickAtStart = GetTickCount();
371 ppvUserData = ctx_ptr;
372 global_flags = flags;
373 dwTLSIndex = TlsAlloc();
375 /* Create the thread mutex. */
376 /* Initally unowned. */
377 hThreadMutex = CreateMutex(NULL, FALSE, NULL);
379 logerror("Failed to create mutex %lu", GetLastError());
383 /* Create the thread start event. */
384 /* Automatic state reset. */
385 hThreadStartEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
386 if (!hThreadStartEvent) {
387 logerror("Failed to create start event %lu", GetLastError());
391 /* Create the shutdown event for the main thread. */
393 hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
394 if (!hShutdownEvent) {
395 logerror("Failed to create shutdown event %lu", GetLastError());
398 SetConsoleCtrlHandler(loc_Exit_Handler, TRUE);
400 /* Create the global Thread context. */
401 pThread = malloc(sizeof(*pThread));
403 logerror("not enough memory to create main thread.");
406 memset(pThread, 0, sizeof(*pThread));
408 pThread->szName = strdup("Main");
409 pThread->ulThreadID = GetCurrentThreadId();
410 pThread->bMainThread = TRUE;
412 TlsSetValue(dwTLSIndex, pThread);
414 /* Make this the running thread. */
415 loc_RunThisThread(NULL);
417 logerror("NT pthreads initialized");
422 /************************
425 * Create a new thread.
427 * entry - entry point function for thread.
429 * flags - debug control.
430 * LWP_STACKCHECK - not needed
431 * name - name of the thread, for debug.
432 * ud - "user data". The "ctx_ptr" gets this value
433 * when the thread is active.
434 * It is also passed to the entry function...
437 empth_create(void (*entry)(void *), int size, int flags,
438 char *name, void *ud)
440 empth_t *pThread = NULL;
442 loc_debug("creating new thread %s", name);
444 pThread = malloc(sizeof(*pThread));
446 logerror("not enough memory to create thread %s", name);
449 memset(pThread, 0, sizeof(*pThread));
451 pThread->szName = strdup(name);
452 pThread->pvUserData = ud;
453 pThread->pfnEntry = entry;
454 pThread->bMainThread = FALSE;
456 /* Create thread event, auto reset. */
457 pThread->hThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
459 if (size < loc_MIN_THREAD_STACK)
460 size = loc_MIN_THREAD_STACK;
462 pThread->ulThreadID = _beginthread(empth_threadMain, size, pThread);
463 if (pThread->ulThreadID == 1L || pThread->ulThreadID == 0L) {
464 logerror("can not create thread: %s: %s", name, strerror(errno));
468 loc_debug("new thread id is %ld", pThread->ulThreadID);
474 loc_FreeThreadInfo(pThread);
480 /************************
486 empth_t *pThread = TlsGetValue(dwTLSIndex);
491 /************************
495 empth_name(empth_t *thread)
497 return thread->szName;
500 /************************
502 * Set the thread name
505 empth_set_name(empth_t *thread, char *name)
507 if (thread->szName != NULL)
508 free(thread->szName);
509 thread->szName = strdup(name);
512 /************************
518 empth_t *pThread = TlsGetValue(dwTLSIndex);
520 loc_debug("empth_exit");
521 loc_BlockThisThread();
523 TlsSetValue(dwTLSIndex, NULL);
524 loc_FreeThreadInfo(pThread);
528 /************************
531 * Yield processing to another thread.
536 loc_BlockThisThread();
538 loc_RunThisThread(NULL);
541 /************************
544 * Kill off the thread.
547 empth_terminate(empth_t *pThread)
549 loc_debug("killing thread %s", pThread->szName);
550 pThread->bKilled = TRUE;
552 SetEvent(pThread->hThreadEvent);
555 /************************
558 * Do a select on the given file.
561 * This would be one of the main functions used within gen\io.c
564 empth_select(int fd, int flags, struct timeval *timeout)
567 WSAEVENT hEventObject[2];
570 empth_t *pThread = TlsGetValue(dwTLSIndex);
573 loc_debug("%s select on %d",
574 flags == EMPTH_FD_READ ? "read" : "write", fd);
575 loc_BlockThisThread();
577 hEventObject[0] = WSACreateEvent();
578 hEventObject[1] = pThread->hThreadEvent;
580 handle = posix_fd2socket(fd);
581 CANT_HAPPEN(handle < 0);
584 if (flags & EMPTH_FD_READ)
585 events |= FD_READ | FD_ACCEPT | FD_CLOSE;
586 if (flags & EMPTH_FD_WRITE)
587 events |= FD_WRITE | FD_CLOSE;
588 WSAEventSelect(handle, hEventObject[0], events);
591 msec = timeout->tv_sec * 1000L + timeout->tv_usec / 1000L;
594 result = WSAWaitForMultipleEvents(2, hEventObject, FALSE, msec, FALSE);
597 case WSA_WAIT_TIMEOUT:
600 case WSA_WAIT_FAILED:
601 errno = WSAGetLastError();
608 WSAEventSelect(handle, hEventObject[0], 0);
610 WSACloseEvent(hEventObject[0]);
612 loc_RunThisThread(NULL);
616 /************************
619 * Wake up the specified thread.
622 empth_wakeup(empth_t *pThread)
624 loc_debug("waking up thread %s", pThread->szName);
626 /* Let it run if it is blocked... */
627 SetEvent(pThread->hThreadEvent);
630 /************************
633 * Put the given thread to sleep...
636 empth_sleep(time_t until)
638 long lSec = until - time(0) > 0 ? until - time(0) : 0;
639 empth_t *pThread = TlsGetValue(dwTLSIndex);
643 loc_BlockThisThread();
644 loc_debug("going to sleep %ld sec", lSec);
646 if (WaitForSingleObject(pThread->hThreadEvent, lSec * 1000L) !=
650 loc_debug("sleep done. Waiting to run.");
651 loc_RunThisThread(NULL);
652 } while (!iReturn && ((lSec = until - time(0)) > 0));
657 /************************
658 * empth_request_shutdown
660 * This wakes up empth_wait_for_signal() so shutdown can proceed.
661 * This is done by signalling hShutdownEvent.
664 empth_request_shutdown(void)
666 SetEvent(hShutdownEvent);
670 empth_wait_for_signal(void)
672 loc_BlockThisThread();
673 loc_RunThisThread(hShutdownEvent);
678 empth_rwlock_create(char *name)
680 empth_rwlock_t *rwlock;
682 rwlock = malloc(sizeof(*rwlock));
686 memset(rwlock, 0, sizeof(*rwlock));
687 rwlock->name = strdup(name);
689 if ((rwlock->can_read = CreateEvent(NULL, TRUE, TRUE, NULL)) == NULL) {
690 logerror("rwlock_create: failed to create reader event %s at %s:%d",
691 name, __FILE__, __LINE__);
697 if ((rwlock->can_write = CreateEvent(NULL, FALSE, TRUE, NULL)) == NULL) {
698 logerror("rwlock_create: failed to create writer event %s at %s:%d",
699 name, __FILE__, __LINE__);
701 CloseHandle(rwlock->can_read);
709 empth_rwlock_destroy(empth_rwlock_t *rwlock)
711 if (CANT_HAPPEN(rwlock->nread || rwlock->nwrite))
713 if (rwlock->name != NULL)
715 CloseHandle(rwlock->can_read);
716 CloseHandle(rwlock->can_write);
721 empth_rwlock_wrlock(empth_rwlock_t *rwlock)
723 /* block any new readers */
724 ResetEvent(rwlock->can_read);
726 loc_BlockThisThread();
727 loc_RunThisThread(rwlock->can_write);
728 CANT_HAPPEN(rwlock->nread != 0);
732 empth_rwlock_rdlock(empth_rwlock_t *rwlock)
734 loc_BlockThisThread();
735 loc_RunThisThread(rwlock->can_read);
736 ResetEvent(rwlock->can_write);
741 empth_rwlock_unlock(empth_rwlock_t *rwlock)
743 if (CANT_HAPPEN(!rwlock->nread && !rwlock->nwrite))
745 if (rwlock->nread) { /* holding read lock */
747 if (rwlock->nread == 0)
748 SetEvent(rwlock->can_write);
751 SetEvent(rwlock->can_write);
753 if (rwlock->nwrite == 0)
754 SetEvent(rwlock->can_read);