2 * Empire - A multi-player, client/server Internet based war game.
3 * Copyright (C) 1994-2011, Dave Pare, Jeff Bailey, Thomas Ruschak,
4 * Ken Stevens, Steve McClure, Markus Armbruster
5 * Copyright (C) 1991-3 Stephen Crane
7 * Empire is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
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 * lwp.c: lightweight process creation, destruction and manipulation
30 * Known contributors to this file:
31 * Markus Armbruster, 2004-2009
39 #include "prototypes.h"
41 static struct lwpQueue LwpSchedQ[LWP_MAX_PRIO], LwpDeadQ;
43 struct lwpProc *LwpCurrent = NULL;
44 static void **LwpContextPtr;
45 static int LwpMaxpri = 0; /* maximum priority so far */
46 static int LwpStackGrowsDown;
48 static void lwpDestroy(struct lwpProc *proc);
49 static void lwpStackCheckInit(struct lwpProc *newp);
50 static void lwpStackCheck(struct lwpProc *newp);
51 static void lwpStackCheckUsed(struct lwpProc *newp);
53 /* check stack direction */
63 * lwpReschedule -- schedule another process. we also check for dead
64 * processes here and free them.
69 static struct lwpProc *nextp;
72 if (LwpCurrent && (LwpCurrent->flags & LWP_STACKCHECK)) {
73 lwpStackCheck(LwpCurrent);
79 /* destroy dead threads */
80 lwpStatus(LwpCurrent, "Cleaning dead queue");
81 while (NULL != (nextp = lwpGetFirst(&LwpDeadQ))) {
82 if (CANT_HAPPEN(nextp == LwpCurrent))
85 lwpStatus(LwpCurrent, "Destroying done");
88 for (i = LwpMaxpri + 1; i--;) {
89 while (NULL != (nextp = lwpGetFirst(&LwpSchedQ[i]))) {
92 /* clean up after dead bodies */
93 lwpStatus(nextp, "got a dead body");
94 if (nextp == LwpCurrent) {
95 lwpStatus(nextp, "we are in it -- will bury later");
96 lwpAddTail(&LwpDeadQ, nextp);
105 if (CANT_HAPPEN(!nextp))
107 if (LwpCurrent != nextp) {
108 struct lwpProc *oldp = LwpCurrent;
110 lwpStatus(oldp, "switch out");
112 *LwpContextPtr = nextp->ud;
113 lwpSwitchContext(oldp, nextp);
114 lwpStatus(nextp, "switch in");
119 * lwpEntryPoint -- process entry point.
124 lwpStatus(LwpCurrent, "starting at entry point");
125 (*LwpCurrent->entry)(LwpCurrent->ud);
130 lwpNewStack(struct lwpProc *newp, int stacksz)
135 /* Make size a multiple of sizeof(long) to keep things aligned */
136 stacksz = (stacksz + sizeof(long) - 1) & -sizeof(long);
137 /* Add a red zone on each side of the stack for LWP_STACKCHECK */
138 redsize = newp->flags & LWP_STACKCHECK ? LWP_REDZONE : 0;
139 size = stacksz + 2 * redsize;
147 newp->ustack = s + redsize;
148 newp->usize = stacksz;
150 if (newp->flags & LWP_STACKCHECK)
151 lwpStackCheckInit(newp);
156 * lwpCreate -- create a process.
159 lwpCreate(int priority, void (*entry)(void *), int stacksz,
160 int flags, char *name, int argc, char **argv, void *ud)
162 struct lwpProc *newp;
164 if (!(newp = malloc(sizeof(struct lwpProc))))
167 newp->name = strdup(name);
173 newp->runtime = (time_t)-1;
176 if (LWP_MAX_PRIO <= priority)
177 priority = LWP_MAX_PRIO - 1;
178 if (LwpMaxpri < (newp->pri = priority))
179 LwpMaxpri = priority;
180 if (lwpNewStack(newp, stacksz) < 0 || lwpNewContext(newp) < 0) {
186 lwpStatus(newp, "creating process structure %p (sbtm %p)",
189 lwpReady(LwpCurrent);
195 lwpDestroy(struct lwpProc *proc)
197 if (proc->flags & LWP_STACKCHECK) {
198 lwpStackCheckUsed(proc);
201 lwpStatus(proc, "destroying sbtm: %p", proc->sbtm);
208 * lwpReady -- put process on ready queue. if null, assume current.
211 lwpReady(struct lwpProc *p)
215 lwpStatus(p, "added to run queue");
216 lwpAddTail(&LwpSchedQ[p->pri], p);
223 lwpGetUD(struct lwpProc *p)
234 lwpSetUD(struct lwpProc *p, char *ud)
242 * lwpYield -- yield the processor to another thread.
247 lwpStatus(LwpCurrent, "yielding control");
248 lwpReady(LwpCurrent);
253 * cause the current process to be scheduled for deletion.
258 lwpStatus(LwpCurrent, "marking self as dead");
259 LwpCurrent->dead = 1;
264 * mark another process as dead, so it will never be rescheduled.
265 * remove any lingering FD action
268 lwpTerminate(struct lwpProc *p)
270 lwpStatus(p, "terminating process");
276 * set the thread's priority, returning the old.
277 * if the new priority is lower than the old, we reschedule.
280 lwpSetPriority(int new)
282 int old = LwpCurrent->pri;
284 if (LWP_MAX_PRIO <= new)
285 new = LWP_MAX_PRIO - 1;
288 LwpCurrent->pri = new;
289 lwpStatus(LwpCurrent, "resetting priority (%d -> %d)", old, new);
296 * initialise the coroutine structures
299 lwpInitSystem(int pri, void **ctxptr, int flags, sigset_t *waitset)
302 int i, *stack, marker;
305 LwpContextPtr = ctxptr;
308 LwpStackGrowsDown = growsdown(&marker);
309 if (!(LwpCurrent = calloc(1, sizeof(struct lwpProc))))
311 if (!(stack = malloc(64)))
313 if (LWP_MAX_PRIO <= pri)
314 pri = LWP_MAX_PRIO - 1;
317 LwpCurrent->next = NULL;
318 LwpCurrent->sbtm = stack; /* dummy stack for "main" */
319 LwpCurrent->pri = pri;
320 LwpCurrent->dead = 0;
321 LwpCurrent->flags = flags & ~LWP_STACKCHECK;
322 LwpCurrent->name = "Main";
323 for (i = LWP_MAX_PRIO, q = LwpSchedQ; i--; q++)
324 q->head = q->tail = NULL;
325 LwpDeadQ.head = LwpDeadQ.tail = NULL;
326 lwpInitSigWait(waitset);
327 /* must be lower in priority than us for this to work right */
328 sel = lwpCreate(0, lwpSelect, 16384, flags, "EventHandler", 0,
336 * Initialize the entire stack (including both redzones) with the stack
337 * check mark. Thus, we can get some indication of how much stack was
341 lwpStackCheckInit(struct lwpProc *newp)
344 int *lim = (int *)((char *)newp->sbtm + newp->size);
346 for (p = newp->sbtm; p < lim; p++)
352 * Check if the thread has overflowed/underflowed its stack.
353 * Should that happen, abort the process, as we cannot recover.
356 lwpStackCheck(struct lwpProc *newp)
358 int *btm = (int *)(newp->ustack - LWP_REDZONE);
359 int *top = (int *)(newp->ustack + newp->usize + LWP_REDZONE);
360 int n = LWP_REDZONE / sizeof(int);
361 int i, lo_clean, hi_clean, overflow, underflow;
363 for (i = 0; i < n && btm[i] == LWP_CHECKMARK; i++) ;
366 for (i = 1; i <= n && top[-i] == LWP_CHECKMARK; i++) ;
369 if (LwpStackGrowsDown) {
370 overflow = n - lo_clean;
371 underflow = n - hi_clean;
373 overflow = n - hi_clean;
374 underflow = n - lo_clean;
377 logerror("Thread %s stack overflow %d bytes",
378 newp->name, overflow * (int)sizeof(int));
380 logerror("Thread %s stack underflow %d bytes",
381 newp->name, underflow * (int)sizeof(int));
382 if (overflow || underflow)
388 * Figure out how much stack was used by this thread.
391 lwpStackCheckUsed(struct lwpProc *newp)
393 int *base = (int *)newp->ustack;
394 int *lim = (int *)(newp->ustack + newp->usize);
395 int total = (lim + 1 - base) * sizeof(int);
398 if (LwpStackGrowsDown) {
399 for (p = base; p < lim && *p == LWP_CHECKMARK; ++p) ;
400 used = (lim - p) * sizeof(int);
402 for (p = lim - 1; p >= base && *p == LWP_CHECKMARK; --p) ;
403 used = (p - base + 1) * sizeof(int);
405 lwpStatus(newp, "Thread stack %d used, %d left, %d total",
406 used, total - used, total);
411 * Return the name of the thread.
414 lwpName(struct lwpProc *proc)
421 * Set the name of the thread.
424 lwpSetName(struct lwpProc *proc, char *name)
426 if (proc->name != NULL)
429 proc->name = strdup(name);