1,6c1,4
< /*ident "@(#)cls4:lib/task/task/task.c 1.8" */
< /*******************************************************************************
<
< C++ source for the C++ Language System, Release 3.0. This product
< is a new release of the original cfront developed in the computer
< science research center of AT&T Bell Laboratories.
---
> /*ident "@(#)C++env:lib/task/task/task.c 1.6" */
> /**************************************************************************
> Copyright (c) 1984 AT&T
> All Rights Reserved
8,10c6,9
< Copyright (c) 1993 UNIX System Laboratories, Inc.
< Copyright (c) 1991, 1992 AT&T and UNIX System Laboratories, Inc.
< Copyright (c) 1984, 1989, 1990 AT&T. All Rights Reserved.
---
> THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
>
> The copyright notice above does not evidence any
> actual or intended publication of such source code.
12,14c11,16
< THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE of AT&T and UNIX System
< Laboratories, Inc. The copyright notice above does not evidence
< any actual or intended publication of such source code.
---
> *****************************************************************************/
> // this file now assumes that the stack grows down;
> // make another if the stack grows up, or split this
> // into pieces such that one piece knows about stack growing
> // and the other doesn't.
> // DO NOT JUST USE IFDEFS!!!!
16,17d17
< *******************************************************************************/
<
19d18
< #include "hw_stack.h"
20a20
> #include <stdlib.h>
22,23c22,26
< task* task::txsk_chxin = 0;
< team* task::team_to_delete = 0;
---
> #ifdef uts
> enum {SIZE = 2048};
> #else
> enum {SIZE = 750};
> #endif
25c28,30
< #define ABSV(x) ( (x) > 0 ? (x) : -(x) )
---
> // align stack if needed
> #define ALIGN(stack) ((ulong *)((long)(stack) & ~(sizeof(double) - 1)))
> enum { UNTOUCHED = 052525 }; /* value considered never used */
27c32
< const int NEW_CHILD = 1;
---
> typedef unsigned long ulong;
29,34d33
< int _hwm;
<
< HW_REGS New_task_regs; /* hardware regs for activating new child
< * in task::task frame
< */
<
38c37
< friend class task;
---
> friend task;
40,44c39,43
< task* got_stack;
< int* stack;
< int size; // of the stack
< team(task*, int =0); // stacksize == zero ==> using the main stack
< ~team() { delete stack; }
---
> task *got_stack;
> ulong *stack;
> ulong *stackend; // of the stack
> team(task*, int); // stacksize == 0 ==> using the main stack
> ~team() { delete stackend; }
46a46,50
> int _hwm;
> static ulong *stack_base;
> static int stackdown; // does the stack grow down or up?
> static task *running; // task on the current stack
>
50,56c54,65
< if (size = stacksize) {
< stack = new int[stacksize];
< while (stack == 0) object::task_error(E_STORE, (object*)0);
< if (_hwm) {
< for (int x = 0; x < stacksize; x++) {
< stack[x] = UNTOUCHED;
< }
---
> if (stacksize) {
> stack = new ulong[stacksize];
> stackend = ALIGN(stack + stacksize - 1);
> while (stack == 0)
> object::task_error(E_STORE, (object*)0);
> if (_hwm)
> for (ulong *x = stack; x <= stackend; x++)
> *x = UNTOUCHED;
> if (stackdown) {
> ulong *t = stack;
> stack = stackend;
> stackend = t;
57a67,69
> } else {
> stackend = 0;
> stack = stack_base;
61,64c73,74
<
< static void
< usemainstack()
< /* fudge to allow simple stack overflow check */
---
> /* called from _main to set __main__base */
> void __task__init()
66c76,83
< int* sp = TOP();
---
> // get args for main
> // main => _main => __task__init
> Label m;
> setlabel(&m);
> stack_base = stackbase(m);
> stackdown = (ulong)stack_base > m.sp;
> new task("main"); // fire up a main task
> }
68,85c85,98
< if (_hwm) {
< /* WARNING: This function used to declare an array of
< * SIZE+100 and set each element to UNTOUCHED instead
< * of using the following method. But then when compilers
< * inlined this function it caused each new task's stack
< * to overflow on initialization, because the task::task
< * stack frame was SIZE+100 larger.
< */
<
< // start with next word after "sp"
< for (int i = 2; i < SIZE+100; i++) {
< *(STACK_LAST_WORD_P(sp, i)) = UNTOUCHED;
< }
< } else {
< #ifndef i386
< *(STACK_LAST_WORD_P(sp, 0)) = 0;
< #endif
< }
---
> Label
> task::copy_task(Label top, ulong *base, ulong *stack)
> {
> ulong *stop = (ulong *)top.sp;
> if (base == stop)
> task_error(E_STACK, this);
> if (stackdown)
> while (base > stop)
> *stack-- = *base--;
> else
> while (base < stop)
> *stack++ = *base++;
> *stack = *base;
> return movelabel(top, (ulong)stack);
88,93c101,102
< void
< copy_stack(register int* f, register int c, register int* t)
< /*
< copy c words down from f to t
< do NOT attempt to copy "copy_stack"'s own stackframe
< */
---
> void
> task::swapjmp()
95c104,109
< COPY_STACK(f,c,t);
---
> if (t_savearea)
> delete t_savearea;
> t_savearea = 0;
> t_size = 0;
> t_team->got_stack = this;
> gotolabel(1, &t_env);
98,104c112,113
< /* swap_stack copies contents of parent stack (starting at pa_fp)
< * to child stack. Adjusts pointers in saved ta_fp frame of child stack
< * (to point to places in child stack).
< * Returns distance from parent stack to child stack.
< */
< int
< task::swap_stack(int* ta_fp, int* pa_fp)
---
> void
> task::doswap(task *on, int ischild)
106,108c115,129
< int size = ACTIVE_STK_SZ(pa_fp, TOP());
< if (size > t_stacksize) {
< task_error(E_STACK, this);
---
> // make sure we have enough room to work
> // if we are running on the stack we want to swap
> if (running == on) {
> Label m;
>
> setlabel(&m);
> ulong *t = argbase(m);
> ulong sz = stackdown
> ? (ulong)t_team->stack - (ulong)t
> : (ulong)t - (ulong)t_team->stack;
> // recursive call to increase the size of this stack
> if (sz <= t_size) {
> doswap(on, ischild);
> abort();
> }
110,118c131,140
< copy_stack(pa_fp, size, t_basep);
< /* distance from old stack to new */
< register int distance = pa_fp - t_basep;
< /* now doctor the new frame */
< #if defined(vax) || defined(PROC_3B)
< OLD_AP(ta_fp - distance) = int((int*)OLD_AP(ta_fp) - distance);
< #endif
< OLD_FP(ta_fp - distance) = int((int*)OLD_FP(ta_fp) - distance);
< return distance;
---
> on->t_size += sizeof(double);
> on->t_savearea = new char[on->t_size];
> on->t_save = stackdown
> ? on->t_savearea + on->t_size - sizeof(ulong)
> : on->t_savearea + sizeof(double) - sizeof(ulong);
> on->t_save = (char *)ALIGN(on->t_save);
> on->t_env = copy_task(on->t_env, t_team->stack, (ulong *)on->t_save);
> if (!ischild)
> t_env = copy_task(t_env, (ulong *)t_save, t_team->stack);
> swapjmp();
120c142
< inline
---
>
122c144
< task::settrap()
---
> task::swap(int ischild)
124,127c146,155
< if (t_team->size) { // Don't set trap for main task
< t_trap = *(STACK_LAST_WORD_P(
< STACK_BASE(t_team->stack, t_stacksize),
< t_team->size));
---
> task *on = on = t_team->got_stack;
> if (this != on) {
> if (ischild)
> t_size = stackdown
> ? (ulong)t_team->stack - t_env.sp
> : t_env.sp - (ulong)t_team->stack;
> on->t_size = stackdown
> ? (ulong)t_team->stack - on->t_env.sp
> : (ulong)on->t_env.sp - (ulong)t_team->stack;
> doswap(on, ischild);
128a157
> swapjmp();
133c162
< task::checktrap()
---
> task::settrap()
135,141c164,165
< if (t_team->size // Don't test for main task
< && t_trap != *(STACK_LAST_WORD_P(
< STACK_BASE(t_team->stack, t_stacksize),
< t_team->size))) {
< task_error(E_STACK, this);
< }
<
---
> if (t_team->stackend) // Don't set trap for main task
> t_trap = *t_team->stackend;
144,149d167
< extern "C" {
< /* swap and sswap are assembly language functions */
< extern task* swap(task*, task*, int, int);
< extern task* sswap(task*, task*, task*, int, int);
< }
<
152,170c170
< task::restore(task* running, int is_new_child)
< /*
< * Call assembly function swap or sswap to do a task switch.
< * Swap suspends "running" task by saving current hardware state (fp, etc)
< * in running->t_framep, etc.,
< * and makes "this" task run after suspension by returning from the frame
< * denoted by "t_framep."
< *
< * swap does a normal return--must be the last thing called here.
< * swap for a new child task will not return through restore,
< * but will return from task::task().
< *
< * sswap saves running's hw state, copies out the target stack,
< * copies in to_run's stack from the save area before "swap"ing
< * It is equivalent to two "copystack"s in the middle of "swap".
< * sswap for a new child copies out the parent stack, but does not need
< * to restore hw_state of child--it's already in place, and
< * WILL return through restore, unlike swap.
< */
---
> task::checktrap()
172,195c172,174
< task* prevOnStack;
< // running might have been TERMINATED
< int is_terminated = 0;
< if ((running == 0) || (running->s_state == TERMINATED)) {
< is_terminated = 1;
< } else {
< running->checktrap();
< }
<
< if ((t_mode == SHARED) && this != (prevOnStack = t_team->got_stack)){
< t_team->got_stack = this; // assuming sswap will get space.
< sswap(running, prevOnStack, this, is_new_child, is_terminated);
< }
< else { // DEDICATED or (SHARED && this already on target stack)
< swap(running, this, is_new_child, is_terminated);
< }
< //sswap and swap for old task return here.
< // This code is not needed for a new child, because a terminated
< // parent cannot create a new child.
< if (team_to_delete) {
< delete team_to_delete;
< team_to_delete = 0;
< }
< // WARNING! No new code here.
---
> // Don't test for main task
> if (t_team->stackend && t_trap != *t_team->stackend)
> task_error(E_STACK, this);
210,218c189
< register task* running;
<
< register int* ta_fp = (int*)FP(); // fp for task::task()
< register int* ta_ap = (int*)AP(); // ap for task::task()
< register int* de_fp = (int*)OLD_FP(ta_fp); // fp for ctor of class
< // derived from class task
< register int* de_ap = (int*)OLD_AP(ta_fp);
< register int* pa_fp = (int*)OLD_FP(de_fp); // parent fp
< // (caller of derived ctor)
---
> running = thxstxsk;
221a193,194
> t_savearea = 0;
> t_size = 0;
226d198
< th = this; /* fudged return value -- "returned" from swap */
228,248c200,202
< switch ((int)thxstxsk) {
< case 0:
< /* initialize task system by creating "main" task */
< thxstxsk = (task*) 1;
< thxstxsk = new task("main");
< break;
< case 1:
< /* create "main" task */
< usemainstack(); /* ensure that store is allocated */
< //set base pointer assuming a static task (Interrupt_alerter)
< //at this point stack has 6 frames for:
< //main, _main, <static ctor>, Int::Int, task::task, task::task
< //NOTE: This sets basep to be the fp saved in _main's stack
< //frame (fp for main). Depending on layout, may not include
< //main's save area. This shouldn't matter.
< #ifdef i386
< t_basep = (int*)OLD_FP((int*)OLD_FP(pa_fp));
< #else
< t_basep = (int*)OLD_FP((int*)OLD_FP((int*)OLD_FP(pa_fp)));
< #endif
< t_team = new team(this); /* don't allocate stack */
---
> if (thxstxsk == 0) { // called from __task__init()
> // create "main" task
> t_team = new team(this, 0); /* don't allocate stack */
249a204
> thxstxsk = this;
252,255c207,208
< // thxstxsk is parent task
< /* return pointer to "child" */
< thxstxsk->th = this;
< thxstxsk->insert(0,this);
---
> // schedule this task to run now
> thxstxsk->insert(0, this);
259,261c212
< {
< t_team = new team(this,t_stacksize);
< t_basep = STACK_BASE(t_team->stack, t_stacksize);
---
> t_team = new team(this, t_stacksize);
263,268c214,216
< // initialize child's stack
< int distance = swap_stack(ta_fp, pa_fp);
< // save hardware state of this frame in "this" (child)
< t_framep = ta_fp - distance;
< t_ap = ta_ap - distance;
< settrap();
---
> if (setlabel(&thxstxsk->t_env) == 0) {
> // child; returns first
> Label child = upframe(thxstxsk->t_env);
270,283c218,221
< // save all current and saved hw regs in New_task_regs,
< // so when child begins execution, it will have hw regs
< // as the derived constructor had them set.
< SAVE_CHILD_REGS(&New_task_regs);
<
< thxstxsk->fudge_return(ta_fp);
< running = thxstxsk; // running = parent
< thxstxsk = this;
< restore(running, NEW_CHILD); // no return for child;
< // parent will return
< // Needed on some machines to reset sp on fudged stack
< FUDGE_SP(de_ap, de_fp); // Can't access arguments on 3B now
< // (except arg1, implicit "this")
< return; // On 68k, return through fudge_sp()
---
> thxstxsk = this;
> child = copy_task(child, argbase(child), t_team->stack);
> settrap();
> gotolabel((long)this, &child);
284a223,224
> break;
>
287d226
< t_basep = pa_fp;
290,303c229,237
< t_framep = ta_fp;
< t_ap = ta_ap;
< settrap();
< running = thxstxsk; // running == parent
< thxstxsk = this;
< restore(running, NEW_CHILD); // both parent & child will
< // return
< if (running == thxstxsk) { // parent
< running->fudge_return(ta_fp);
< // Needed on some machines to reset sp on fudged stack
< FUDGE_SP(de_ap, de_fp); // Can't access arguments
< // on 3B now (except arg1,
< // implicit "this")
< // On 68k, parent returns through fudge_sp()
---
> if (setlabel(&thxstxsk->t_env) == 0) {
> // child; return first
> if (setlabel(&t_env) == 0)
> swap(1);
> // ok, now we are really running;
> thxstxsk = this;
> Label child = upframe(t_env);
> settrap();
> gotolabel((long)this, &child);
305c239
< return;
---
> break;
308a243,251
>
> // parent
> if (team_to_delete) {
> delete team_to_delete;
> team_to_delete = 0;
> }
> /* return this to function that called the derived constructor */
> Label me = upframe(upframe(thxstxsk->t_env));
> gotolabel((long)this, &me);
314c257
< task* running = thxstxsk;
---
> running = thxstxsk;
316c259,272
< restore(running);
---
> if (running && running->s_state != TERMINATED)
> running->checktrap();
>
> // NOTE -- need to do shared here
> if (running == 0 || setlabel(&running->t_env) == 0) {
> if (t_mode == SHARED)
> swap(0);
> else
> gotolabel(1, &this->t_env);
> }
> if (team_to_delete) {
> delete team_to_delete;
> team_to_delete = 0;
> }
360a317,318
> if (t_savearea)
> delete t_savearea;
431c389
< printf("task\n");
---
> fprintf(stderr, "task\n");
436c394
< printf("task %s ",ns);
---
> fprintf(stderr, "task %s ",ns);
438c396
< printf("(is thistask, %s) ", ss);
---
> fprintf(stderr, "(is thistask, %s) ", ss);
440c398
< printf("(%s) ",ss);
---
> fprintf(stderr, "(%s) ",ss);
442,443c400,401
< printf("(state==%d CORRUPTED) ",s_state);
< printf("\tthis = %x:\n", this);
---
> fprintf(stderr, "(state==%d CORRUPTED) ",s_state);
> fprintf(stderr, "\tthis = %x:\n", this);
448c406
< printf("\tmode=%s t_alert=%x t_next=%x",
---
> fprintf(stderr, "\tmode=%s t_alert=%x t_next=%x",
450c408
< printf((s_state==TERMINATED) ? " result=%d\n" : " s_time=%d\n", s_time);
---
> fprintf(stderr, (s_state==TERMINATED) ? " result=%d\n" : " s_time=%d\n", s_time);
454c412,414
< printf("\tstack: ");
---
> fprintf(stderr, "\tstack: ");
> fprintf(stderr, "stack=0x%x, stackend=0x%x, ",
> t_team->stack, t_team->stackend);
456c416,435
< printf("deleted. ");
---
> fprintf(stderr, "deleted. ");
> if (_hwm)
> fprintf(stderr, "hwm size=%d", t_size);
> fprintf(stderr, "\n");
> } else {
> fprintf(stderr, "\tsizes:\t");
> ulong *top;
> if (this==thxstxsk) { // figure out real current size
> Label m;
>
> setlabel(&m);
> top = (ulong *)m.sp;
> } else // approximate at last switch
> top = (ulong *)t_env.sp;
> ulong sz = stackdown ? (ulong)t_team->stack - (ulong)top
> : (ulong)top - (ulong)t_team->stack;
> if (t_mode == SHARED)
> sz = t_size;
> fprintf(stderr, "max=%d, current=%d", t_stacksize, sz);
> int my_hwm;
458,459c437,438
< printf("hwm size=%d, ", t_size);
< printf("hwm address=%x",STACK_LAST_WORD_P(t_basep,t_size));
---
> my_hwm = curr_hwm();
> fprintf(stderr, ", hwm=%d", my_hwm);
461c440,446
< printf("\n");
---
> fprintf(stderr, "\n\t\taddresses:\t");
> fprintf(stderr, "top of stack=0x%x", top);
> if (_hwm)
> fprintf(stderr, ", hwm=0x%x",
> stackdown ? t_team->stack - my_hwm
> : t_team->stack + my_hwm);
> fprintf(stderr, "\n");
463,483d447
< else {
< register int* b = t_basep;
< printf("\tsizes:\t");
< register int sz;
< if (this==thxstxsk) { // figure out real current size
< sz = ACTIVE_STK_SZ(b,TOP());
< } else { // approximate at last switch
< sz = t_mode==DEDICATED ?
< ACTIVE_STK_SZ(b,t_framep) : t_size;
< }
< printf("max=%d, current=%d",t_stacksize, sz);
< if (_hwm) printf(", hwm=%d",curr_hwm());
< printf("\n\t\taddresses:\t");
< printf("t_basep=%x, t_framep=%x\n",b,t_framep);
< printf("\t\t\t\tmax=%x",
< STACK_LAST_WORD_P(b,t_stacksize));
< printf(", current=%x", STACK_LAST_WORD_P(b,sz));
< if (_hwm) printf(", hwm=%x",
< STACK_LAST_WORD_P(b, curr_hwm()));
< printf("\n");
< }
494c458
< printf("\nChain of all tasks:\n");
---
> fprintf(stderr, "\nChain of all tasks:\n");
497c461
< printf("Next task on chain of all tasks is:\n");
---
> fprintf(stderr, "Next task on chain of all tasks is:\n");
508,511c472,480
< int* b = t_basep;
< int i;
< for (i=t_team->size; 0<i && *(STACK_LAST_WORD_P(b,i))==UNTOUCHED; i--) ;
< return i;
---
> ulong *b = t_team->stackend;
> ulong *e = t_team->stack;
> if (stackdown)
> while (b < e && *b == UNTOUCHED)
> b++;
> else
> while (b > e && *b == UNTOUCHED)
> b--;
> return stackdown ? e - b : b - e;
555c524
< Interrupt_alerter interrupt_alerter;
---
> // not on plan 9 yet Interrupt_alerter interrupt_alerter;
|
