Return to pgrp.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/pgrp.c, revision 1.1.1.1

1.1       root        1: #include       "u.h"
                      2: #include       "../port/lib.h"
                      3: #include       "mem.h"
                      4: #include       "dat.h"
                      5: #include       "fns.h"
                      6: #include       "../port/error.h"
                      7: 
                      8: static Ref pgrpid;
                      9: static Ref mountid;
                     10: 
                     11: void
                     12: pgrpnote(ulong noteid, char *a, long n, int flag)
                     13: {
                     14:        Proc *p, *ep;
                     15:        char buf[ERRLEN];
                     16: 
                     17:        if(n >= ERRLEN-1)
                     18:                error(Etoobig);
                     19: 
                     20:        memmove(buf, a, n);
                     21:        buf[n] = 0;
                     22:        p = proctab(0);
                     23:        ep = p+conf.nproc;
                     24:        for(; p < ep; p++) {
                     25:                if(p->state == Dead)
                     26:                        continue;
                     27:                if(p != u->p && p->noteid == noteid && p->kp == 0) {
                     28:                        qlock(&p->debug);
                     29:                        if(p->pid == 0 || p->noteid != noteid){
                     30:                                qunlock(&p->debug);
                     31:                                continue;
                     32:                        }
                     33:                        if(!waserror()) {
                     34:                                postnote(p, 0, buf, flag);
                     35:                                poperror();
                     36:                        }
                     37:                        qunlock(&p->debug);
                     38:                }
                     39:        }
                     40: }
                     41: 
                     42: Pgrp*
                     43: newpgrp(void)
                     44: {
                     45:        Pgrp *p;
                     46: 
                     47:        p = smalloc(sizeof(Pgrp));
                     48:        p->ref = 1;
                     49:        p->pgrpid = incref(&pgrpid);
                     50:        return p;
                     51: }
                     52: 
                     53: void
                     54: closepgrp(Pgrp *p)
                     55: {
                     56:        Mhead **h, **e, *f, *next;
                     57:        
                     58:        if(decref(p) == 0){
                     59:                qlock(&p->debug);
                     60:                p->pgrpid = -1;
                     61: 
                     62:                e = &p->mnthash[MNTHASH];
                     63:                for(h = p->mnthash; h < e; h++) {
                     64:                        for(f = *h; f; f = next) {
                     65:                                close(f->from);
                     66:                                mountfree(f->mount);
                     67:                                next = f->hash;
                     68:                                free(f);
                     69:                        }
                     70:                }
                     71:                qunlock(&p->debug);
                     72:                free(p);
                     73:        }
                     74: }
                     75: 
                     76: void
                     77: pgrpcpy(Pgrp *to, Pgrp *from)
                     78: {
                     79:        Mhead **h, **e, *f, **tom, **l, *mh;
                     80:        Mount *n, *m, **link;
                     81: 
                     82:        rlock(&from->ns);
                     83: 
                     84:        e = &from->mnthash[MNTHASH];
                     85:        tom = to->mnthash;
                     86:        for(h = from->mnthash; h < e; h++) {
                     87:                l = tom++;
                     88:                for(f = *h; f; f = f->hash) {
                     89:                        mh = smalloc(sizeof(Mhead));
                     90:                        mh->from = f->from;
                     91:                        incref(mh->from);
                     92:                        *l = mh;
                     93:                        l = &mh->hash;
                     94:                        link = &mh->mount;
                     95:                        for(m = f->mount; m; m = m->next) {
                     96:                                n = newmount(mh, m->to);
                     97:                                *link = n;
                     98:                                link = &n->next;        
                     99:                        }
                    100:                }
                    101:        }
                    102:        runlock(&from->ns);
                    103: }
                    104: 
                    105: Fgrp*
                    106: dupfgrp(Fgrp *f)
                    107: {
                    108:        Fgrp *new;
                    109:        Chan *c;
                    110:        int i;
                    111: 
                    112:        new = smalloc(sizeof(Fgrp));
                    113:        new->ref = 1;
                    114: 
                    115:        lock(f);
                    116:        new->maxfd = f->maxfd;
                    117:        for(i = 0; i <= f->maxfd; i++) {
                    118:                if(c = f->fd[i]){
                    119:                        incref(c);
                    120:                        new->fd[i] = c;
                    121:                }
                    122:        }
                    123:        unlock(f);
                    124: 
                    125:        return new;
                    126: }
                    127: 
                    128: void
                    129: closefgrp(Fgrp *f)
                    130: {
                    131:        int i;
                    132:        Chan *c;
                    133: 
                    134:        if(decref(f) == 0) {
                    135:                for(i = 0; i <= f->maxfd; i++)
                    136:                        if(c = f->fd[i])
                    137:                                close(c);
                    138: 
                    139:                free(f);
                    140:        }
                    141: }
                    142: 
                    143: 
                    144: Mount*
                    145: newmount(Mhead *mh, Chan *to)
                    146: {
                    147:        Mount *m;
                    148: 
                    149:        m = smalloc(sizeof(Mount));
                    150:        m->to = to;
                    151:        m->head = mh;
                    152:        incref(to);
                    153:        m->mountid = incref(&mountid);
                    154:        return m;
                    155: }
                    156: 
                    157: void
                    158: mountfree(Mount *m)
                    159: {
                    160:        Mount *f;
                    161: 
                    162:        while(m) {
                    163:                f = m->next;
                    164:                close(m->to);
                    165:                free(m);
                    166:                m = f;
                    167:        }
                    168: }
                    169: 
                    170: void
                    171: resrcwait(char *reason)
                    172: {
                    173:        char *p;
                    174: 
                    175:        p = u->p->psstate;
                    176:        if(reason) {
                    177:                u->p->psstate = reason;
                    178:                print("%s\n", reason);
                    179:        }
                    180:        if(u == 0)
                    181:                panic("resrcwait");
                    182: 
                    183:        tsleep(&u->p->sleep, return0, 0, 300);
                    184:        u->p->psstate = p;
                    185: }

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