git.pond.sub.org Git - empserver/blob - src/lib/lwp/lwp.c

   1 /*
   2  * lwp.c -- lightweight process creation, destruction and manipulation.
   3  * Copyright (C) 1991-3 Stephen Crane.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the Free
  17  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  * author: Stephen Crane, (jsc@doc.ic.ac.uk), Department of Computing,
  20  * Imperial College of Science, Technology and Medicine, 180 Queen's
  21  * Gate, London SW7 2BZ, England.
  22  */
  23
  24 #include <stdio.h>
  25 #include <signal.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include "lwp.h"
  29 #include "lwpint.h"
  30 #include "prototypes.h"
  31
  32 #if defined(_EMPTH_LWP)
  33
  34 #ifdef BOUNDS_CHECK
  35 #include <bounds/fix-args.h>
  36 #include <bounds/unchecked.h>
  37 #endif
  38
  39 #ifdef hpc
  40 extern struct lwpProc *initcontext;
  41 extern int startpoint;
  42 #endif
  43
  44 struct lwpQueue LwpSchedQ[LWP_MAX_PRIO], LwpDeadQ;
  45
  46 struct lwpProc *LwpCurrent = NULL;
  47 char **LwpContextPtr;
  48 int LwpMaxpri = 0;              /* maximum priority so far */
  49
  50 #ifdef POSIXSIGNALS
  51 static sigset_t oldmask;
  52 #else  /* POSIXSIGNALS */
  53 static int oldmask;
  54 #endif /* POSIXSIGNALS */
  55
  56 /* for systems without strdup  */
  57 #ifdef NOSTRDUP
  58 extern char *strdup();
  59 #endif /* NOSTRDUP */
  60
  61 static void lwpStackCheckInit();
  62 static int lwpStackCheck();
  63 static void lwpStackCheckUsed();
  64
  65 /* check stack direction */
  66 static int
  67 growsdown(x)
  68 void *x;
  69 {
  70     int y;
  71
  72 #ifdef BOUNDS_CHECK
  73     BOUNDS_CHECKING_OFF;
  74 #endif
  75     y = (x > (void *)&y);
  76
  77 #ifdef BOUNDS_CHECK
  78     BOUNDS_CHECKING_ON;
  79 #endif
  80
  81     return y;
  82 }
  83
  84 /*
  85  * lwpReschedule -- schedule another process.  we also check for dead
  86  * processes here and free them.
  87  */
  88 void
  89 lwpReschedule()
  90 {
  91     extern struct lwpQueue LwpSchedQ[];
  92     static int lcount = LCOUNT;
  93     static struct lwpProc *nextp;
  94     static int i;
  95 #ifdef POSIXSIGNALS
  96     static sigset_t tmask;
  97 #endif /* POSIXSIGNALS */
  98
  99     if (LwpCurrent && (LwpCurrent->flags & LWP_STACKCHECK)) {
 100         lwpStackCheck(LwpCurrent);
 101     }
 102     if (!--lcount) {
 103         int p = lwpSetPriority(LWP_MAX_PRIO - 1);
 104         lcount = LCOUNT;
 105 #ifdef POSIXSIGNALS
 106         sigprocmask(SIG_SETMASK, &oldmask, &tmask);
 107         sigprocmask(SIG_SETMASK, &tmask, &oldmask);
 108 #else  /* POSIXSIGNALS */
 109         sigsetmask(sigsetmask(oldmask));
 110 #endif /* POSIXSIGNALS */
 111         LwpCurrent->pri = p;
 112     }
 113
 114     /* destroy dead threads */
 115     lwpStatus(LwpCurrent, "Cleaning dead queue");
 116     while (NULL != (nextp = lwpGetFirst(&LwpDeadQ))) {
 117         if (nextp == LwpCurrent) {
 118             lwpStatus(nextp, "OOOPS, we are running already dead thread");
 119             exit(1);
 120         }
 121         lwpDestroy(nextp);
 122         lwpStatus(LwpCurrent, "Destroying done");
 123     }
 124
 125     for (i = LwpMaxpri + 1; i--;) {
 126         while (NULL != (nextp = lwpGetFirst(&LwpSchedQ[i]))) {
 127             if (!nextp->dead)
 128                 break;
 129             /* clean up after dead bodies */
 130             lwpStatus(nextp, "got a dead body");
 131             if (nextp == LwpCurrent) {
 132                 lwpStatus(nextp, "we are in it -- will bury later");
 133                 lwpAddTail(&LwpDeadQ, nextp);
 134             } else {
 135                 lwpDestroy(nextp);
 136 /*                              fprintf(stderr,  "Destroying done\n"); */
 137             }
 138             nextp = 0;
 139         }
 140         if (nextp)
 141             break;
 142     }
 143     if (LwpCurrent == 0 && nextp == 0) {
 144         fprintf(stderr, "No processes to run!\n");
 145         exit(1);
 146     }
 147     if (LwpCurrent)
 148         lwpStatus(LwpCurrent, "switch out");
 149     /* do context switch */
 150 #ifdef BOUNDS_CHECK
 151     BOUNDS_CHECKING_OFF;
 152 #endif
 153
 154 #if defined(hpc)
 155     {
 156         int endpoint;
 157
 158         endpoint = &endpoint;
 159         if (initcontext == NULL || endpoint < startpoint) {
 160             i = lwpSave(LwpCurrent->context);
 161         } else {
 162             LwpCurrent->size = endpoint - startpoint;
 163             LwpCurrent->sbtm = realloc(LwpCurrent->sbtm, LwpCurrent->size);
 164             memcpy(LwpCurrent->sbtm, startpoint, LwpCurrent->size);
 165             if (i = lwpSave(LwpCurrent->context)) {
 166                 memcpy(startpoint, LwpCurrent->sbtm, LwpCurrent->size);
 167                 i = 1;
 168             }
 169         }
 170     }
 171 #else
 172     i = lwpSave(LwpCurrent->context);
 173 #endif
 174 #ifdef BOUNDS_CHECK
 175     BOUNDS_CHECKING_ON;
 176 #endif
 177
 178     if (LwpCurrent != nextp && !(LwpCurrent && i)) {
 179         /* restore previous context */
 180         lwpStatus(nextp, "switch in", nextp->pri);
 181         LwpCurrent = nextp;
 182         *LwpContextPtr = LwpCurrent->ud;
 183 #ifdef BOUNDS_CHECK
 184         BOUNDS_CHECKING_OFF;
 185 #endif
 186         lwpRestore(LwpCurrent->context);
 187
 188 #ifdef BOUNDS_CHECK
 189         BOUNDS_CHECKING_ON;
 190 #endif
 191     }
 192 }
 193
 194 /*
 195  * lwpEntryPoint -- process entry point.
 196  */
 197 void
 198 lwpEntryPoint()
 199 {
 200     extern struct lwpProc *LwpCurrent;
 201 #ifdef POSIXSIGNALS
 202     sigset_t set;
 203 #endif /* POSIXSIGNALS */
 204
 205 #ifdef BOUNDS_CHECK
 206     BOUNDS_CHECKING_OFF;
 207 #endif
 208 #ifdef POSIXSIGNALS
 209     sigemptyset(&set);
 210     sigaddset(&set, SIGALRM);
 211     sigprocmask(SIG_SETMASK, &set, &oldmask);
 212 #else  /*  POSIXSIGNALS */
 213     sigsetmask(SIGNALS);
 214 #endif /* POSIXSIGNALS */
 215     *LwpContextPtr = LwpCurrent->ud;
 216
 217     lwpStatus(LwpCurrent, "starting at entry point");
 218     (*LwpCurrent->entry) (LwpCurrent->argc, LwpCurrent->argv,
 219                           LwpCurrent->ud);
 220     lwpExit();
 221 #ifdef BOUNDS_CHECK
 222     BOUNDS_CHECKING_ON;
 223 #endif
 224
 225
 226 }
 227
 228 /*
 229  * lwpCreate -- create a process.
 230  */
 231 struct lwpProc *
 232 lwpCreate(priority, entry, size, flags, name, desc, argc, argv, ud)
 233 int priority;
 234 void (*entry) ();
 235 int size;
 236 int flags;
 237 char *name;
 238 char *desc;
 239 int argc;
 240 char *argv[];
 241 void *ud;
 242 {
 243     extern struct lwpProc *LwpCurrent;
 244     struct lwpProc *newp;
 245     int *s, x;
 246 #ifdef UCONTEXT
 247     stack_t sp;
 248 #else  /* UCONTEXT */
 249     void *sp;
 250 #endif /* UCONTEXT */
 251     unsigned long stackp;
 252
 253     if (!(newp = (struct lwpProc *)malloc(sizeof(struct lwpProc))))
 254         return (0);
 255     if (flags & LWP_STACKCHECK) {
 256         /* Add a 1K buffer on each side of the stack */
 257         size += 2 * LWP_REDZONE;
 258     }
 259     size += LWP_EXTRASTACK;
 260     size += sizeof(stkalign_t);
 261     if (!(s = (int *)malloc(size)))
 262         return (0);
 263     newp->flags = flags;
 264     newp->name = strdup(name);
 265     newp->desc = strdup(desc);
 266     newp->entry = entry;
 267     newp->argc = argc;
 268     newp->argv = argv;
 269     newp->ud = ud;
 270     if ((newp->flags & LWP_STACKCHECK) == 0) {
 271         stackp = growsdown((void *)&x) ?
 272             (((long)s) + size - sizeof(stkalign_t) - LWP_EXTRASTACK) :
 273             (long)s + LWP_EXTRASTACK;
 274 #ifdef UCONTEXT
 275         sp.ss_sp = (void *)(stackp & -sizeof(stkalign_t));
 276         sp.ss_size = size;
 277         sp.ss_flags = 0;
 278 #else  /* UCONTEXT */
 279         sp = (void *)(stackp & -sizeof(stkalign_t));
 280 #endif /* UCONTEXT */
 281     } else {
 282         if (growsdown(&x)) {
 283             /* round address off to stkalign_t */
 284             stackp = ((long)s) + size - LWP_REDZONE -
 285                 LWP_EXTRASTACK - sizeof(stkalign_t);
 286 #ifdef UCONTEXT
 287             sp.ss_sp = (void *)(stackp & -sizeof(stkalign_t));
 288             sp.ss_size = size;
 289             sp.ss_flags = 0;
 290             newp->lowmark = (void *)(((long)sp.ss_sp) + LWP_EXTRASTACK);
 291 #else  /* UCONTEXT */
 292             sp = (void *)(stackp & -sizeof(stkalign_t));
 293             newp->lowmark = (void *)(((long)sp) + LWP_EXTRASTACK);
 294 #endif /* UCONTEXT */
 295             newp->himark = s;
 296         } else {
 297             stackp = ((long)s) + LWP_REDZONE + LWP_EXTRASTACK;
 298 #ifdef UCONTEXT
 299             sp.ss_sp = (void *)(((long)stackp) & -sizeof(stkalign_t));
 300             sp.ss_size = size;
 301             sp.ss_flags = 0;
 302 #else  /* UCONTEXT */
 303             sp = (void *)(((long)stackp) & -sizeof(stkalign_t));
 304 #endif /* UCONTEXT */
 305             newp->lowmark = (void *)s;
 306             newp->himark = (void *)(((long)s) + size - LWP_REDZONE);
 307         }
 308     }
 309     if (LWP_MAX_PRIO <= priority)
 310         priority = LWP_MAX_PRIO - 1;
 311     if (LwpMaxpri < (newp->pri = priority))
 312         LwpMaxpri = priority;
 313     newp->sbtm = (void *)s;
 314     newp->size = size;
 315     newp->dead = 0;
 316     if (flags & LWP_STACKCHECK)
 317         lwpStackCheckInit(newp);
 318     lwpStatus(newp, "creating process structure sbtm: %d",
 319               (int)newp->sbtm);
 320     lwpReady(newp);
 321     lwpReady(LwpCurrent);
 322 #ifdef UCONTEXT
 323     lwpInitContext(newp, &sp);  /* architecture-dependent: from arch.c */
 324 #else  /* UCONTEXT */
 325     lwpInitContext(newp, sp);   /* architecture-dependent: from arch.c */
 326 #endif /* UCONTEXT */
 327     lwpReschedule();
 328     return (newp);
 329 }
 330
 331 void
 332 lwpDestroy(proc)
 333 struct lwpProc *proc;
 334 {
 335     if (proc->flags & LWP_STACKCHECK) {
 336         lwpStackCheckUsed(proc);
 337         lwpStackCheck(proc);
 338     }
 339     lwpStatus(proc, "destroying sbtm: %d", (int)proc->sbtm);
 340     proc->entry = 0;
 341     proc->ud = 0;
 342     proc->argv = 0;
 343     free((char *)proc->sbtm);
 344     free(proc->name);
 345     free(proc->desc);
 346     proc->name = 0;
 347     proc->desc = 0;
 348     proc->sbtm = 0;
 349     proc->lowmark = 0;
 350     proc->himark = 0;
 351     free((char *)proc);
 352 }
 353
 354 /*
 355  * lwpReady -- put process on ready queue.  if null, assume current.
 356  */
 357 void
 358 lwpReady(p)
 359 struct lwpProc *p;
 360 {
 361     extern struct lwpProc *LwpCurrent;
 362     extern struct lwpQueue LwpSchedQ[];
 363
 364     if (!p)
 365         p = LwpCurrent;
 366     lwpStatus(p, "added to run queue");
 367     lwpAddTail(&LwpSchedQ[p->pri], p);
 368 }
 369
 370 /*
 371  * return user's data
 372  */
 373 void *
 374 lwpGetUD(p)
 375 struct lwpProc *p;
 376 {
 377     if (!p)
 378         p = LwpCurrent;
 379     return (p->ud);
 380 }
 381
 382 /*
 383  * set user's data
 384  */
 385 void
 386 lwpSetUD(p, ud)
 387 struct lwpProc *p;
 388 char *ud;
 389 {
 390     if (!p)
 391         p = LwpCurrent;
 392     p->ud = ud;
 393 }
 394
 395 /*
 396  * set name & desc
 397  */
 398 void
 399 lwpSetDesc(p, name, desc)
 400 struct lwpProc *p;
 401 char *name;
 402 char *desc;
 403 {
 404     if (!p)
 405         p = LwpCurrent;
 406     free(p->name);
 407     free(p->desc);
 408     p->name = strdup(name);
 409     p->desc = strdup(desc);
 410 }
 411
 412 /*
 413  * lwpYield -- yield the processor to another thread.
 414  */
 415 void
 416 lwpYield()
 417 {
 418     lwpStatus(LwpCurrent, "yielding control");
 419     lwpReady(LwpCurrent);
 420     lwpReschedule();
 421 }
 422
 423 /*
 424  * cause the current process to be scheduled for deletion.
 425  */
 426 void
 427 lwpExit()
 428 {
 429     lwpStatus(LwpCurrent, "marking self as dead");
 430     LwpCurrent->dead = 1;
 431     lwpYield();
 432 }
 433
 434 /*
 435  * mark another process as dead, so it will never be rescheduled.
 436  * remove any lingering FD action
 437  */
 438 void
 439 lwpTerminate(p)
 440 struct lwpProc *p;
 441 {
 442     lwpStatus(p, "terminating process");
 443     p->dead = 1;
 444     if (p->fd >= 0)
 445         lwpWakeupFd(p);
 446 }
 447
 448 /*
 449  * set the thread's priority, returning the old.
 450  * if the new priority is lower than the old, we reschedule.
 451  */
 452 int
 453 lwpSetPriority(new)
 454 int new;
 455 {
 456     int old = LwpCurrent->pri;
 457
 458     if (LWP_MAX_PRIO <= new)
 459         new = LWP_MAX_PRIO - 1;
 460     if (LwpMaxpri < new)
 461         LwpMaxpri = new;
 462     LwpCurrent->pri = new;
 463     lwpStatus(LwpCurrent, "resetting priority (%d -> %d)", old, new);
 464     if (new < old)
 465         lwpYield();
 466     return (old);
 467 }
 468
 469 /*
 470  * initialise the coroutine structures
 471  */
 472 struct lwpProc *
 473 lwpInitSystem(pri, ctxptr, flags)
 474 int pri;
 475 char **ctxptr;
 476 int flags;
 477 {
 478     extern struct lwpQueue LwpSchedQ[];
 479     extern struct lwpProc *LwpCurrent;
 480     struct lwpQueue *q;
 481     int i, *stack;
 482     struct lwpProc *sel;
 483
 484     LwpContextPtr = ctxptr;
 485     if (pri < 1)
 486         pri = 1;
 487     /* *LwpContextPtr = 0; */
 488     if (!
 489         (LwpCurrent = (struct lwpProc *)calloc(1, sizeof(struct lwpProc))))
 490         return (0);
 491     if (!(stack = (int *)malloc(64)))
 492         return (0);
 493     if (LWP_MAX_PRIO <= pri)
 494         pri = LWP_MAX_PRIO - 1;
 495     if (LwpMaxpri < pri)
 496         LwpMaxpri = pri;
 497     LwpCurrent->next = 0;
 498     LwpCurrent->sbtm = stack;   /* dummy stack for "main" */
 499     LwpCurrent->pri = pri;
 500     LwpCurrent->dead = 0;
 501     LwpCurrent->flags = flags;
 502     LwpCurrent->name = "Main";
 503     for (i = LWP_MAX_PRIO, q = LwpSchedQ; i--; q++)
 504         q->head = q->tail = 0;
 505     LwpDeadQ.head = LwpDeadQ.tail = 0;
 506     /* must be lower in priority than us for this to work right */
 507     sel = lwpCreate(0, lwpSelect, 16384, flags, "EventHandler",
 508                     "Select (main loop) Event Handler", 0, 0, 0);
 509     lwpInitSelect(sel);
 510     return (LwpCurrent);
 511 }
 512
 513 /* lwpStackCheckInit
 514  *
 515  * Initialize the entire stack (including both redzones) with the stack
 516  * check mark.  Thus, we can get some indication of how much stack was
 517  * used.
 518  */
 519 static void
 520 lwpStackCheckInit(newp)
 521 struct lwpProc *newp;
 522 {
 523     register int i;
 524     register long *lp;
 525
 526     int lim = newp->size / sizeof(long);
 527     if (!newp || !newp->sbtm)
 528         return;
 529     for (lp = newp->sbtm, i = 0; i < lim; i++, lp++) {
 530         *lp = LWP_CHECKMARK;
 531     }
 532 }
 533
 534 /* lwpStackCheck
 535  *
 536  * Check if the thread has overflowed/underflowed its stack.
 537  * NOTE:
 538  *   If an problem occurs, it is not corrected.
 539  *   The buffer is not cleaned up, nor is the thread terminated.
 540  *   Cleaning up the buffer would be a mistake, and terminating
 541  *   the thread, well, could be done.   Should more like take
 542  *   down the entire process.
 543  */
 544 static int
 545 lwpStackCheck(newp)
 546 struct lwpProc *newp;
 547 {
 548     register int end, amt;
 549     register unsigned int i;
 550     register long *lp;
 551     register int growsDown;
 552     int marker;
 553
 554     if (!newp || !newp->himark || !newp->lowmark)
 555         return (1);
 556     growsDown = growsdown(&marker);
 557     for (lp = newp->himark, i = 0; i < LWP_REDZONE / sizeof(long);
 558          i++, lp++) {
 559         if (*lp == LWP_CHECKMARK)
 560             continue;
 561         /* Stack overflow. */
 562         if (growsDown) {
 563             end = i;
 564             while (i < LWP_REDZONE / sizeof(long)) {
 565                 if (*lp++ != LWP_CHECKMARK)
 566                     end = i;
 567                 i++;
 568             }
 569             amt = (end + 1) * sizeof(long);
 570         } else {
 571             amt = (i + 1) * sizeof(long);
 572         }
 573         lwpStatus(newp, "Thread stack overflowed %d bytes (of %u)",
 574                   amt, newp->size - 2 * LWP_REDZONE - sizeof(stkalign_t));
 575         return (0);
 576     }
 577     for (lp = newp->lowmark, i = 0; i < LWP_REDZONE / sizeof(long);
 578          i++, lp++) {
 579         if (*lp == LWP_CHECKMARK)
 580             continue;
 581         /* Stack underflow. */
 582         if (growsDown) {
 583             end = i;
 584             while (i < LWP_REDZONE / sizeof(long)) {
 585                 if (*lp++ != LWP_CHECKMARK)
 586                     end = i;
 587                 i++;
 588             }
 589             amt = (end + 1) * sizeof(long);
 590         } else {
 591             amt = (LWP_REDZONE - i + 1) * sizeof(long);
 592         }
 593         lwpStatus(newp, "Thread stack underflow %d bytes (of %u)",
 594                   amt, newp->size - 2 * LWP_REDZONE - sizeof(stkalign_t));
 595         return (0);
 596     }
 597     return (1);
 598 }
 599
 600 /* lwpStackCheckUsed
 601  *
 602  * Figure out how much stack was used by this thread.
 603  */
 604 static void
 605 lwpStackCheckUsed(newp)
 606 struct lwpProc *newp;
 607 {
 608     register int i;
 609     register long *lp;
 610     register int lim;
 611     int marker;
 612
 613     if (!newp || !newp->sbtm)
 614         return;
 615     lim = newp->size / sizeof(long);
 616     if (growsdown(&marker)) {
 617         /* Start at the bottom and find first non checkmark. */
 618         for (lp = newp->sbtm, i = 0; i < lim; i++, lp++) {
 619             if (*lp != LWP_CHECKMARK) {
 620                 break;
 621             }
 622         }
 623     } else {
 624         /* Start at the top and find first non checkmark. */
 625         lp = newp->sbtm;
 626         lp += newp->size / sizeof(long);
 627         lp--;
 628         for (i = 0; i < lim; i++, lp--) {
 629             if (*lp != LWP_CHECKMARK) {
 630                 break;
 631             }
 632         }
 633     }
 634     lwpStatus(newp, "stack use: %u bytes (of %u total)",
 635               (i * sizeof(long)) - LWP_REDZONE,
 636               newp->size - 2 * LWP_REDZONE - sizeof(stkalign_t));
 637 }
 638
 639 #endif