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