Return to waitlist.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / pi

Annotation of researchv9/jtools/src/pi/waitlist.c, revision 1.1

1.1     ! root        1: #include "process.pub"
        !             2: #include "frame.pri"
        !             3: #include "symtab.pri"
        !             4: #include "symbol.h"
        !             5: #include "hostcore.h"
        !             6: #include "asm.pri"
        !             7: #include "format.pub"
        !             8: #include "bpts.pri"
        !             9: #include "master.pri"
        !            10: SRCFILE("waitlist.c")
        !            11: 
        !            12: const int STOPPED=0, RUNNING=1, EXITED=2, DIED=3;
        !            13: 
        !            14: void WaitList::add(HostCore* h)
        !            15: {
        !            16:        WaitMem *wm = new WaitMem;
        !            17:        wm->core = h;
        !            18:        wm->next = head;
        !            19:        wm->changed = 0;
        !            20:        head = wm;
        !            21: }
        !            22: 
        !            23: void WaitList::remove(HostCore* h)
        !            24: {
        !            25:        WaitMem *p = 0, *n = head;
        !            26:        while (n && (n->core != h)) {
        !            27:                p = n;
        !            28:                n = p->next;
        !            29:        }
        !            30:        if (!n)
        !            31:                return;
        !            32:        if (!p)
        !            33:                head = n->next;
        !            34:        else
        !            35:                p->next = n->next;
        !            36:        delete n;
        !            37: }
        !            38: 
        !            39: int wait3(_wait*, int, int);
        !            40: int wait(_wait*);
        !            41: 
        !            42: int WaitList::wait(HostCore* h, int flags)
        !            43: {
        !            44:        WaitMem *p = head;
        !            45:        while (p && (p->core != h))
        !            46:                p = p->next;
        !            47:        if (!p)
        !            48:                return 0;
        !            49:        // It may have already occured 
        !            50:        if (p->changed) {
        !            51:                p->changed = 0;
        !            52: out:
        !            53:                if (flags & WAIT_DISCARD)
        !            54:                        return 1;
        !            55:                h->state = STOPPED;
        !            56:                if (WIFSTOPPED(p->status)) {
        !            57:                        h->cursig = p->status.w_stopsig;
        !            58:                        if (h->cursig == SIGTRAP && (flags & WAIT_PCFIX))
        !            59:                                h->regpoke(h->REG_PC(), h->pc() - 2);
        !            60:                } else {
        !            61:                        if (WIFSIGNALED(p->status)) {
        !            62:                                h->state = DIED;
        !            63:                                h->cursig = p->status.w_termsig;
        !            64:                        } else {
        !            65:                                h->state = EXITED;
        !            66:                                h->cursig = p->status.w_retcode;
        !            67:                        }
        !            68:                }
        !            69:                return 1;
        !            70:        }
        !            71:        // Must really wait for it
        !            72:        for(;;) {
        !            73:                int pid;
        !            74:                _wait tstat;
        !            75:                if (flags & WAIT_POLL) {
        !            76:                        if ((pid = ::wait3(&tstat, WNOHANG, 0)) <= 0)
        !            77:                                return 0;
        !            78:                } else  {
        !            79:                        if ((pid = ::wait(&tstat)) == -1)
        !            80:                                return 0;
        !            81:                }
        !            82:                WaitMem *q = head;
        !            83:                for ( ; q; q = q->next)
        !            84:                        if (q->core->pid == pid) {
        !            85:                                q->status = tstat;
        !            86:                                if (q == p)
        !            87:                                        goto out;
        !            88:                                q->changed = 1;
        !            89:                                break;
        !            90:                        }
        !            91:        }
        !            92: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.