Indented with src/scripts/indent-emp.
This commit is contained in:
parent
5f263a7753
commit
9b7adfbecc
437 changed files with 52211 additions and 51052 deletions
|
|
@ -45,198 +45,211 @@
|
|||
#if defined(hpc)
|
||||
|
||||
static struct lwpProc *tempcontext;
|
||||
struct lwpProc *initcontext=NULL;
|
||||
struct lwpProc *initcontext = NULL;
|
||||
int startpoint;
|
||||
|
||||
startcontext()
|
||||
{
|
||||
int space[10000];
|
||||
int x;
|
||||
int space[10000];
|
||||
int x;
|
||||
|
||||
startpoint = (void *) &x;
|
||||
if (!setjmp(initcontext->context)) longjmp(tempcontext->context,1);
|
||||
startpoint = (void *)&x;
|
||||
if (!setjmp(initcontext->context))
|
||||
longjmp(tempcontext->context, 1);
|
||||
|
||||
if (!setjmp(tempcontext->context)) longjmp(LwpCurrent->context,1);
|
||||
if (!setjmp(tempcontext->context))
|
||||
longjmp(LwpCurrent->context, 1);
|
||||
|
||||
lwpEntryPoint();
|
||||
lwpEntryPoint();
|
||||
}
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
struct lwpProc holder;
|
||||
int endpoint;
|
||||
struct lwpProc holder;
|
||||
int endpoint;
|
||||
|
||||
if (initcontext == NULL) {
|
||||
initcontext = (struct lwpProc *) malloc (sizeof(struct lwpProc));
|
||||
tempcontext = &holder;
|
||||
if (!setjmp(tempcontext->context)) startcontext();
|
||||
}
|
||||
if (initcontext == NULL) {
|
||||
initcontext = (struct lwpProc *)malloc(sizeof(struct lwpProc));
|
||||
tempcontext = &holder;
|
||||
if (!setjmp(tempcontext->context))
|
||||
startcontext();
|
||||
}
|
||||
|
||||
tempcontext = newp;
|
||||
endpoint = &endpoint;
|
||||
if (endpoint < startpoint) {
|
||||
if (!setjmp(LwpCurrent->context)) longjmp(initcontext->context,1);
|
||||
} else {
|
||||
LwpCurrent->size = endpoint - startpoint;
|
||||
LwpCurrent->sbtm = realloc(LwpCurrent->sbtm, LwpCurrent->size);
|
||||
memcpy(LwpCurrent->sbtm, startpoint, LwpCurrent->size);
|
||||
if (!setjmp(LwpCurrent->context)) longjmp(initcontext->context,1);
|
||||
memcpy(startpoint, LwpCurrent->sbtm, LwpCurrent->size);
|
||||
}
|
||||
tempcontext = newp;
|
||||
endpoint = &endpoint;
|
||||
if (endpoint < startpoint) {
|
||||
if (!setjmp(LwpCurrent->context))
|
||||
longjmp(initcontext->context, 1);
|
||||
} else {
|
||||
LwpCurrent->size = endpoint - startpoint;
|
||||
LwpCurrent->sbtm = realloc(LwpCurrent->sbtm, LwpCurrent->size);
|
||||
memcpy(LwpCurrent->sbtm, startpoint, LwpCurrent->size);
|
||||
if (!setjmp(LwpCurrent->context))
|
||||
longjmp(initcontext->context, 1);
|
||||
memcpy(startpoint, LwpCurrent->sbtm, LwpCurrent->size);
|
||||
}
|
||||
}
|
||||
|
||||
#elif defined(hpux)
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
volatile struct lwpProc *volatile newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
volatile struct lwpProc *volatile newp;
|
||||
void *sp;
|
||||
{
|
||||
static jmp_buf *cpp;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
|
||||
if (!lwpSave(LwpCurrent->context)) {
|
||||
cpp = (jmp_buf *)&newp->context;
|
||||
asm volatile ("ldw %0, %%sp": : "o" (sp));
|
||||
cpp = (jmp_buf *) & newp->context;
|
||||
asm volatile ("ldw %0, %%sp"::"o" (sp));
|
||||
if (!lwpSave(*cpp))
|
||||
lwpRestore(LwpCurrent->context);
|
||||
lwpEntryPoint();
|
||||
}
|
||||
}
|
||||
|
||||
int lwpSave(jb)
|
||||
jmp_buf jb;
|
||||
int
|
||||
lwpSave(jb)
|
||||
jmp_buf jb;
|
||||
{
|
||||
/* save stack pointer and return program counter */
|
||||
asm ("stw %sp, 4(%arg0)");
|
||||
asm ("stw %rp, 8(%arg0)");
|
||||
/* save stack pointer and return program counter */
|
||||
asm("stw %sp, 4(%arg0)");
|
||||
asm("stw %rp, 8(%arg0)");
|
||||
|
||||
/* save "callee save" registers */
|
||||
asm ("stw %r3, 12(%arg0)");
|
||||
asm ("stw %r4, 16(%arg0)");
|
||||
asm ("stw %r5, 20(%arg0)");
|
||||
asm ("stw %r6, 24(%arg0)");
|
||||
asm ("stw %r7, 28(%arg0)");
|
||||
asm ("stw %r8, 32(%arg0)");
|
||||
asm ("stw %r9, 36(%arg0)");
|
||||
asm ("stw %r10, 40(%arg0)");
|
||||
asm ("stw %r11, 44(%arg0)");
|
||||
asm ("stw %r12, 48(%arg0)");
|
||||
asm ("stw %r13, 52(%arg0)");
|
||||
asm ("stw %r14, 56(%arg0)");
|
||||
asm ("stw %r15, 60(%arg0)");
|
||||
asm ("stw %r16, 64(%arg0)");
|
||||
asm ("stw %r17, 68(%arg0)");
|
||||
asm ("stw %r18, 72(%arg0)");
|
||||
/* save "callee save" registers */
|
||||
asm("stw %r3, 12(%arg0)");
|
||||
asm("stw %r4, 16(%arg0)");
|
||||
asm("stw %r5, 20(%arg0)");
|
||||
asm("stw %r6, 24(%arg0)");
|
||||
asm("stw %r7, 28(%arg0)");
|
||||
asm("stw %r8, 32(%arg0)");
|
||||
asm("stw %r9, 36(%arg0)");
|
||||
asm("stw %r10, 40(%arg0)");
|
||||
asm("stw %r11, 44(%arg0)");
|
||||
asm("stw %r12, 48(%arg0)");
|
||||
asm("stw %r13, 52(%arg0)");
|
||||
asm("stw %r14, 56(%arg0)");
|
||||
asm("stw %r15, 60(%arg0)");
|
||||
asm("stw %r16, 64(%arg0)");
|
||||
asm("stw %r17, 68(%arg0)");
|
||||
asm("stw %r18, 72(%arg0)");
|
||||
|
||||
/* save "callee save" space register */
|
||||
asm volatile ("mfsp %sr3, %r1");
|
||||
asm ("stw %r1, 0(%arg0)");
|
||||
/* save "callee save" space register */
|
||||
asm volatile ("mfsp %sr3, %r1");
|
||||
asm("stw %r1, 0(%arg0)");
|
||||
|
||||
/* indicate "true return" from saved() */
|
||||
asm ("ldi 0, %ret0");
|
||||
/* indicate "true return" from saved() */
|
||||
asm("ldi 0, %ret0");
|
||||
|
||||
asm (".LABEL _comefrom_");
|
||||
asm(".LABEL _comefrom_");
|
||||
}
|
||||
|
||||
void
|
||||
lwpRestore(jb)
|
||||
jmp_buf jb;
|
||||
jmp_buf jb;
|
||||
{
|
||||
/* restore stack pointer and program counter */
|
||||
asm volatile ("ldw 4(%arg0), %sp");
|
||||
asm volatile ("ldw 8(%arg0), %rp");
|
||||
/* restore stack pointer and program counter */
|
||||
asm volatile ("ldw 4(%arg0), %sp");
|
||||
asm volatile ("ldw 8(%arg0), %rp");
|
||||
|
||||
/* restore "callee save" space register */
|
||||
asm volatile ("ldw 0(%arg0), %r1");
|
||||
asm volatile ("mtsp %r1, %sr3");
|
||||
/* restore "callee save" space register */
|
||||
asm volatile ("ldw 0(%arg0), %r1");
|
||||
asm volatile ("mtsp %r1, %sr3");
|
||||
|
||||
/* restore "callee save" registers */
|
||||
asm volatile ("ldw 12(%arg0), %r3");
|
||||
asm volatile ("ldw 16(%arg0), %r4");
|
||||
asm volatile ("ldw 20(%arg0), %r5");
|
||||
asm volatile ("ldw 24(%arg0), %r6");
|
||||
asm volatile ("ldw 28(%arg0), %r7");
|
||||
asm volatile ("ldw 32(%arg0), %r8");
|
||||
asm volatile ("ldw 36(%arg0), %r9");
|
||||
asm volatile ("ldw 40(%arg0), %r10");
|
||||
asm volatile ("ldw 44(%arg0), %r11");
|
||||
asm volatile ("ldw 48(%arg0), %r12");
|
||||
asm volatile ("ldw 52(%arg0), %r13");
|
||||
asm volatile ("ldw 56(%arg0), %r14");
|
||||
asm volatile ("ldw 60(%arg0), %r15");
|
||||
asm volatile ("ldw 64(%arg0), %r16");
|
||||
asm volatile ("ldw 68(%arg0), %r17");
|
||||
asm volatile ("ldw 72(%arg0), %r18");
|
||||
/* restore "callee save" registers */
|
||||
asm volatile ("ldw 12(%arg0), %r3");
|
||||
asm volatile ("ldw 16(%arg0), %r4");
|
||||
asm volatile ("ldw 20(%arg0), %r5");
|
||||
asm volatile ("ldw 24(%arg0), %r6");
|
||||
asm volatile ("ldw 28(%arg0), %r7");
|
||||
asm volatile ("ldw 32(%arg0), %r8");
|
||||
asm volatile ("ldw 36(%arg0), %r9");
|
||||
asm volatile ("ldw 40(%arg0), %r10");
|
||||
asm volatile ("ldw 44(%arg0), %r11");
|
||||
asm volatile ("ldw 48(%arg0), %r12");
|
||||
asm volatile ("ldw 52(%arg0), %r13");
|
||||
asm volatile ("ldw 56(%arg0), %r14");
|
||||
asm volatile ("ldw 60(%arg0), %r15");
|
||||
asm volatile ("ldw 64(%arg0), %r16");
|
||||
asm volatile ("ldw 68(%arg0), %r17");
|
||||
asm volatile ("ldw 72(%arg0), %r18");
|
||||
|
||||
/* warp to saved() to unwind the frame correctly */
|
||||
asm volatile ("bl _comefrom_, %r0");
|
||||
asm volatile ("ldi 1, %ret0");
|
||||
/* warp to saved() to unwind the frame correctly */
|
||||
asm volatile ("bl _comefrom_, %r0");
|
||||
asm volatile ("ldi 1, %ret0");
|
||||
}
|
||||
|
||||
#elif defined(BSD386)
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
newp->context[2] = (int)sp;
|
||||
newp->context[0] = (int)lwpEntryPoint;
|
||||
newp->context[2] = (int)sp;
|
||||
newp->context[0] = (int)lwpEntryPoint;
|
||||
}
|
||||
|
||||
#elif defined(FBSD)
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
setjmp (newp->context);
|
||||
newp->context->_jb[2] = (int)sp;
|
||||
newp->context->_jb[3] = (int)sp;
|
||||
newp->context->_jb[0] = (int)lwpEntryPoint;
|
||||
setjmp(newp->context);
|
||||
newp->context->_jb[2] = (int)sp;
|
||||
newp->context->_jb[3] = (int)sp;
|
||||
newp->context->_jb[0] = (int)lwpEntryPoint;
|
||||
}
|
||||
|
||||
#elif defined(__linux__)
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
#if defined(__GLIBC__) && (__GLIBC__ >= 2)
|
||||
#if defined(__PPC__)
|
||||
newp->context->__jmpbuf[JB_GPR1] = (int) sp;
|
||||
newp->context->__jmpbuf[JB_LR] = (int) lwpEntryPoint;
|
||||
newp->context->__jmpbuf[JB_GPR1] = (int)sp;
|
||||
newp->context->__jmpbuf[JB_LR] = (int)lwpEntryPoint;
|
||||
#else
|
||||
newp->context->__jmpbuf[JB_SP] = (int) sp;
|
||||
newp->context->__jmpbuf[JB_BP] = (int) sp;
|
||||
newp->context->__jmpbuf[JB_PC] = (int) lwpEntryPoint;
|
||||
newp->context->__jmpbuf[JB_SP] = (int)sp;
|
||||
newp->context->__jmpbuf[JB_BP] = (int)sp;
|
||||
newp->context->__jmpbuf[JB_PC] = (int)lwpEntryPoint;
|
||||
#endif
|
||||
#else
|
||||
newp->context->__sp = sp;
|
||||
newp->context->__bp = sp;
|
||||
newp->context->__pc = (void *)lwpEntryPoint;
|
||||
newp->context->__sp = sp;
|
||||
newp->context->__bp = sp;
|
||||
newp->context->__pc = (void *)lwpEntryPoint;
|
||||
#endif
|
||||
}
|
||||
|
||||
#elif defined(SUN3)
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
newp->context[2] = (int)sp;
|
||||
newp->context[3] = (int)lwpEntryPoint;
|
||||
newp->context[2] = (int)sp;
|
||||
newp->context[3] = (int)lwpEntryPoint;
|
||||
}
|
||||
|
||||
#elif defined(__vax)
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
void lwpInitContext(newp, stack)
|
||||
struct lwpProc *newp;
|
||||
void *stack;
|
||||
void
|
||||
lwpInitContext(newp, stack)
|
||||
struct lwpProc *newp;
|
||||
void *stack;
|
||||
{
|
||||
int *sp = (int*)stack;
|
||||
int *sp = (int *)stack;
|
||||
int *fp = 0;
|
||||
|
||||
/* Build root frame on new stack for lwpEntryPoint */
|
||||
|
|
@ -248,7 +261,7 @@ void lwpInitContext(newp, stack)
|
|||
fp = sp;
|
||||
|
||||
/* Build stack frame to return from. */
|
||||
*--sp = (int)lwpEntryPoint+2;/* pc */
|
||||
*--sp = (int)lwpEntryPoint + 2; /* pc */
|
||||
*--sp = (int)fp; /* fp */
|
||||
*--sp = 0; /* ap */
|
||||
*--sp = 0; /* psw */
|
||||
|
|
@ -268,8 +281,9 @@ void lwpInitContext(newp, stack)
|
|||
return;
|
||||
}
|
||||
|
||||
int lwpSave(jb)
|
||||
jmp_buf jb;
|
||||
int
|
||||
lwpSave(jb)
|
||||
jmp_buf jb;
|
||||
{
|
||||
asm("movl 4(ap), r0"); /* r0 = &jb */
|
||||
asm("movl r6, (r0)"); /* jb[0] = r6 */
|
||||
|
|
@ -283,8 +297,9 @@ int lwpSave(jb)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void lwpRestore(jb)
|
||||
jmp_buf jb;
|
||||
void
|
||||
lwpRestore(jb)
|
||||
jmp_buf jb;
|
||||
{
|
||||
asm("movl 4(ap), r0"); /* r0 = &jb */
|
||||
asm("movl (r0), r6"); /* r6 = jb[0] */
|
||||
|
|
@ -303,31 +318,32 @@ void lwpRestore(jb)
|
|||
|
||||
#elif defined(SUN4)
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
static jmp_buf *cpp;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
static jmp_buf *cpp;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
|
||||
bzero(newp->context, sizeof(newp->context));
|
||||
newp->context[0] = (int)sp;
|
||||
/* preserve cpp for new context */
|
||||
cpp = (jmp_buf *)&newp->context;
|
||||
if (!_setjmp(LwpCurrent->context)) {
|
||||
/* create new context */
|
||||
/* flush registers */
|
||||
asm ("ta 0x03");
|
||||
/* %o0 <- newp */
|
||||
asm ("ld [%fp+0x44], %o0");
|
||||
/* %o1 <- newp->context[0] */
|
||||
asm ("ld [%o0], %o1");
|
||||
/* create min frame on new stack */
|
||||
asm ("save %o1,-96, %sp");
|
||||
if (!_setjmp(*cpp))
|
||||
_longjmp(LwpCurrent->context, 1);
|
||||
lwpEntryPoint();
|
||||
}
|
||||
bzero(newp->context, sizeof(newp->context));
|
||||
newp->context[0] = (int)sp;
|
||||
/* preserve cpp for new context */
|
||||
cpp = (jmp_buf *) & newp->context;
|
||||
if (!_setjmp(LwpCurrent->context)) {
|
||||
/* create new context */
|
||||
/* flush registers */
|
||||
asm("ta 0x03");
|
||||
/* %o0 <- newp */
|
||||
asm("ld [%fp+0x44], %o0");
|
||||
/* %o1 <- newp->context[0] */
|
||||
asm("ld [%o0], %o1");
|
||||
/* create min frame on new stack */
|
||||
asm("save %o1,-96, %sp");
|
||||
if (!_setjmp(*cpp))
|
||||
_longjmp(LwpCurrent->context, 1);
|
||||
lwpEntryPoint();
|
||||
}
|
||||
}
|
||||
|
||||
#elif defined(__USLC__) && defined(i386)
|
||||
|
|
@ -360,12 +376,13 @@ void lwpInitContext(newp, sp)
|
|||
* context + 0x14 [5] -> jump location for return
|
||||
*/
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
newp->context[4] = (int)sp;
|
||||
newp->context[5] = (int)lwpEntryPoint;
|
||||
newp->context[4] = (int)sp;
|
||||
newp->context[5] = (int)lwpEntryPoint;
|
||||
}
|
||||
|
||||
#elif defined UCONTEXT
|
||||
|
|
@ -375,50 +392,54 @@ void lwpInitContext(newp, sp)
|
|||
* longjump. This should work on any SVr4 machine independant of
|
||||
* architecture. Unfortunaltely some changes are still nessesary in lwp.c.
|
||||
* Tested on IRIX 5.3
|
||||
*/
|
||||
*/
|
||||
|
||||
void lwpInitContext(newp, spp)
|
||||
struct lwpProc *newp;
|
||||
stack_t *spp;
|
||||
void
|
||||
lwpInitContext(newp, spp)
|
||||
struct lwpProc *newp;
|
||||
stack_t *spp;
|
||||
{
|
||||
getcontext (&(newp->context));
|
||||
newp->context.uc_stack.ss_sp = spp->ss_sp;
|
||||
newp->context.uc_stack.ss_size = spp->ss_size;
|
||||
makecontext (&(newp->context), lwpEntryPoint, 0);
|
||||
getcontext(&(newp->context));
|
||||
newp->context.uc_stack.ss_sp = spp->ss_sp;
|
||||
newp->context.uc_stack.ss_size = spp->ss_size;
|
||||
makecontext(&(newp->context), lwpEntryPoint, 0);
|
||||
}
|
||||
|
||||
#elif defined(ALPHA)
|
||||
|
||||
#include <c_asm.h>
|
||||
|
||||
void lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
void
|
||||
lwpInitContext(newp, sp)
|
||||
struct lwpProc *newp;
|
||||
void *sp;
|
||||
{
|
||||
extern long *_gp;
|
||||
extern long *_gp;
|
||||
|
||||
/* register values obtained from setjmp.h */
|
||||
_setjmp(newp->context);
|
||||
newp->context[2] = (long)lwpEntryPoint; /* program counter */
|
||||
newp->context[30] = (long)lwpEntryPoint; /* return address */
|
||||
newp->context[31] = (long)lwpEntryPoint; /* fake program value (!) */
|
||||
newp->context[34] = (long)sp; /* stack pointer */
|
||||
/* register values obtained from setjmp.h */
|
||||
_setjmp(newp->context);
|
||||
newp->context[2] = (long)lwpEntryPoint; /* program counter */
|
||||
newp->context[30] = (long)lwpEntryPoint; /* return address */
|
||||
newp->context[31] = (long)lwpEntryPoint; /* fake program value (!) */
|
||||
newp->context[34] = (long)sp; /* stack pointer */
|
||||
}
|
||||
|
||||
int lwpSave(jb)
|
||||
jmp_buf jb;
|
||||
int
|
||||
lwpSave(jb)
|
||||
jmp_buf jb;
|
||||
{
|
||||
return _setjmp(jb);
|
||||
return _setjmp(jb);
|
||||
}
|
||||
|
||||
void lwpRestore(jb)
|
||||
jmp_buf jb;
|
||||
void
|
||||
lwpRestore(jb)
|
||||
jmp_buf jb;
|
||||
{
|
||||
/* resume, but get the pv from the jmp_buf */
|
||||
asm("ldq %pv, 248(%a0)");
|
||||
asm("stq %a0, 16(%sp)");
|
||||
/* generates a warning, but functions just fine */
|
||||
asm("bsr %ra, __longjump_resume");
|
||||
/* resume, but get the pv from the jmp_buf */
|
||||
asm("ldq %pv, 248(%a0)");
|
||||
asm("stq %a0, 16(%sp)");
|
||||
/* generates a warning, but functions just fine */
|
||||
asm("bsr %ra, __longjump_resume");
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -41,16 +41,16 @@ extern struct lwpProc *initcontext;
|
|||
extern int startpoint;
|
||||
#endif
|
||||
|
||||
struct lwpQueue LwpSchedQ[LWP_MAX_PRIO], LwpDeadQ;
|
||||
struct lwpQueue LwpSchedQ[LWP_MAX_PRIO], LwpDeadQ;
|
||||
|
||||
struct lwpProc *LwpCurrent = NULL;
|
||||
char **LwpContextPtr;
|
||||
int LwpMaxpri=0; /* maximum priority so far */
|
||||
struct lwpProc *LwpCurrent = NULL;
|
||||
char **LwpContextPtr;
|
||||
int LwpMaxpri = 0; /* maximum priority so far */
|
||||
|
||||
#ifdef POSIXSIGNALS
|
||||
static sigset_t oldmask;
|
||||
#else /* POSIXSIGNALS */
|
||||
static int oldmask;
|
||||
static sigset_t oldmask;
|
||||
#else /* POSIXSIGNALS */
|
||||
static int oldmask;
|
||||
#endif /* POSIXSIGNALS */
|
||||
|
||||
/* for systems without strdup */
|
||||
|
|
@ -58,169 +58,168 @@ static int oldmask;
|
|||
extern char *strdup();
|
||||
#endif /* NOSTRDUP */
|
||||
|
||||
static void lwpStackCheckInit();
|
||||
static int lwpStackCheck();
|
||||
static void lwpStackCheckUsed();
|
||||
static void lwpStackCheckInit();
|
||||
static int lwpStackCheck();
|
||||
static void lwpStackCheckUsed();
|
||||
|
||||
/* check stack direction */
|
||||
static int growsdown (x)
|
||||
void *x;
|
||||
static int
|
||||
growsdown(x)
|
||||
void *x;
|
||||
{
|
||||
int y;
|
||||
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_OFF;
|
||||
#endif
|
||||
y = (x > (void *)&y);
|
||||
int y;
|
||||
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_ON;
|
||||
BOUNDS_CHECKING_OFF;
|
||||
#endif
|
||||
|
||||
return y;
|
||||
y = (x > (void *)&y);
|
||||
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_ON;
|
||||
#endif
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
/*
|
||||
* lwpReschedule -- schedule another process. we also check for dead
|
||||
* processes here and free them.
|
||||
*/
|
||||
void lwpReschedule()
|
||||
void
|
||||
lwpReschedule()
|
||||
{
|
||||
extern struct lwpQueue LwpSchedQ[];
|
||||
static int lcount = LCOUNT;
|
||||
static struct lwpProc *nextp;
|
||||
static int i;
|
||||
extern struct lwpQueue LwpSchedQ[];
|
||||
static int lcount = LCOUNT;
|
||||
static struct lwpProc *nextp;
|
||||
static int i;
|
||||
#ifdef POSIXSIGNALS
|
||||
static sigset_t tmask;
|
||||
static sigset_t tmask;
|
||||
#endif /* POSIXSIGNALS */
|
||||
|
||||
if (LwpCurrent && (LwpCurrent->flags & LWP_STACKCHECK)) {
|
||||
lwpStackCheck(LwpCurrent);
|
||||
}
|
||||
if (!--lcount) {
|
||||
int p = lwpSetPriority(LWP_MAX_PRIO-1);
|
||||
lcount = LCOUNT;
|
||||
if (LwpCurrent && (LwpCurrent->flags & LWP_STACKCHECK)) {
|
||||
lwpStackCheck(LwpCurrent);
|
||||
}
|
||||
if (!--lcount) {
|
||||
int p = lwpSetPriority(LWP_MAX_PRIO - 1);
|
||||
lcount = LCOUNT;
|
||||
#ifdef POSIXSIGNALS
|
||||
sigprocmask (SIG_SETMASK, &oldmask, &tmask);
|
||||
sigprocmask (SIG_SETMASK, &tmask, &oldmask);
|
||||
#else /* POSIXSIGNALS */
|
||||
sigsetmask(sigsetmask(oldmask));
|
||||
sigprocmask(SIG_SETMASK, &oldmask, &tmask);
|
||||
sigprocmask(SIG_SETMASK, &tmask, &oldmask);
|
||||
#else /* POSIXSIGNALS */
|
||||
sigsetmask(sigsetmask(oldmask));
|
||||
#endif /* POSIXSIGNALS */
|
||||
LwpCurrent->pri = p;
|
||||
LwpCurrent->pri = p;
|
||||
}
|
||||
|
||||
/* destroy dead threads */
|
||||
lwpStatus(LwpCurrent, "Cleaning dead queue");
|
||||
while (NULL != (nextp = lwpGetFirst(&LwpDeadQ))) {
|
||||
if (nextp == LwpCurrent) {
|
||||
lwpStatus(nextp, "OOOPS, we are running already dead thread");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* destroy dead threads */
|
||||
lwpStatus(LwpCurrent, "Cleaning dead queue");
|
||||
while (NULL != (nextp = lwpGetFirst(&LwpDeadQ))) {
|
||||
if (nextp == LwpCurrent) {
|
||||
lwpStatus(nextp,
|
||||
"OOOPS, we are running already dead thread");
|
||||
exit(1);
|
||||
}
|
||||
lwpDestroy(nextp);
|
||||
lwpStatus(LwpCurrent, "Destroying done");
|
||||
}
|
||||
|
||||
for (i = LwpMaxpri + 1; i--;) {
|
||||
while (NULL != (nextp = lwpGetFirst(&LwpSchedQ[i]))) {
|
||||
if (!nextp->dead)
|
||||
break;
|
||||
/* clean up after dead bodies */
|
||||
lwpStatus(nextp, "got a dead body");
|
||||
if (nextp == LwpCurrent) {
|
||||
lwpStatus(nextp, "we are in it -- will bury later");
|
||||
lwpAddTail(&LwpDeadQ, nextp);
|
||||
} else {
|
||||
lwpDestroy(nextp);
|
||||
lwpStatus(LwpCurrent, "Destroying done");
|
||||
}
|
||||
|
||||
for (i=LwpMaxpri+1; i--; ) {
|
||||
while (NULL != (nextp = lwpGetFirst(&LwpSchedQ[i]))) {
|
||||
if (!nextp->dead)
|
||||
break;
|
||||
/* clean up after dead bodies */
|
||||
lwpStatus(nextp, "got a dead body");
|
||||
if (nextp == LwpCurrent) {
|
||||
lwpStatus(nextp,
|
||||
"we are in it -- will bury later");
|
||||
lwpAddTail(&LwpDeadQ, nextp);
|
||||
}
|
||||
else{
|
||||
lwpDestroy(nextp);
|
||||
/* fprintf(stderr, "Destroying done\n"); */
|
||||
}
|
||||
nextp = 0;
|
||||
}
|
||||
if (nextp)
|
||||
break;
|
||||
}
|
||||
nextp = 0;
|
||||
}
|
||||
if (LwpCurrent == 0 && nextp == 0) {
|
||||
fprintf(stderr, "No processes to run!\n");
|
||||
exit(1);
|
||||
}
|
||||
if (LwpCurrent)
|
||||
lwpStatus(LwpCurrent, "switch out");
|
||||
/* do context switch */
|
||||
if (nextp)
|
||||
break;
|
||||
}
|
||||
if (LwpCurrent == 0 && nextp == 0) {
|
||||
fprintf(stderr, "No processes to run!\n");
|
||||
exit(1);
|
||||
}
|
||||
if (LwpCurrent)
|
||||
lwpStatus(LwpCurrent, "switch out");
|
||||
/* do context switch */
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_OFF;
|
||||
BOUNDS_CHECKING_OFF;
|
||||
#endif
|
||||
|
||||
#if defined(hpc)
|
||||
{
|
||||
int endpoint;
|
||||
{
|
||||
int endpoint;
|
||||
|
||||
endpoint = &endpoint;
|
||||
if (initcontext == NULL || endpoint < startpoint) {
|
||||
i = lwpSave(LwpCurrent->context);
|
||||
} else {
|
||||
LwpCurrent->size = endpoint - startpoint;
|
||||
LwpCurrent->sbtm = realloc(LwpCurrent->sbtm, LwpCurrent->size);
|
||||
memcpy(LwpCurrent->sbtm, startpoint, LwpCurrent->size);
|
||||
if (i = lwpSave(LwpCurrent->context)) {
|
||||
memcpy(startpoint, LwpCurrent->sbtm, LwpCurrent->size);
|
||||
i = 1;
|
||||
}
|
||||
}
|
||||
endpoint = &endpoint;
|
||||
if (initcontext == NULL || endpoint < startpoint) {
|
||||
i = lwpSave(LwpCurrent->context);
|
||||
} else {
|
||||
LwpCurrent->size = endpoint - startpoint;
|
||||
LwpCurrent->sbtm = realloc(LwpCurrent->sbtm, LwpCurrent->size);
|
||||
memcpy(LwpCurrent->sbtm, startpoint, LwpCurrent->size);
|
||||
if (i = lwpSave(LwpCurrent->context)) {
|
||||
memcpy(startpoint, LwpCurrent->sbtm, LwpCurrent->size);
|
||||
i = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
i = lwpSave(LwpCurrent->context);
|
||||
i = lwpSave(LwpCurrent->context);
|
||||
#endif
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_ON;
|
||||
#endif
|
||||
|
||||
if (LwpCurrent != nextp && !(LwpCurrent && i)) {
|
||||
/* restore previous context */
|
||||
lwpStatus(nextp, "switch in", nextp->pri);
|
||||
LwpCurrent = nextp;
|
||||
*LwpContextPtr = LwpCurrent->ud;
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_OFF;
|
||||
#endif
|
||||
lwpRestore(LwpCurrent->context);
|
||||
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_ON;
|
||||
#endif
|
||||
|
||||
if (LwpCurrent != nextp &&
|
||||
!(LwpCurrent && i)) {
|
||||
/* restore previous context */
|
||||
lwpStatus(nextp, "switch in", nextp->pri);
|
||||
LwpCurrent = nextp;
|
||||
*LwpContextPtr = LwpCurrent->ud;
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_OFF;
|
||||
#endif
|
||||
lwpRestore(LwpCurrent->context);
|
||||
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_ON;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* lwpEntryPoint -- process entry point.
|
||||
*/
|
||||
void lwpEntryPoint()
|
||||
void
|
||||
lwpEntryPoint()
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
#ifdef POSIXSIGNALS
|
||||
sigset_t set;
|
||||
sigset_t set;
|
||||
#endif /* POSIXSIGNALS */
|
||||
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_OFF;
|
||||
BOUNDS_CHECKING_OFF;
|
||||
#endif
|
||||
#ifdef POSIXSIGNALS
|
||||
sigemptyset (&set);
|
||||
sigaddset (&set, SIGALRM);
|
||||
sigprocmask (SIG_SETMASK, &set, &oldmask);
|
||||
#else /* POSIXSIGNALS */
|
||||
sigsetmask(SIGNALS);
|
||||
sigemptyset(&set);
|
||||
sigaddset(&set, SIGALRM);
|
||||
sigprocmask(SIG_SETMASK, &set, &oldmask);
|
||||
#else /* POSIXSIGNALS */
|
||||
sigsetmask(SIGNALS);
|
||||
#endif /* POSIXSIGNALS */
|
||||
*LwpContextPtr = LwpCurrent->ud;
|
||||
*LwpContextPtr = LwpCurrent->ud;
|
||||
|
||||
lwpStatus(LwpCurrent, "starting at entry point");
|
||||
(*LwpCurrent->entry)(LwpCurrent->argc, LwpCurrent->argv,
|
||||
LwpCurrent->ud);
|
||||
lwpExit();
|
||||
lwpStatus(LwpCurrent, "starting at entry point");
|
||||
(*LwpCurrent->entry) (LwpCurrent->argc, LwpCurrent->argv,
|
||||
LwpCurrent->ud);
|
||||
lwpExit();
|
||||
#ifdef BOUNDS_CHECK
|
||||
BOUNDS_CHECKING_ON;
|
||||
BOUNDS_CHECKING_ON;
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -231,274 +230,284 @@ void lwpEntryPoint()
|
|||
*/
|
||||
struct lwpProc *
|
||||
lwpCreate(priority, entry, size, flags, name, desc, argc, argv, ud)
|
||||
int priority;
|
||||
void (*entry)();
|
||||
int size;
|
||||
int flags;
|
||||
char *name;
|
||||
char *desc;
|
||||
int argc;
|
||||
char *argv[];
|
||||
void *ud;
|
||||
int priority;
|
||||
void (*entry) ();
|
||||
int size;
|
||||
int flags;
|
||||
char *name;
|
||||
char *desc;
|
||||
int argc;
|
||||
char *argv[];
|
||||
void *ud;
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
struct lwpProc *newp;
|
||||
int *s, x;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
struct lwpProc *newp;
|
||||
int *s, x;
|
||||
#ifdef UCONTEXT
|
||||
stack_t sp;
|
||||
#else /* UCONTEXT */
|
||||
void *sp;
|
||||
stack_t sp;
|
||||
#else /* UCONTEXT */
|
||||
void *sp;
|
||||
#endif /* UCONTEXT */
|
||||
unsigned long stackp;
|
||||
unsigned long stackp;
|
||||
|
||||
if (!(newp = (struct lwpProc *)malloc(sizeof(struct lwpProc))))
|
||||
return (0);
|
||||
if (flags & LWP_STACKCHECK) {
|
||||
/* Add a 1K buffer on each side of the stack */
|
||||
size += 2 * LWP_REDZONE;
|
||||
}
|
||||
size += LWP_EXTRASTACK;
|
||||
size += sizeof(stkalign_t);
|
||||
if (!(s = (int *)malloc(size)))
|
||||
return (0);
|
||||
newp->flags = flags;
|
||||
newp->name = strdup(name);
|
||||
newp->desc = strdup(desc);
|
||||
newp->entry = entry;
|
||||
newp->argc = argc;
|
||||
newp->argv = argv;
|
||||
newp->ud = ud;
|
||||
if ((newp->flags & LWP_STACKCHECK) == 0) {
|
||||
stackp = growsdown((void *)&x) ?
|
||||
(((long)s) + size - sizeof(stkalign_t) - LWP_EXTRASTACK) :
|
||||
(long) s + LWP_EXTRASTACK;
|
||||
if (!(newp = (struct lwpProc *)malloc(sizeof(struct lwpProc))))
|
||||
return (0);
|
||||
if (flags & LWP_STACKCHECK) {
|
||||
/* Add a 1K buffer on each side of the stack */
|
||||
size += 2 * LWP_REDZONE;
|
||||
}
|
||||
size += LWP_EXTRASTACK;
|
||||
size += sizeof(stkalign_t);
|
||||
if (!(s = (int *)malloc(size)))
|
||||
return (0);
|
||||
newp->flags = flags;
|
||||
newp->name = strdup(name);
|
||||
newp->desc = strdup(desc);
|
||||
newp->entry = entry;
|
||||
newp->argc = argc;
|
||||
newp->argv = argv;
|
||||
newp->ud = ud;
|
||||
if ((newp->flags & LWP_STACKCHECK) == 0) {
|
||||
stackp = growsdown((void *)&x) ?
|
||||
(((long)s) + size - sizeof(stkalign_t) - LWP_EXTRASTACK) :
|
||||
(long)s + LWP_EXTRASTACK;
|
||||
#ifdef UCONTEXT
|
||||
sp.ss_sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
sp.ss_size = size;
|
||||
sp.ss_flags = 0;
|
||||
#else /* UCONTEXT */
|
||||
sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
sp.ss_sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
sp.ss_size = size;
|
||||
sp.ss_flags = 0;
|
||||
#else /* UCONTEXT */
|
||||
sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
#endif /* UCONTEXT */
|
||||
} else {
|
||||
if (growsdown(&x)) {
|
||||
/* round address off to stkalign_t */
|
||||
stackp = ((long)s) + size - LWP_REDZONE -
|
||||
LWP_EXTRASTACK - sizeof(stkalign_t);
|
||||
#ifdef UCONTEXT
|
||||
sp.ss_sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
sp.ss_size = size;
|
||||
sp.ss_flags = 0;
|
||||
newp->lowmark = (void *)(((long)sp.ss_sp) + LWP_EXTRASTACK);
|
||||
#else /* UCONTEXT */
|
||||
sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
newp->lowmark = (void *)(((long)sp) + LWP_EXTRASTACK);
|
||||
#endif /* UCONTEXT */
|
||||
newp->himark = s;
|
||||
} else {
|
||||
if (growsdown(&x)) {
|
||||
/* round address off to stkalign_t */
|
||||
stackp = ((long)s) + size - LWP_REDZONE -
|
||||
LWP_EXTRASTACK - sizeof(stkalign_t);
|
||||
#ifdef UCONTEXT
|
||||
sp.ss_sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
sp.ss_size = size;
|
||||
sp.ss_flags = 0;
|
||||
newp->lowmark = (void *)(((long) sp.ss_sp) + LWP_EXTRASTACK);
|
||||
#else /* UCONTEXT */
|
||||
sp = (void *)(stackp & -sizeof(stkalign_t));
|
||||
newp->lowmark = (void *)(((long) sp) + LWP_EXTRASTACK);
|
||||
#endif /* UCONTEXT */
|
||||
newp->himark = s;
|
||||
} else {
|
||||
stackp = ((long)s) + LWP_REDZONE + LWP_EXTRASTACK;
|
||||
#ifdef UCONTEXT
|
||||
sp.ss_sp = (void *)(((long)stackp) &
|
||||
-sizeof(stkalign_t));
|
||||
sp.ss_size = size;
|
||||
sp.ss_flags = 0;
|
||||
#else /* UCONTEXT */
|
||||
sp = (void *)(((long)stackp) & -sizeof(stkalign_t));
|
||||
#endif /* UCONTEXT */
|
||||
newp->lowmark = (void *)s;
|
||||
newp->himark = (void *)(((long)s) + size - LWP_REDZONE);
|
||||
}
|
||||
}
|
||||
if (LWP_MAX_PRIO <= priority)
|
||||
priority = LWP_MAX_PRIO-1;
|
||||
if (LwpMaxpri < (newp->pri = priority))
|
||||
LwpMaxpri = priority;
|
||||
newp->sbtm = (void *)s;
|
||||
newp->size = size;
|
||||
newp->dead = 0;
|
||||
if (flags & LWP_STACKCHECK)
|
||||
lwpStackCheckInit(newp);
|
||||
lwpStatus(newp, "creating process structure sbtm: %d",
|
||||
(int)newp->sbtm);
|
||||
lwpReady(newp);
|
||||
lwpReady(LwpCurrent);
|
||||
stackp = ((long)s) + LWP_REDZONE + LWP_EXTRASTACK;
|
||||
#ifdef UCONTEXT
|
||||
lwpInitContext(newp, &sp); /* architecture-dependent: from arch.c */
|
||||
#else /* UCONTEXT */
|
||||
lwpInitContext(newp, sp); /* architecture-dependent: from arch.c */
|
||||
sp.ss_sp = (void *)(((long)stackp) & -sizeof(stkalign_t));
|
||||
sp.ss_size = size;
|
||||
sp.ss_flags = 0;
|
||||
#else /* UCONTEXT */
|
||||
sp = (void *)(((long)stackp) & -sizeof(stkalign_t));
|
||||
#endif /* UCONTEXT */
|
||||
lwpReschedule();
|
||||
return (newp);
|
||||
newp->lowmark = (void *)s;
|
||||
newp->himark = (void *)(((long)s) + size - LWP_REDZONE);
|
||||
}
|
||||
}
|
||||
if (LWP_MAX_PRIO <= priority)
|
||||
priority = LWP_MAX_PRIO - 1;
|
||||
if (LwpMaxpri < (newp->pri = priority))
|
||||
LwpMaxpri = priority;
|
||||
newp->sbtm = (void *)s;
|
||||
newp->size = size;
|
||||
newp->dead = 0;
|
||||
if (flags & LWP_STACKCHECK)
|
||||
lwpStackCheckInit(newp);
|
||||
lwpStatus(newp, "creating process structure sbtm: %d",
|
||||
(int)newp->sbtm);
|
||||
lwpReady(newp);
|
||||
lwpReady(LwpCurrent);
|
||||
#ifdef UCONTEXT
|
||||
lwpInitContext(newp, &sp); /* architecture-dependent: from arch.c */
|
||||
#else /* UCONTEXT */
|
||||
lwpInitContext(newp, sp); /* architecture-dependent: from arch.c */
|
||||
#endif /* UCONTEXT */
|
||||
lwpReschedule();
|
||||
return (newp);
|
||||
}
|
||||
|
||||
void lwpDestroy(proc)
|
||||
struct lwpProc *proc;
|
||||
void
|
||||
lwpDestroy(proc)
|
||||
struct lwpProc *proc;
|
||||
{
|
||||
if (proc->flags & LWP_STACKCHECK){
|
||||
lwpStackCheckUsed(proc);
|
||||
lwpStackCheck(proc);
|
||||
}
|
||||
lwpStatus(proc, "destroying sbtm: %d", (int)proc->sbtm);
|
||||
proc->entry = 0;
|
||||
proc->ud = 0;
|
||||
proc->argv = 0;
|
||||
free((char *)proc->sbtm);
|
||||
free(proc->name);
|
||||
free(proc->desc);
|
||||
proc->name = 0;
|
||||
proc->desc = 0;
|
||||
proc->sbtm = 0;
|
||||
proc->lowmark = 0;
|
||||
proc->himark = 0;
|
||||
free((char *)proc);
|
||||
if (proc->flags & LWP_STACKCHECK) {
|
||||
lwpStackCheckUsed(proc);
|
||||
lwpStackCheck(proc);
|
||||
}
|
||||
lwpStatus(proc, "destroying sbtm: %d", (int)proc->sbtm);
|
||||
proc->entry = 0;
|
||||
proc->ud = 0;
|
||||
proc->argv = 0;
|
||||
free((char *)proc->sbtm);
|
||||
free(proc->name);
|
||||
free(proc->desc);
|
||||
proc->name = 0;
|
||||
proc->desc = 0;
|
||||
proc->sbtm = 0;
|
||||
proc->lowmark = 0;
|
||||
proc->himark = 0;
|
||||
free((char *)proc);
|
||||
}
|
||||
|
||||
/*
|
||||
* lwpReady -- put process on ready queue. if null, assume current.
|
||||
*/
|
||||
void lwpReady(p)
|
||||
struct lwpProc *p;
|
||||
void
|
||||
lwpReady(p)
|
||||
struct lwpProc *p;
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpQueue LwpSchedQ[];
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpQueue LwpSchedQ[];
|
||||
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
lwpStatus(p, "added to run queue");
|
||||
lwpAddTail(&LwpSchedQ[p->pri], p);
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
lwpStatus(p, "added to run queue");
|
||||
lwpAddTail(&LwpSchedQ[p->pri], p);
|
||||
}
|
||||
|
||||
/*
|
||||
* return user's data
|
||||
*/
|
||||
void *lwpGetUD(p)
|
||||
struct lwpProc *p;
|
||||
void *
|
||||
lwpGetUD(p)
|
||||
struct lwpProc *p;
|
||||
{
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
return (p->ud);
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
return (p->ud);
|
||||
}
|
||||
|
||||
/*
|
||||
* set user's data
|
||||
*/
|
||||
void lwpSetUD(p, ud)
|
||||
struct lwpProc *p;
|
||||
char *ud;
|
||||
void
|
||||
lwpSetUD(p, ud)
|
||||
struct lwpProc *p;
|
||||
char *ud;
|
||||
{
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
p->ud = ud;
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
p->ud = ud;
|
||||
}
|
||||
|
||||
/*
|
||||
* set name & desc
|
||||
*/
|
||||
void lwpSetDesc(p, name, desc)
|
||||
struct lwpProc *p;
|
||||
char *name;
|
||||
char *desc;
|
||||
void
|
||||
lwpSetDesc(p, name, desc)
|
||||
struct lwpProc *p;
|
||||
char *name;
|
||||
char *desc;
|
||||
{
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
free(p->name);
|
||||
free(p->desc);
|
||||
p->name = strdup(name);
|
||||
p->desc = strdup(desc);
|
||||
if (!p)
|
||||
p = LwpCurrent;
|
||||
free(p->name);
|
||||
free(p->desc);
|
||||
p->name = strdup(name);
|
||||
p->desc = strdup(desc);
|
||||
}
|
||||
|
||||
/*
|
||||
* lwpYield -- yield the processor to another thread.
|
||||
*/
|
||||
void lwpYield()
|
||||
void
|
||||
lwpYield()
|
||||
{
|
||||
lwpStatus(LwpCurrent, "yielding control");
|
||||
lwpReady(LwpCurrent);
|
||||
lwpReschedule();
|
||||
lwpStatus(LwpCurrent, "yielding control");
|
||||
lwpReady(LwpCurrent);
|
||||
lwpReschedule();
|
||||
}
|
||||
|
||||
/*
|
||||
* cause the current process to be scheduled for deletion.
|
||||
*/
|
||||
void lwpExit()
|
||||
void
|
||||
lwpExit()
|
||||
{
|
||||
lwpStatus(LwpCurrent, "marking self as dead");
|
||||
LwpCurrent->dead = 1;
|
||||
lwpYield();
|
||||
lwpStatus(LwpCurrent, "marking self as dead");
|
||||
LwpCurrent->dead = 1;
|
||||
lwpYield();
|
||||
}
|
||||
|
||||
/*
|
||||
* mark another process as dead, so it will never be rescheduled.
|
||||
* remove any lingering FD action
|
||||
*/
|
||||
void lwpTerminate(p)
|
||||
struct lwpProc *p;
|
||||
void
|
||||
lwpTerminate(p)
|
||||
struct lwpProc *p;
|
||||
{
|
||||
lwpStatus(p, "terminating process");
|
||||
p->dead = 1;
|
||||
if (p->fd >= 0)
|
||||
lwpWakeupFd(p);
|
||||
lwpStatus(p, "terminating process");
|
||||
p->dead = 1;
|
||||
if (p->fd >= 0)
|
||||
lwpWakeupFd(p);
|
||||
}
|
||||
|
||||
/*
|
||||
* set the thread's priority, returning the old.
|
||||
* if the new priority is lower than the old, we reschedule.
|
||||
*/
|
||||
int lwpSetPriority(new)
|
||||
int new;
|
||||
int
|
||||
lwpSetPriority(new)
|
||||
int new;
|
||||
{
|
||||
int old = LwpCurrent->pri;
|
||||
int old = LwpCurrent->pri;
|
||||
|
||||
if (LWP_MAX_PRIO <= new)
|
||||
new = LWP_MAX_PRIO-1;
|
||||
if (LwpMaxpri < new)
|
||||
LwpMaxpri = new;
|
||||
LwpCurrent->pri = new;
|
||||
lwpStatus(LwpCurrent, "resetting priority (%d -> %d)", old, new);
|
||||
if (new < old)
|
||||
lwpYield();
|
||||
return (old);
|
||||
if (LWP_MAX_PRIO <= new)
|
||||
new = LWP_MAX_PRIO - 1;
|
||||
if (LwpMaxpri < new)
|
||||
LwpMaxpri = new;
|
||||
LwpCurrent->pri = new;
|
||||
lwpStatus(LwpCurrent, "resetting priority (%d -> %d)", old, new);
|
||||
if (new < old)
|
||||
lwpYield();
|
||||
return (old);
|
||||
}
|
||||
|
||||
/*
|
||||
* initialise the coroutine structures
|
||||
*/
|
||||
struct lwpProc *lwpInitSystem(pri, ctxptr, flags)
|
||||
int pri;
|
||||
char **ctxptr;
|
||||
int flags;
|
||||
struct lwpProc *
|
||||
lwpInitSystem(pri, ctxptr, flags)
|
||||
int pri;
|
||||
char **ctxptr;
|
||||
int flags;
|
||||
{
|
||||
extern struct lwpQueue LwpSchedQ[];
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
struct lwpQueue *q;
|
||||
int i, *stack;
|
||||
struct lwpProc *sel;
|
||||
extern struct lwpQueue LwpSchedQ[];
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
struct lwpQueue *q;
|
||||
int i, *stack;
|
||||
struct lwpProc *sel;
|
||||
|
||||
LwpContextPtr = ctxptr;
|
||||
if (pri < 1)
|
||||
pri = 1;
|
||||
/* *LwpContextPtr = 0; */
|
||||
if (!(LwpCurrent = (struct lwpProc *)calloc (1, sizeof(struct lwpProc))))
|
||||
return (0);
|
||||
if (!(stack = (int *)malloc(64)))
|
||||
return (0);
|
||||
if (LWP_MAX_PRIO <= pri)
|
||||
pri = LWP_MAX_PRIO-1;
|
||||
if (LwpMaxpri < pri)
|
||||
LwpMaxpri = pri;
|
||||
LwpCurrent->next = 0;
|
||||
LwpCurrent->sbtm = stack; /* dummy stack for "main" */
|
||||
LwpCurrent->pri = pri;
|
||||
LwpCurrent->dead = 0;
|
||||
LwpCurrent->flags = flags;
|
||||
LwpCurrent->name = "Main";
|
||||
for (i=LWP_MAX_PRIO, q=LwpSchedQ; i--; q++)
|
||||
q->head = q->tail = 0;
|
||||
LwpDeadQ.head = LwpDeadQ.tail = 0;
|
||||
/* must be lower in priority than us for this to work right */
|
||||
sel = lwpCreate(0, lwpSelect, 16384, flags, "EventHandler",
|
||||
"Select (main loop) Event Handler", 0, 0, 0);
|
||||
lwpInitSelect(sel);
|
||||
return (LwpCurrent);
|
||||
LwpContextPtr = ctxptr;
|
||||
if (pri < 1)
|
||||
pri = 1;
|
||||
/* *LwpContextPtr = 0; */
|
||||
if (!
|
||||
(LwpCurrent = (struct lwpProc *)calloc(1, sizeof(struct lwpProc))))
|
||||
return (0);
|
||||
if (!(stack = (int *)malloc(64)))
|
||||
return (0);
|
||||
if (LWP_MAX_PRIO <= pri)
|
||||
pri = LWP_MAX_PRIO - 1;
|
||||
if (LwpMaxpri < pri)
|
||||
LwpMaxpri = pri;
|
||||
LwpCurrent->next = 0;
|
||||
LwpCurrent->sbtm = stack; /* dummy stack for "main" */
|
||||
LwpCurrent->pri = pri;
|
||||
LwpCurrent->dead = 0;
|
||||
LwpCurrent->flags = flags;
|
||||
LwpCurrent->name = "Main";
|
||||
for (i = LWP_MAX_PRIO, q = LwpSchedQ; i--; q++)
|
||||
q->head = q->tail = 0;
|
||||
LwpDeadQ.head = LwpDeadQ.tail = 0;
|
||||
/* must be lower in priority than us for this to work right */
|
||||
sel = lwpCreate(0, lwpSelect, 16384, flags, "EventHandler",
|
||||
"Select (main loop) Event Handler", 0, 0, 0);
|
||||
lwpInitSelect(sel);
|
||||
return (LwpCurrent);
|
||||
}
|
||||
|
||||
/* lwpStackCheckInit
|
||||
|
|
@ -507,18 +516,19 @@ struct lwpProc *lwpInitSystem(pri, ctxptr, flags)
|
|||
* check mark. Thus, we can get some indication of how much stack was
|
||||
* used.
|
||||
*/
|
||||
static void lwpStackCheckInit(newp)
|
||||
struct lwpProc *newp;
|
||||
static void
|
||||
lwpStackCheckInit(newp)
|
||||
struct lwpProc *newp;
|
||||
{
|
||||
register int i;
|
||||
register long *lp;
|
||||
register int i;
|
||||
register long *lp;
|
||||
|
||||
int lim = newp->size/sizeof(long);
|
||||
if (!newp || !newp->sbtm)
|
||||
return;
|
||||
for (lp=newp->sbtm,i=0; i < lim; i++,lp++) {
|
||||
*lp = LWP_CHECKMARK;
|
||||
}
|
||||
int lim = newp->size / sizeof(long);
|
||||
if (!newp || !newp->sbtm)
|
||||
return;
|
||||
for (lp = newp->sbtm, i = 0; i < lim; i++, lp++) {
|
||||
*lp = LWP_CHECKMARK;
|
||||
}
|
||||
}
|
||||
|
||||
/* lwpStackCheck
|
||||
|
|
@ -531,95 +541,99 @@ static void lwpStackCheckInit(newp)
|
|||
* the thread, well, could be done. Should more like take
|
||||
* down the entire process.
|
||||
*/
|
||||
static int lwpStackCheck(newp)
|
||||
struct lwpProc *newp;
|
||||
static int
|
||||
lwpStackCheck(newp)
|
||||
struct lwpProc *newp;
|
||||
{
|
||||
register int end, amt;
|
||||
register unsigned int i;
|
||||
register long *lp;
|
||||
register int growsDown;
|
||||
int marker;
|
||||
register int end, amt;
|
||||
register unsigned int i;
|
||||
register long *lp;
|
||||
register int growsDown;
|
||||
int marker;
|
||||
|
||||
if (!newp || !newp->himark || !newp->lowmark)
|
||||
return(1);
|
||||
growsDown = growsdown(&marker);
|
||||
for (lp=newp->himark,i=0; i < LWP_REDZONE/sizeof(long); i++,lp++) {
|
||||
if (*lp == LWP_CHECKMARK)
|
||||
continue;
|
||||
/* Stack overflow. */
|
||||
if (growsDown) {
|
||||
end = i;
|
||||
while (i < LWP_REDZONE/sizeof(long)) {
|
||||
if (*lp++ != LWP_CHECKMARK)
|
||||
end = i;
|
||||
i++;
|
||||
}
|
||||
amt = (end+1) * sizeof(long);
|
||||
} else {
|
||||
amt = (i+1) * sizeof(long);
|
||||
}
|
||||
lwpStatus(newp, "Thread stack overflowed %d bytes (of %u)",
|
||||
amt, newp->size - 2*LWP_REDZONE - sizeof(stkalign_t));
|
||||
return(0);
|
||||
if (!newp || !newp->himark || !newp->lowmark)
|
||||
return (1);
|
||||
growsDown = growsdown(&marker);
|
||||
for (lp = newp->himark, i = 0; i < LWP_REDZONE / sizeof(long);
|
||||
i++, lp++) {
|
||||
if (*lp == LWP_CHECKMARK)
|
||||
continue;
|
||||
/* Stack overflow. */
|
||||
if (growsDown) {
|
||||
end = i;
|
||||
while (i < LWP_REDZONE / sizeof(long)) {
|
||||
if (*lp++ != LWP_CHECKMARK)
|
||||
end = i;
|
||||
i++;
|
||||
}
|
||||
amt = (end + 1) * sizeof(long);
|
||||
} else {
|
||||
amt = (i + 1) * sizeof(long);
|
||||
}
|
||||
for (lp=newp->lowmark,i=0; i < LWP_REDZONE/sizeof(long); i++,lp++) {
|
||||
if (*lp == LWP_CHECKMARK)
|
||||
continue;
|
||||
/* Stack underflow. */
|
||||
if (growsDown) {
|
||||
end = i;
|
||||
while (i < LWP_REDZONE/sizeof(long)) {
|
||||
if (*lp++ != LWP_CHECKMARK)
|
||||
end = i;
|
||||
i++;
|
||||
}
|
||||
amt = (end+1) * sizeof(long);
|
||||
} else {
|
||||
amt = (LWP_REDZONE - i+1) * sizeof(long);
|
||||
}
|
||||
lwpStatus(newp, "Thread stack underflow %d bytes (of %u)",
|
||||
amt, newp->size - 2*LWP_REDZONE - sizeof(stkalign_t));
|
||||
return(0);
|
||||
lwpStatus(newp, "Thread stack overflowed %d bytes (of %u)",
|
||||
amt, newp->size - 2 * LWP_REDZONE - sizeof(stkalign_t));
|
||||
return (0);
|
||||
}
|
||||
for (lp = newp->lowmark, i = 0; i < LWP_REDZONE / sizeof(long);
|
||||
i++, lp++) {
|
||||
if (*lp == LWP_CHECKMARK)
|
||||
continue;
|
||||
/* Stack underflow. */
|
||||
if (growsDown) {
|
||||
end = i;
|
||||
while (i < LWP_REDZONE / sizeof(long)) {
|
||||
if (*lp++ != LWP_CHECKMARK)
|
||||
end = i;
|
||||
i++;
|
||||
}
|
||||
amt = (end + 1) * sizeof(long);
|
||||
} else {
|
||||
amt = (LWP_REDZONE - i + 1) * sizeof(long);
|
||||
}
|
||||
return(1);
|
||||
lwpStatus(newp, "Thread stack underflow %d bytes (of %u)",
|
||||
amt, newp->size - 2 * LWP_REDZONE - sizeof(stkalign_t));
|
||||
return (0);
|
||||
}
|
||||
return (1);
|
||||
}
|
||||
|
||||
/* lwpStackCheckUsed
|
||||
*
|
||||
* Figure out how much stack was used by this thread.
|
||||
*/
|
||||
static void lwpStackCheckUsed(newp)
|
||||
struct lwpProc *newp;
|
||||
static void
|
||||
lwpStackCheckUsed(newp)
|
||||
struct lwpProc *newp;
|
||||
{
|
||||
register int i;
|
||||
register long *lp;
|
||||
register int lim;
|
||||
int marker;
|
||||
register int i;
|
||||
register long *lp;
|
||||
register int lim;
|
||||
int marker;
|
||||
|
||||
if (!newp || !newp->sbtm)
|
||||
return;
|
||||
lim = newp->size/sizeof(long);
|
||||
if (growsdown(&marker)) {
|
||||
/* Start at the bottom and find first non checkmark. */
|
||||
for (lp=newp->sbtm,i=0; i < lim; i++,lp++) {
|
||||
if (*lp != LWP_CHECKMARK) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* Start at the top and find first non checkmark. */
|
||||
lp = newp->sbtm;
|
||||
lp += newp->size/sizeof(long);
|
||||
lp--;
|
||||
for (i=0; i < lim; i++, lp--) {
|
||||
if (*lp != LWP_CHECKMARK) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!newp || !newp->sbtm)
|
||||
return;
|
||||
lim = newp->size / sizeof(long);
|
||||
if (growsdown(&marker)) {
|
||||
/* Start at the bottom and find first non checkmark. */
|
||||
for (lp = newp->sbtm, i = 0; i < lim; i++, lp++) {
|
||||
if (*lp != LWP_CHECKMARK) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
lwpStatus(newp, "stack use: %u bytes (of %u total)",
|
||||
(i * sizeof(long)) - LWP_REDZONE,
|
||||
newp->size - 2*LWP_REDZONE - sizeof(stkalign_t));
|
||||
} else {
|
||||
/* Start at the top and find first non checkmark. */
|
||||
lp = newp->sbtm;
|
||||
lp += newp->size / sizeof(long);
|
||||
lp--;
|
||||
for (i = 0; i < lim; i++, lp--) {
|
||||
if (*lp != LWP_CHECKMARK) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
lwpStatus(newp, "stack use: %u bytes (of %u total)",
|
||||
(i * sizeof(long)) - LWP_REDZONE,
|
||||
newp->size - 2 * LWP_REDZONE - sizeof(stkalign_t));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -30,13 +30,13 @@
|
|||
#define LCOUNT -1
|
||||
|
||||
#ifdef hpux
|
||||
int lwpSave _PROTO((jmp_buf));
|
||||
void lwpRestore _PROTO((jmp_buf));
|
||||
int lwpSave _PROTO((jmp_buf));
|
||||
void lwpRestore _PROTO((jmp_buf));
|
||||
#endif
|
||||
|
||||
#if defined(MIPS) || defined(AIX32) || defined(ALPHA) || defined(__vax)
|
||||
int lwpSave _PROTO((jmp_buf));
|
||||
void lwpRestore _PROTO((jmp_buf));
|
||||
int lwpSave _PROTO((jmp_buf));
|
||||
void lwpRestore _PROTO((jmp_buf));
|
||||
#elif defined(SUN4)
|
||||
#define lwpSave(x) _setjmp(x)
|
||||
#define lwpRestore(x) _longjmp(x, 1)
|
||||
|
|
@ -78,28 +78,27 @@ typedef struct {
|
|||
#endif
|
||||
|
||||
/* internal routines */
|
||||
void lwpAddTail _PROTO((struct lwpQueue *, struct lwpProc *));
|
||||
struct lwpProc *lwpGetFirst _PROTO((struct lwpQueue *));
|
||||
void lwpReschedule _PROTO((void));
|
||||
void lwpReady _PROTO((struct lwpProc *));
|
||||
void lwpOnalarm _PROTO((void));
|
||||
void lwpAddTail _PROTO((struct lwpQueue *, struct lwpProc *));
|
||||
struct lwpProc *lwpGetFirst _PROTO((struct lwpQueue *));
|
||||
void lwpReschedule _PROTO((void));
|
||||
void lwpReady _PROTO((struct lwpProc *));
|
||||
void lwpOnalarm _PROTO((void));
|
||||
|
||||
#ifdef UCONTEXT
|
||||
void lwpInitContext _PROTO((struct lwpProc *, stack_t *));
|
||||
#else /* GETCONTEXT */
|
||||
void lwpInitContext _PROTO((struct lwpProc *, stack_t *));
|
||||
#else /* GETCONTEXT */
|
||||
#ifdef hpc
|
||||
void lwpInitContext _PROTO((struct lwpProc *, void *));
|
||||
void lwpInitContext _PROTO((struct lwpProc *, void *));
|
||||
#else
|
||||
#ifdef hpux
|
||||
void lwpInitContext _PROTO((volatile struct lwpProc *volatile, void *));
|
||||
void lwpInitContext _PROTO((volatile struct lwpProc * volatile, void *));
|
||||
#else
|
||||
void lwpInitContext _PROTO((struct lwpProc *, void *));
|
||||
void lwpInitContext _PROTO((struct lwpProc *, void *));
|
||||
#endif /* hpux */
|
||||
#endif /* hpc */
|
||||
#endif /* GETCONTEXT */
|
||||
void lwpEntryPoint _PROTO((void));
|
||||
void lwpInitSelect _PROTO((struct lwpProc *self));
|
||||
void lwpDestroy _PROTO((struct lwpProc *proc));
|
||||
|
||||
#endif /* _LWP_H */
|
||||
void lwpEntryPoint _PROTO((void));
|
||||
void lwpInitSelect _PROTO((struct lwpProc * self));
|
||||
void lwpDestroy _PROTO((struct lwpProc * proc));
|
||||
|
||||
#endif /* _LWP_H */
|
||||
|
|
|
|||
|
|
@ -18,98 +18,101 @@
|
|||
#include "lwp.h"
|
||||
|
||||
struct context {
|
||||
struct lwpProc *us;
|
||||
struct sockaddr_in addr;
|
||||
int fd;
|
||||
struct lwpProc *us;
|
||||
struct sockaddr_in addr;
|
||||
int fd;
|
||||
};
|
||||
|
||||
/*ARGSUSED*/
|
||||
int readConn(argc, argv, ud)
|
||||
int argc;
|
||||
char **argv;
|
||||
void *ud;
|
||||
int
|
||||
readConn(argc, argv, ud)
|
||||
int argc;
|
||||
char **argv;
|
||||
void *ud;
|
||||
{
|
||||
struct context *ctx = (struct context *) ud;
|
||||
char buf[1024];
|
||||
int n;
|
||||
struct context *ctx = (struct context *)ud;
|
||||
char buf[1024];
|
||||
int n;
|
||||
|
||||
while (1) {
|
||||
printf("sleeping\n");
|
||||
lwpSleepFd(ctx->fd, LWP_FD_READ);
|
||||
printf("waiting to read\n");
|
||||
if ((n = read(ctx->fd, buf, sizeof(buf))) <= 0)
|
||||
break;
|
||||
printf("got %d char\n", n);
|
||||
lwpSleepFd(ctx->fd, LWP_FD_WRITE);
|
||||
printf("waiting to write\n");
|
||||
if (write(ctx->fd, buf, n) < 0)
|
||||
break;
|
||||
printf("wrote %d char\n", n);
|
||||
}
|
||||
printf("process/fd %d exiting\n", ctx->fd);
|
||||
close(ctx->fd);
|
||||
lwpExit();
|
||||
/*NOTREACHED*/
|
||||
while (1) {
|
||||
printf("sleeping\n");
|
||||
lwpSleepFd(ctx->fd, LWP_FD_READ);
|
||||
printf("waiting to read\n");
|
||||
if ((n = read(ctx->fd, buf, sizeof(buf))) <= 0)
|
||||
break;
|
||||
printf("got %d char\n", n);
|
||||
lwpSleepFd(ctx->fd, LWP_FD_WRITE);
|
||||
printf("waiting to write\n");
|
||||
if (write(ctx->fd, buf, n) < 0)
|
||||
break;
|
||||
printf("wrote %d char\n", n);
|
||||
}
|
||||
printf("process/fd %d exiting\n", ctx->fd);
|
||||
close(ctx->fd);
|
||||
lwpExit();
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
int acceptConn(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
int
|
||||
acceptConn(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
struct sockaddr_in sin;
|
||||
int s;
|
||||
int ns;
|
||||
int len;
|
||||
int maxfd;
|
||||
struct context *ctx;
|
||||
struct sockaddr_in sin;
|
||||
int s;
|
||||
int ns;
|
||||
int len;
|
||||
int maxfd;
|
||||
struct context *ctx;
|
||||
|
||||
if (argc != 2) {
|
||||
fprintf(stderr, "Usage: %s port\n", *argv);
|
||||
exit(-1);
|
||||
if (argc != 2) {
|
||||
fprintf(stderr, "Usage: %s port\n", *argv);
|
||||
exit(-1);
|
||||
}
|
||||
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
|
||||
perror("inet socket");
|
||||
exit(-1);
|
||||
}
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(atoi(argv[1]));
|
||||
sin.sin_addr.s_addr = 0;
|
||||
if (bind(s, &sin, sizeof(sin)) < 0) {
|
||||
perror("inet socket bind");
|
||||
exit(-1);
|
||||
}
|
||||
if (listen(s, LISTENMAXCONN) < 0) {
|
||||
perror("inet socket listen");
|
||||
exit(-1);
|
||||
}
|
||||
maxfd = getdtablesize() - 1;
|
||||
while (1) {
|
||||
lwpSleepFd(s, LWP_FD_READ);
|
||||
len = sizeof(sin);
|
||||
ns = accept(s, &sin, &len);
|
||||
if (ns < 0) {
|
||||
perror("accept");
|
||||
exit(-1);
|
||||
}
|
||||
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
|
||||
perror("inet socket");
|
||||
exit(-1);
|
||||
if (ns == maxfd) {
|
||||
fprintf(stderr, "no more connections");
|
||||
close(ns);
|
||||
}
|
||||
sin.sin_family = AF_INET;
|
||||
sin.sin_port = htons(atoi(argv[1]));
|
||||
sin.sin_addr.s_addr = 0;
|
||||
if (bind(s, &sin, sizeof(sin)) < 0) {
|
||||
perror("inet socket bind");
|
||||
exit(-1);
|
||||
}
|
||||
if (listen(s, LISTENMAXCONN) < 0) {
|
||||
perror("inet socket listen");
|
||||
exit(-1);
|
||||
}
|
||||
maxfd = getdtablesize() - 1;
|
||||
while (1) {
|
||||
lwpSleepFd(s, LWP_FD_READ);
|
||||
len = sizeof(sin);
|
||||
ns = accept(s, &sin, &len);
|
||||
if (ns < 0) {
|
||||
perror("accept");
|
||||
exit(-1);
|
||||
}
|
||||
if (ns == maxfd) {
|
||||
fprintf(stderr, "no more connections");
|
||||
close(ns);
|
||||
}
|
||||
printf("got connection from %s\n", inet_ntoa(sin.sin_addr));
|
||||
ctx = (struct context *) malloc(sizeof(*ctx));
|
||||
ctx->addr = sin;
|
||||
ctx->fd = ns;
|
||||
ctx->us = lwpCreate(SP_READER, readConn, 8192, 0, 0, ctx);
|
||||
}
|
||||
/*NOTREACHED*/
|
||||
printf("got connection from %s\n", inet_ntoa(sin.sin_addr));
|
||||
ctx = (struct context *)malloc(sizeof(*ctx));
|
||||
ctx->addr = sin;
|
||||
ctx->fd = ns;
|
||||
ctx->us = lwpCreate(SP_READER, readConn, 8192, 0, 0, ctx);
|
||||
}
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
|
||||
int main(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
int
|
||||
main(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
lwpInitSystem(1);
|
||||
lwpCreate(SP_ACCEPT, acceptConn, 8192, argc, argv, 0);
|
||||
lwpReschedule();
|
||||
/*NOTREACHED*/
|
||||
lwpInitSystem(1);
|
||||
lwpCreate(SP_ACCEPT, acceptConn, 8192, argc, argv, 0);
|
||||
lwpReschedule();
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,30 +36,30 @@
|
|||
|
||||
/* process control block. do *not* change the position of context */
|
||||
struct lwpProc {
|
||||
jmp_buf context; /* processor context area */
|
||||
void *sbtm; /* bottom of stack attached to it */
|
||||
int size; /* size of stack */
|
||||
void (*entry)(); /* entry point */
|
||||
int dead; /* whether the process can be rescheduled */
|
||||
int pri; /* which scheduling queue we're on */
|
||||
long runtime; /* time at which process is restarted */
|
||||
int fd; /* fd we're blocking on */
|
||||
int argc; /* initial arguments */
|
||||
char **argv;
|
||||
void *ud; /* user data */
|
||||
struct lwpProc *next;
|
||||
jmp_buf context; /* processor context area */
|
||||
void *sbtm; /* bottom of stack attached to it */
|
||||
int size; /* size of stack */
|
||||
void (*entry) (); /* entry point */
|
||||
int dead; /* whether the process can be rescheduled */
|
||||
int pri; /* which scheduling queue we're on */
|
||||
long runtime; /* time at which process is restarted */
|
||||
int fd; /* fd we're blocking on */
|
||||
int argc; /* initial arguments */
|
||||
char **argv;
|
||||
void *ud; /* user data */
|
||||
struct lwpProc *next;
|
||||
};
|
||||
|
||||
/* queue */
|
||||
struct lwpQueue {
|
||||
struct lwpProc *head;
|
||||
struct lwpProc *tail;
|
||||
struct lwpProc *head;
|
||||
struct lwpProc *tail;
|
||||
};
|
||||
|
||||
/* semaphore */
|
||||
struct lwpSem {
|
||||
int count;
|
||||
struct lwpQueue q;
|
||||
int count;
|
||||
struct lwpQueue q;
|
||||
};
|
||||
|
||||
#define LWP_FD_READ 0x1
|
||||
|
|
@ -67,24 +67,25 @@ struct lwpSem {
|
|||
|
||||
#define LWP_MAX_PRIO 8
|
||||
|
||||
struct lwpProc *lwpInitSystem _PROTO((int));
|
||||
struct lwpProc *lwpCreate _PROTO((int, void (*)(), int, int, char **, void *));
|
||||
void lwpExit _PROTO((void));
|
||||
void lwpTerminate _PROTO((struct lwpProc *));
|
||||
void lwpYield _PROTO((void));
|
||||
void lwpSleepFd _PROTO((int fd, int flags));
|
||||
void lwpSleepUntil _PROTO((long until));
|
||||
void lwpWakeupFd _PROTO((struct lwpProc *));
|
||||
void *lwpGetUD _PROTO((struct lwpProc *));
|
||||
void lwpSetUD _PROTO((struct lwpProc *, char *));
|
||||
int lwpSetPriority _PROTO((int));
|
||||
void lwpReschedule _PROTO(());
|
||||
struct lwpProc *lwpInitSystem _PROTO((int));
|
||||
struct lwpProc *lwpCreate
|
||||
_PROTO((int, void (*)(), int, int, char **, void *));
|
||||
void lwpExit _PROTO((void));
|
||||
void lwpTerminate _PROTO((struct lwpProc *));
|
||||
void lwpYield _PROTO((void));
|
||||
void lwpSleepFd _PROTO((int fd, int flags));
|
||||
void lwpSleepUntil _PROTO((long until));
|
||||
void lwpWakeupFd _PROTO((struct lwpProc *));
|
||||
void *lwpGetUD _PROTO((struct lwpProc *));
|
||||
void lwpSetUD _PROTO((struct lwpProc *, char *));
|
||||
int lwpSetPriority _PROTO((int));
|
||||
void lwpReschedule _PROTO(());
|
||||
|
||||
struct lwpSem *lwpCreateSem _PROTO((int));
|
||||
void lwpSignal _PROTO((struct lwpSem *));
|
||||
void lwpWait _PROTO((struct lwpSem *));
|
||||
void lwpSelect _PROTO((int argc, char **argv));
|
||||
struct lwpSem *lwpCreateSem _PROTO((int));
|
||||
void lwpSignal _PROTO((struct lwpSem *));
|
||||
void lwpWait _PROTO((struct lwpSem *));
|
||||
void lwpSelect _PROTO((int argc, char **argv));
|
||||
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
|
||||
#endif /* _LWP_H */
|
||||
#endif /* _LWP_H */
|
||||
|
|
|
|||
|
|
@ -26,26 +26,28 @@
|
|||
|
||||
#if defined(_EMPTH_LWP)
|
||||
|
||||
struct lwpProc *lwpGetFirst(q)
|
||||
struct lwpQueue *q;
|
||||
struct lwpProc *
|
||||
lwpGetFirst(q)
|
||||
struct lwpQueue *q;
|
||||
{
|
||||
struct lwpProc *head;
|
||||
struct lwpProc *head;
|
||||
|
||||
if ((head = q->head) && !(q->head = head->next))
|
||||
q->tail = 0;
|
||||
return (head);
|
||||
if ((head = q->head) && !(q->head = head->next))
|
||||
q->tail = 0;
|
||||
return (head);
|
||||
}
|
||||
|
||||
void lwpAddTail(q, p)
|
||||
register struct lwpQueue *q;
|
||||
register struct lwpProc *p;
|
||||
void
|
||||
lwpAddTail(q, p)
|
||||
register struct lwpQueue *q;
|
||||
register struct lwpProc *p;
|
||||
{
|
||||
if (!q->tail)
|
||||
q->head = p;
|
||||
else
|
||||
q->tail->next = p;
|
||||
q->tail = p;
|
||||
p->next = 0;
|
||||
if (!q->tail)
|
||||
q->head = p;
|
||||
else
|
||||
q->tail->next = p;
|
||||
q->tail = p;
|
||||
p->next = 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -50,201 +50,204 @@
|
|||
#if defined(_EMPTH_LWP)
|
||||
|
||||
struct lwpSelect {
|
||||
int maxfd;
|
||||
int nfds;
|
||||
int nfile;
|
||||
fd_set readmask;
|
||||
fd_set writemask;
|
||||
struct lwpProc **wait;
|
||||
struct lwpQueue delayq;
|
||||
struct lwpProc *proc;
|
||||
int maxfd;
|
||||
int nfds;
|
||||
int nfile;
|
||||
fd_set readmask;
|
||||
fd_set writemask;
|
||||
struct lwpProc **wait;
|
||||
struct lwpQueue delayq;
|
||||
struct lwpProc *proc;
|
||||
};
|
||||
|
||||
struct lwpSelect LwpSelect;
|
||||
|
||||
void lwpInitSelect(proc)
|
||||
struct lwpProc *proc;
|
||||
void
|
||||
lwpInitSelect(proc)
|
||||
struct lwpProc *proc;
|
||||
{
|
||||
LwpSelect.maxfd = 0;
|
||||
LwpSelect.nfds = 0;
|
||||
LwpSelect.maxfd = 0;
|
||||
LwpSelect.nfds = 0;
|
||||
#ifdef hpux
|
||||
LwpSelect.nfile = _NFILE;
|
||||
LwpSelect.nfile = _NFILE;
|
||||
#else
|
||||
LwpSelect.nfile = getdtablesize();
|
||||
LwpSelect.nfile = getdtablesize();
|
||||
#endif
|
||||
FD_ZERO(&LwpSelect.readmask);
|
||||
FD_ZERO(&LwpSelect.writemask);
|
||||
LwpSelect.wait = (struct lwpProc **)
|
||||
calloc(LwpSelect.nfile, sizeof(char *));
|
||||
LwpSelect.delayq.head = 0;
|
||||
LwpSelect.delayq.tail = 0;
|
||||
LwpSelect.proc = proc;
|
||||
FD_ZERO(&LwpSelect.readmask);
|
||||
FD_ZERO(&LwpSelect.writemask);
|
||||
LwpSelect.wait = (struct lwpProc **)
|
||||
calloc(LwpSelect.nfile, sizeof(char *));
|
||||
LwpSelect.delayq.head = 0;
|
||||
LwpSelect.delayq.tail = 0;
|
||||
LwpSelect.proc = proc;
|
||||
}
|
||||
|
||||
void lwpSleepFd(fd, mask)
|
||||
int fd;
|
||||
int mask;
|
||||
void
|
||||
lwpSleepFd(fd, mask)
|
||||
int fd;
|
||||
int mask;
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
|
||||
lwpStatus(LwpCurrent, "sleeping on fd %d", fd);
|
||||
lwpStatus(LwpCurrent, "sleeping on fd %d", fd);
|
||||
|
||||
if (LwpSelect.wait[fd] != 0) {
|
||||
lwpStatus(LwpCurrent,
|
||||
"multiple sleeps attempted on file descriptor %d", fd);
|
||||
return;
|
||||
}
|
||||
if (mask & LWP_FD_READ)
|
||||
FD_SET(fd, &LwpSelect.readmask);
|
||||
if (mask & LWP_FD_WRITE)
|
||||
FD_SET(fd, &LwpSelect.writemask);
|
||||
if (LwpSelect.wait[fd] != 0) {
|
||||
lwpStatus(LwpCurrent,
|
||||
"multiple sleeps attempted on file descriptor %d", fd);
|
||||
return;
|
||||
}
|
||||
if (mask & LWP_FD_READ)
|
||||
FD_SET(fd, &LwpSelect.readmask);
|
||||
if (mask & LWP_FD_WRITE)
|
||||
FD_SET(fd, &LwpSelect.writemask);
|
||||
|
||||
LwpSelect.nfds++;
|
||||
LwpSelect.nfds++;
|
||||
|
||||
if (LwpSelect.maxfd == 0 && LwpSelect.delayq.head == 0) {
|
||||
/* select process is sleeping until first waiter arrives */
|
||||
lwpStatus(LwpCurrent, "going to resched fd %d", fd);
|
||||
lwpReady(LwpSelect.proc);
|
||||
}
|
||||
lwpStatus(LwpCurrent, "going to wait on fd %d", fd);
|
||||
if (fd > LwpSelect.maxfd)
|
||||
LwpSelect.maxfd = fd;
|
||||
LwpSelect.wait[fd] = LwpCurrent;
|
||||
LwpCurrent->fd = fd;
|
||||
lwpReschedule();
|
||||
if (LwpSelect.maxfd == 0 && LwpSelect.delayq.head == 0) {
|
||||
/* select process is sleeping until first waiter arrives */
|
||||
lwpStatus(LwpCurrent, "going to resched fd %d", fd);
|
||||
lwpReady(LwpSelect.proc);
|
||||
}
|
||||
lwpStatus(LwpCurrent, "going to wait on fd %d", fd);
|
||||
if (fd > LwpSelect.maxfd)
|
||||
LwpSelect.maxfd = fd;
|
||||
LwpSelect.wait[fd] = LwpCurrent;
|
||||
LwpCurrent->fd = fd;
|
||||
lwpReschedule();
|
||||
}
|
||||
|
||||
void lwpWakeupFd(proc)
|
||||
struct lwpProc *proc;
|
||||
void
|
||||
lwpWakeupFd(proc)
|
||||
struct lwpProc *proc;
|
||||
{
|
||||
if (proc->fd < 0)
|
||||
return;
|
||||
if (proc->fd < 0)
|
||||
return;
|
||||
|
||||
lwpStatus(proc, "awakening; was sleeping on fd %d", proc->fd);
|
||||
FD_CLR(proc->fd, &LwpSelect.readmask);
|
||||
FD_CLR(proc->fd, &LwpSelect.writemask);
|
||||
LwpSelect.nfds--;
|
||||
LwpSelect.wait[proc->fd] = 0;
|
||||
proc->fd = -1;
|
||||
lwpReady(proc);
|
||||
lwpStatus(proc, "awakening; was sleeping on fd %d", proc->fd);
|
||||
FD_CLR(proc->fd, &LwpSelect.readmask);
|
||||
FD_CLR(proc->fd, &LwpSelect.writemask);
|
||||
LwpSelect.nfds--;
|
||||
LwpSelect.wait[proc->fd] = 0;
|
||||
proc->fd = -1;
|
||||
lwpReady(proc);
|
||||
}
|
||||
|
||||
void lwpSleepUntil(until)
|
||||
long until;
|
||||
void
|
||||
lwpSleepUntil(until)
|
||||
long until;
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
|
||||
lwpStatus(LwpCurrent, "sleeping for %d sec", until - time(0));
|
||||
LwpCurrent->runtime = until;
|
||||
if (LwpSelect.maxfd == 0 && LwpSelect.delayq.head == 0) {
|
||||
/* select process is sleeping until first waiter arrives */
|
||||
lwpReady(LwpSelect.proc);
|
||||
}
|
||||
lwpAddTail(&LwpSelect.delayq, LwpCurrent);
|
||||
lwpReschedule();
|
||||
lwpStatus(LwpCurrent, "sleeping for %d sec", until - time(0));
|
||||
LwpCurrent->runtime = until;
|
||||
if (LwpSelect.maxfd == 0 && LwpSelect.delayq.head == 0) {
|
||||
/* select process is sleeping until first waiter arrives */
|
||||
lwpReady(LwpSelect.proc);
|
||||
}
|
||||
lwpAddTail(&LwpSelect.delayq, LwpCurrent);
|
||||
lwpReschedule();
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
void
|
||||
lwpSelect(argc, argv)
|
||||
int argc;
|
||||
char **argv;
|
||||
int argc;
|
||||
char **argv;
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
struct lwpProc *us = LwpCurrent;
|
||||
fd_set readmask;
|
||||
fd_set writemask;
|
||||
int n;
|
||||
int fd;
|
||||
time_t now;
|
||||
time_t delta;
|
||||
struct lwpProc *proc;
|
||||
struct timeval tv;
|
||||
struct lwpQueue save;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
struct lwpProc *us = LwpCurrent;
|
||||
fd_set readmask;
|
||||
fd_set writemask;
|
||||
int n;
|
||||
int fd;
|
||||
time_t now;
|
||||
time_t delta;
|
||||
struct lwpProc *proc;
|
||||
struct timeval tv;
|
||||
struct lwpQueue save;
|
||||
|
||||
lwpStatus(us, "starting select loop");
|
||||
FD_ZERO(&readmask);
|
||||
FD_ZERO(&writemask);
|
||||
lwpStatus(us, "starting select loop");
|
||||
FD_ZERO(&readmask);
|
||||
FD_ZERO(&writemask);
|
||||
while (1) {
|
||||
while (1) {
|
||||
while (1) {
|
||||
if (LwpSelect.nfds)
|
||||
break;
|
||||
if (LwpSelect.delayq.head)
|
||||
break;
|
||||
/* wait for someone to lwpSleepFd or lwpSleepUntil */
|
||||
LwpSelect.maxfd = 0;
|
||||
lwpStatus(us, "no fds or sleepers, waiting");
|
||||
lwpReschedule();
|
||||
}
|
||||
tv.tv_sec = 1000000;
|
||||
tv.tv_usec = 0;
|
||||
if (LwpSelect.delayq.head) {
|
||||
time(&now);
|
||||
proc = LwpSelect.delayq.head;
|
||||
for ( ; proc != 0; proc = proc->next) {
|
||||
delta = proc->runtime - now;
|
||||
if (delta < tv.tv_sec)
|
||||
tv.tv_sec = delta;
|
||||
}
|
||||
if (tv.tv_sec < 0)
|
||||
tv.tv_sec = 0;
|
||||
}
|
||||
lwpStatus(us, "selecting; sleep %ld secs", (long)delta);
|
||||
|
||||
bcopy((s_char *)&LwpSelect.readmask, (s_char *)&readmask, sizeof(fd_set));
|
||||
bcopy((s_char *)&LwpSelect.writemask, (s_char *)&writemask, sizeof(fd_set));
|
||||
n = select(LwpSelect.maxfd + 1, &readmask, &writemask,
|
||||
(fd_set *)0, &tv);
|
||||
|
||||
if (n < 0) {
|
||||
if (errno == EINTR) {
|
||||
/* go handle the signal */
|
||||
lwpReady(us);
|
||||
lwpReschedule();
|
||||
continue;
|
||||
}
|
||||
lwpStatus(us,
|
||||
"select failed (bad file descriptor?)");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
if (LwpSelect.delayq.head) {
|
||||
/* sleeping proecss activity */
|
||||
time(&now);
|
||||
save.tail = save.head = 0;
|
||||
while (NULL != (proc = lwpGetFirst(&LwpSelect.delayq))) {
|
||||
if (now >= proc->runtime) {
|
||||
lwpStatus(proc, "sleep done");
|
||||
lwpReady(proc);
|
||||
} else {
|
||||
lwpAddTail(&save, proc);
|
||||
}
|
||||
}
|
||||
LwpSelect.delayq = save;
|
||||
}
|
||||
if (n > 0) {
|
||||
/* file descriptor activity */
|
||||
for(fd = 0; fd <= LwpSelect.maxfd; fd++) {
|
||||
if (LwpSelect.wait[fd] == 0)
|
||||
continue;
|
||||
if (FD_ISSET(fd, &readmask)) {
|
||||
lwpStatus(LwpSelect.wait[fd],
|
||||
"input ready");
|
||||
lwpWakeupFd(LwpSelect.wait[fd]);
|
||||
continue;
|
||||
}
|
||||
if (FD_ISSET(fd, &writemask)) {
|
||||
lwpStatus(LwpSelect.wait[fd],
|
||||
"output ready");
|
||||
lwpWakeupFd(LwpSelect.wait[fd]);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
lwpStatus(us, "fd dispatch completed");
|
||||
lwpReady(LwpCurrent);
|
||||
lwpReschedule();
|
||||
if (LwpSelect.nfds)
|
||||
break;
|
||||
if (LwpSelect.delayq.head)
|
||||
break;
|
||||
/* wait for someone to lwpSleepFd or lwpSleepUntil */
|
||||
LwpSelect.maxfd = 0;
|
||||
lwpStatus(us, "no fds or sleepers, waiting");
|
||||
lwpReschedule();
|
||||
}
|
||||
/*NOTREACHED*/
|
||||
tv.tv_sec = 1000000;
|
||||
tv.tv_usec = 0;
|
||||
if (LwpSelect.delayq.head) {
|
||||
time(&now);
|
||||
proc = LwpSelect.delayq.head;
|
||||
for (; proc != 0; proc = proc->next) {
|
||||
delta = proc->runtime - now;
|
||||
if (delta < tv.tv_sec)
|
||||
tv.tv_sec = delta;
|
||||
}
|
||||
if (tv.tv_sec < 0)
|
||||
tv.tv_sec = 0;
|
||||
}
|
||||
lwpStatus(us, "selecting; sleep %ld secs", (long)delta);
|
||||
|
||||
bcopy((s_char *)&LwpSelect.readmask, (s_char *)&readmask,
|
||||
sizeof(fd_set));
|
||||
bcopy((s_char *)&LwpSelect.writemask, (s_char *)&writemask,
|
||||
sizeof(fd_set));
|
||||
n = select(LwpSelect.maxfd + 1, &readmask, &writemask,
|
||||
(fd_set *) 0, &tv);
|
||||
|
||||
if (n < 0) {
|
||||
if (errno == EINTR) {
|
||||
/* go handle the signal */
|
||||
lwpReady(us);
|
||||
lwpReschedule();
|
||||
continue;
|
||||
}
|
||||
lwpStatus(us, "select failed (bad file descriptor?)");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
if (LwpSelect.delayq.head) {
|
||||
/* sleeping proecss activity */
|
||||
time(&now);
|
||||
save.tail = save.head = 0;
|
||||
while (NULL != (proc = lwpGetFirst(&LwpSelect.delayq))) {
|
||||
if (now >= proc->runtime) {
|
||||
lwpStatus(proc, "sleep done");
|
||||
lwpReady(proc);
|
||||
} else {
|
||||
lwpAddTail(&save, proc);
|
||||
}
|
||||
}
|
||||
LwpSelect.delayq = save;
|
||||
}
|
||||
if (n > 0) {
|
||||
/* file descriptor activity */
|
||||
for (fd = 0; fd <= LwpSelect.maxfd; fd++) {
|
||||
if (LwpSelect.wait[fd] == 0)
|
||||
continue;
|
||||
if (FD_ISSET(fd, &readmask)) {
|
||||
lwpStatus(LwpSelect.wait[fd], "input ready");
|
||||
lwpWakeupFd(LwpSelect.wait[fd]);
|
||||
continue;
|
||||
}
|
||||
if (FD_ISSET(fd, &writemask)) {
|
||||
lwpStatus(LwpSelect.wait[fd], "output ready");
|
||||
lwpWakeupFd(LwpSelect.wait[fd]);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
lwpStatus(us, "fd dispatch completed");
|
||||
lwpReady(LwpCurrent);
|
||||
lwpReschedule();
|
||||
}
|
||||
/*NOTREACHED*/
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -37,54 +37,57 @@ extern char *strdup();
|
|||
/*
|
||||
* create a lwpSemaphore.
|
||||
*/
|
||||
struct lwpSem *lwpCreateSem(name, count)
|
||||
char *name;
|
||||
int count;
|
||||
struct lwpSem *
|
||||
lwpCreateSem(name, count)
|
||||
char *name;
|
||||
int count;
|
||||
{
|
||||
struct lwpSem *new;
|
||||
struct lwpSem *new;
|
||||
|
||||
if (!(new = (struct lwpSem *)malloc(sizeof(struct lwpSem))))
|
||||
return (0);
|
||||
new->name = strdup(name);
|
||||
new->count = count;
|
||||
new->q.head = new->q.tail = 0;
|
||||
return (new);
|
||||
if (!(new = (struct lwpSem *)malloc(sizeof(struct lwpSem))))
|
||||
return (0);
|
||||
new->name = strdup(name);
|
||||
new->count = count;
|
||||
new->q.head = new->q.tail = 0;
|
||||
return (new);
|
||||
}
|
||||
|
||||
/*
|
||||
* signal a lwpSemaphore. We only yield here if
|
||||
* the blocked process has a higher priority than ours'.
|
||||
*/
|
||||
void lwpSignal(s)
|
||||
struct lwpSem *s;
|
||||
void
|
||||
lwpSignal(s)
|
||||
struct lwpSem *s;
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
|
||||
lwpStatus(LwpCurrent, "done with semaphore %s", s->name);
|
||||
if (s->count++ < 0) {
|
||||
struct lwpProc *p = lwpGetFirst(&s->q);
|
||||
lwpStatus(LwpCurrent, "activating first waiter");
|
||||
lwpReady(p);
|
||||
if (LwpCurrent->pri < p->pri) {
|
||||
lwpStatus(p, "priority is higher");
|
||||
lwpYield();
|
||||
}
|
||||
lwpStatus(LwpCurrent, "done with semaphore %s", s->name);
|
||||
if (s->count++ < 0) {
|
||||
struct lwpProc *p = lwpGetFirst(&s->q);
|
||||
lwpStatus(LwpCurrent, "activating first waiter");
|
||||
lwpReady(p);
|
||||
if (LwpCurrent->pri < p->pri) {
|
||||
lwpStatus(p, "priority is higher");
|
||||
lwpYield();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* wait on a lwpSemaphore
|
||||
*/
|
||||
void lwpWait(s)
|
||||
struct lwpSem *s;
|
||||
void
|
||||
lwpWait(s)
|
||||
struct lwpSem *s;
|
||||
{
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
extern struct lwpProc *LwpCurrent;
|
||||
|
||||
lwpStatus(LwpCurrent, "checking semaphore %s", s->name);
|
||||
if (--s->count < 0) {
|
||||
lwpStatus(LwpCurrent, "blocking");
|
||||
lwpAddTail(&s->q, LwpCurrent);
|
||||
lwpReschedule();
|
||||
}
|
||||
lwpStatus(LwpCurrent, "checking semaphore %s", s->name);
|
||||
if (--s->count < 0) {
|
||||
lwpStatus(LwpCurrent, "blocking");
|
||||
lwpAddTail(&s->q, LwpCurrent);
|
||||
lwpReschedule();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -40,30 +40,31 @@
|
|||
|
||||
#if defined(_EMPTH_LWP)
|
||||
|
||||
void lwpStatus(struct lwpProc *proc, char *format, ...)
|
||||
void
|
||||
lwpStatus(struct lwpProc *proc, char *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
static struct timeval startTime;
|
||||
struct timeval tv;
|
||||
char buf[1024];
|
||||
int sec, msec;
|
||||
va_list ap;
|
||||
static struct timeval startTime;
|
||||
struct timeval tv;
|
||||
char buf[1024];
|
||||
int sec, msec;
|
||||
|
||||
va_start(ap,format);
|
||||
if (proc->flags & LWP_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);
|
||||
printf("%d:%02d.%03d %17s[%d]: %s\n", sec/60, sec%60, msec/10,
|
||||
proc->name, proc->pri, buf);
|
||||
va_start(ap, format);
|
||||
if (proc->flags & LWP_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);
|
||||
printf("%d:%02d.%03d %17s[%d]: %s\n", sec / 60, sec % 60,
|
||||
msec / 10, proc->name, proc->pri, buf);
|
||||
}
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue