ref: 51bcc63cc6bce3f9dab27cf6bd7155512b82c8fa
dir: /emu/port/dis.c/
#include "dat.h"
#include "fns.h"
#include <isa.h>
#include <interp.h>
#include <kernel.h>
#include "error.h"
#include "raise.h"
struct
{
Lock l;
Prog* runhd;
Prog* runtl;
Prog* head;
Prog* tail;
Rendez irend;
int idle;
int nyield;
int creating;
Proc* vmq; /* queue of procs wanting vm */
Proc* vmqt;
Proc* idlevmq; /* queue of procs wanting work */
Atidle* idletasks;
} isched;
int bflag;
int cflag;
uvlong gcbusy;
uvlong gcidle;
uvlong gcidlepass;
uvlong gcpartial;
int keepbroken = 1;
extern int vflag;
static Prog* proghash[64];
static Progs* delgrp(Prog*);
static void addgrp(Prog*, Prog*);
void printgrp(Prog*, char*);
static Prog**
pidlook(int pid)
{
ulong h;
Prog **l;
h = (ulong)pid % nelem(proghash);
for(l = &proghash[h]; *l != nil && (*l)->pid != pid; l = &(*l)->pidlink)
;
return l;
}
int
tready(void *a)
{
USED(a);
return isched.runhd != nil || isched.vmq != nil;
}
Prog*
progpid(int pid)
{
return *pidlook(pid);
}
Prog*
progn(int n)
{
Prog *p;
for(p = isched.head; p && n--; p = p->next)
;
return p;
}
int
nprog(void)
{
int n;
Prog *p;
n = 0;
for(p = isched.head; p; p = p->next)
n++;
return n;
}
static void
execatidle(void)
{
int done;
if(tready(nil))
return;
gcidle++;
up->type = IdleGC;
up->iprog = nil;
addrun(up->prog);
done = gccolor+3;
while(gccolor < done && gcruns()) {
if(isched.vmq != nil || isched.runhd != isched.runtl) {
gcpartial++;
break;
}
rungc(isched.head);
gcidlepass++;
if(((ulong)gcidlepass&0xFF) == 0)
osyield();
}
up->type = Interp;
delrunq(up->prog);
}
Prog*
newprog(Prog *p, Modlink *m)
{
Heap *h;
Prog *n, **ph;
Osenv *on, *op;
static int pidnum;
if(p != nil){
if(p->group != nil)
p->flags |= p->group->flags & Pkilled;
if(p->kill != nil)
error(p->kill);
if(p->flags & Pkilled)
error("");
}
n = malloc(sizeof(Prog)+sizeof(Osenv));
if(n == 0){
if(p == nil)
panic("no memory");
else
error(exNomem);
}
n->pid = ++pidnum;
if(n->pid <= 0)
panic("no pids");
n->group = nil;
if(isched.tail != nil) {
n->prev = isched.tail;
isched.tail->next = n;
}
else {
isched.head = n;
n->prev = nil;
}
isched.tail = n;
ph = pidlook(n->pid);
if(*ph != nil)
panic("dup pid");
n->pidlink = nil;
*ph = n;
n->osenv = (Osenv*)((uchar*)n + sizeof(Prog));
n->xec = xec;
n->quanta = PQUANTA;
n->flags = 0;
n->exval = H;
h = D2H(m);
h->ref++;
Setmark(h);
n->R.M = m;
n->R.MP = m->MP;
if(m->MP != H)
Setmark(D2H(m->MP));
addrun(n);
if(p == nil){
newgrp(n);
return n;
}
addgrp(n, p);
n->flags = p->flags;
if(p->flags & Prestrict)
n->flags |= Prestricted;
memmove(n->osenv, p->osenv, sizeof(Osenv));
op = p->osenv;
on = n->osenv;
on->waitq = op->childq;
on->childq = nil;
on->debug = nil;
incref(&on->pgrp->r);
incref(&on->fgrp->r);
incref(&on->egrp->r);
if(on->sigs != nil)
incref(&on->sigs->r);
on->user = nil;
kstrdup(&on->user, op->user);
on->errstr = on->errbuf0;
on->syserrstr = on->errbuf1;
return n;
}
void
delprog(Prog *p, char *msg)
{
Osenv *o;
Prog **ph;
tellsomeone(p, msg); /* call before being removed from prog list */
o = p->osenv;
release();
closepgrp(o->pgrp);
closefgrp(o->fgrp);
closeegrp(o->egrp);
closesigs(o->sigs);
acquire();
delgrp(p);
if(p->prev)
p->prev->next = p->next;
else
isched.head = p->next;
if(p->next)
p->next->prev = p->prev;
else
isched.tail = p->prev;
ph = pidlook(p->pid);
if(*ph == nil)
panic("lost pid");
*ph = p->pidlink;
if(p == isched.runhd) {
isched.runhd = p->link;
if(p->link == nil)
isched.runtl = nil;
}
p->state = 0xdeadbeef;
free(o->user);
free(p->killstr);
free(p->exstr);
free(p);
}
void
renameproguser(char *old, char *new)
{
Prog *p;
Osenv *o;
acquire();
for(p = isched.head; p; p = p->next){
o = p->osenv;
if(o->user != nil && strcmp(o->user, old) == 0)
kstrdup(&o->user, new);
}
release();
}
void
tellsomeone(Prog *p, char *buf)
{
Osenv *o;
if(waserror())
return;
o = p->osenv;
if(o->childq != nil)
qproduce(o->childq, buf, strlen(buf));
if(o->waitq != nil)
qproduce(o->waitq, buf, strlen(buf));
poperror();
}
static void
swiprog(Prog *p)
{
Proc *q;
lock(&procs.l);
for(q = procs.head; q; q = q->next) {
if(q->iprog == p) {
unlock(&procs.l);
swiproc(q, 1);
return;
}
}
unlock(&procs.l);
/*print("didn't find\n");*/
}
static Prog*
grpleader(Prog *p)
{
Progs *g;
Prog *l;
g = p->group;
if(g != nil && (l = g->head) != nil && l->pid == g->id)
return l;
return nil;
}
int
exprog(Prog *p, char *exc)
{
/* similar code to killprog but not quite */
switch(p->state) {
case Palt:
altdone(p->R.s, p, nil, -1);
break;
case Psend:
cqdelp(&p->chan->send, p);
break;
case Precv:
cqdelp(&p->chan->recv, p);
break;
case Pready:
break;
case Prelease:
swiprog(p);
break;
case Pexiting:
case Pbroken:
case Pdebug:
return 0;
default:
panic("exprog - bad state 0x%x\n", p->state);
}
if(p->state != Pready && p->state != Prelease)
addrun(p);
if(p->kill == nil){
if(p->killstr == nil){
p->killstr = malloc(ERRMAX);
if(p->killstr == nil){
p->kill = Enomem;
return 1;
}
}
kstrcpy(p->killstr, exc, ERRMAX);
p->kill = p->killstr;
}
return 1;
}
static void
propex(Prog *p, char *estr)
{
Prog *f, *nf, *pgl;
if(!(p->flags & (Ppropagate|Pnotifyleader)) || p->group == nil)
return;
if(*estr == 0){
if((p->flags & Pkilled) == 0)
return;
estr = "killed";
}
pgl = grpleader(p);
if(pgl == nil)
pgl = p;
if(!(pgl->flags & (Ppropagate|Pnotifyleader)))
return; /* exceptions are local; don't propagate */
for(f = p->group->head; f != nil; f = nf){
nf = f->grpnext;
if(f != p && f != pgl){
if(pgl->flags & Ppropagate)
exprog(f, estr);
else{
f->flags &= ~(Ppropagate|Pnotifyleader); /* prevent recursion */
killprog(f, "killed");
}
}
}
if(p != pgl)
exprog(pgl, estr);
}
int
killprog(Prog *p, char *cause)
{
Osenv *env;
char msg[ERRMAX+2*KNAMELEN];
if(p == isched.runhd) {
p->kill = "";
p->flags |= Pkilled;
p->state = Pexiting;
return 0;
}
switch(p->state) {
case Palt:
altdone(p->R.s, p, nil, -1);
break;
case Psend:
cqdelp(&p->chan->send, p);
break;
case Precv:
cqdelp(&p->chan->recv, p);
break;
case Pready:
delrunq(p);
break;
case Prelease:
p->kill = "";
p->flags |= Pkilled;
p->state = Pexiting;
swiprog(p);
/* No break */
case Pexiting:
return 0;
case Pbroken:
case Pdebug:
break;
default:
panic("killprog - bad state 0x%x\n", p->state);
}
if(p->addrun != nil) {
p->kill = "";
p->flags |= Pkilled;
p->addrun(p);
p->addrun = nil;
return 0;
}
env = p->osenv;
if(env->debug != nil) {
p->state = Pbroken;
dbgexit(p, 0, cause);
return 0;
}
propex(p, "killed");
snprint(msg, sizeof(msg), "%d \"%s\":%s", p->pid, p->R.M->m->name, cause);
p->state = Pexiting;
gclock();
destroystack(&p->R);
delprog(p, msg);
gcunlock();
return 1;
}
void
newgrp(Prog *p)
{
Progs *pg, *g;
if(p->group != nil && p->group->id == p->pid)
return;
g = malloc(sizeof(*g));
if(g == nil)
error(Enomem);
p->flags &= ~(Ppropagate|Pnotifyleader);
g->id = p->pid;
g->flags = 0;
if(p->group != nil)
g->flags |= p->group->flags&Pprivatemem;
g->child = nil;
pg = delgrp(p);
g->head = g->tail = p;
p->group = g;
if(pg != nil){
g->sib = pg->child;
pg->child = g;
}
g->parent = pg;
}
static void
addgrp(Prog *n, Prog *p)
{
Progs *g;
n->group = p->group;
if((g = n->group) != nil){
n->grpnext = nil;
if(g->head != nil){
n->grpprev = g->tail;
g->tail->grpnext = n;
}else{
n->grpprev = nil;
g->head = n;
}
g->tail = n;
}
}
static Progs*
delgrp(Prog *p)
{
Progs *g, *pg, *cg, **l;
g = p->group;
if(g == nil)
return nil;
if(p->grpprev)
p->grpprev->grpnext = p->grpnext;
else
g->head = p->grpnext;
if(p->grpnext)
p->grpnext->grpprev = p->grpprev;
else
g->tail = p->grpprev;
p->grpprev = p->grpnext = nil;
p->group = nil;
if(g->head == nil){
/* move up, giving subgroups of groups with no Progs to their parents */
do{
if((pg = g->parent) != nil){
pg = g->parent;
for(l = &pg->child; *l != nil && *l != g; l = &(*l)->sib)
;
*l = g->sib;
}
/* put subgroups in new parent group */
while((cg = g->child) != nil){
g->child = cg->sib;
cg->parent = pg;
if(pg != nil){
cg->sib = pg->child;
pg->child = cg;
}
}
free(g);
}while((g = pg) != nil && g->head == nil);
}
return g;
}
void
printgrp(Prog *p, char *v)
{
Progs *g;
Prog *q;
g = p->group;
print("%s pid %d grp %d pgrp %d: [pid", v, p->pid, g->id, g->parent!=nil?g->parent->id:0);
for(q = g->head; q != nil; q = q->grpnext)
print(" %d", q->pid);
print(" subgrp");
for(g = g->child; g != nil; g = g->sib)
print(" %d", g->id);
print("]\n");
}
int
killgrp(Prog *p, char *msg)
{
int i, npid, *pids;
Prog *f;
Progs *g;
/* interpreter has been acquired */
g = p->group;
if(g == nil || g->head == nil)
return 0;
while(g->flags & Pkilled){
release();
acquire();
}
npid = 0;
for(f = g->head; f != nil; f = f->grpnext)
if(f->group != g)
panic("killgrp");
else
npid++;
/* use pids not Prog* because state can change during killprog (eg, in delprog) */
pids = malloc(npid*sizeof(int));
if(pids == nil)
error(Enomem);
npid = 0;
for(f = g->head; f != nil; f = f->grpnext)
pids[npid++] = f->pid;
g->flags |= Pkilled;
if(waserror()) {
g->flags &= ~Pkilled;
free(pids);
nexterror();
}
for(i = 0; i < npid; i++) {
f = progpid(pids[i]);
if(f != nil && f != currun())
killprog(f, msg);
}
poperror();
g->flags &= ~Pkilled;
free(pids);
return 1;
}
char changup[] = "channel hangup";
void
killcomm(Progq **q)
{
Prog *p;
Progq *f;
for (f = *q; f != nil; f = *q) {
*q = f->next;
p = f->prog;
free(f);
if(p == nil)
return;
p->ptr = nil;
switch(p->state) {
case Prelease:
swiprog(p);
break;
case Psend:
case Precv:
p->kill = changup;
addrun(p);
break;
case Palt:
altgone(p);
break;
}
}
}
void
addprog(Proc *p)
{
Prog *n;
n = malloc(sizeof(Prog));
if(n == nil)
panic("no memory");
p->prog = n;
n->osenv = p->env;
}
static void
cwakeme(Prog *p)
{
Osenv *o;
p->addrun = nil;
o = p->osenv;
Wakeup(o->rend);
}
static int
cdone(void *vp)
{
Prog *p = vp;
return p->addrun == nil || p->kill != nil;
}
void
cblock(Prog *p)
{
Osenv *o;
p->addrun = cwakeme;
o = p->osenv;
o->rend = &up->sleep;
release();
/*
* To allow cdone(p) safely after release,
* p must be currun before the release.
* Exits in the error case with the vm acquired.
*/
if(waserror()) {
acquire();
p->addrun = nil;
nexterror();
}
Sleep(o->rend, cdone, p);
if (p->kill != nil)
error(Eintr);
poperror();
acquire();
}
void
addrun(Prog *p)
{
if(p->addrun != 0) {
p->addrun(p);
return;
}
p->state = Pready;
p->link = nil;
if(isched.runhd == nil)
isched.runhd = p;
else
isched.runtl->link = p;
isched.runtl = p;
}
Prog*
delrun(int state)
{
Prog *p;
p = isched.runhd;
p->state = state;
isched.runhd = p->link;
if(p->link == nil)
isched.runtl = nil;
return p;
}
void
delrunq(Prog *p)
{
Prog *prev, *f;
prev = nil;
for(f = isched.runhd; f; f = f->link) {
if(f == p)
break;
prev = f;
}
if(f == nil)
return;
if(prev == nil)
isched.runhd = p->link;
else
prev->link = p->link;
if(p == isched.runtl)
isched.runtl = prev;
}
Prog*
delruntail(int state)
{
Prog *p;
p = isched.runtl;
delrunq(p);
p->state = state;
return p;
}
Prog*
currun(void)
{
return isched.runhd;
}
Prog*
schedmod(Module *m)
{
Heap *h;
Type *t;
Prog *p;
Modlink *ml;
Frame f, *fp;
ml = mklinkmod(m, 0);
if(m->origmp != H && m->ntype > 0) {
t = m->type[0];
h = nheap(t->size);
h->t = t;
t->ref++;
ml->MP = H2D(uchar*, h);
newmp(ml->MP, m->origmp, t);
}
p = newprog(nil, ml);
h = D2H(ml);
h->ref--;
p->R.PC = m->entry;
fp = &f;
R.s = &fp;
f.t = m->entryt;
newstack(p);
initmem(m->entryt, p->R.FP);
return p;
}
/*
static char*
m(Prog *p)
{
if(p)
if(p->R.M)
if(p->R.M->m)
return p->R.M->m->name;
return "nil";
}
*/
void
acquire(void)
{
int empty;
Prog *p;
lock(&isched.l);
if(isched.idle) {
isched.idle = 0;
unlock(&isched.l);
}
else {
up->qnext = nil;
if(isched.vmq != nil){
empty = 0;
isched.vmqt->qnext = up;
}else{
isched.vmq = up;
empty = 1;
}
isched.vmqt = up;
unlock(&isched.l);
strcpy(up->text, "acquire");
if(empty)
Wakeup(&isched.irend);
osblock();
}
if(up->type == Interp) {
p = up->iprog;
up->iprog = nil;
irestore(p);
}
else
p = up->prog;
p->state = Pready;
p->link = isched.runhd;
isched.runhd = p;
if(p->link == nil)
isched.runtl = p;
strcpy(up->text, "dis");
}
void
release(void)
{
Proc *p, **pq;
int f;
if(up->type == Interp)
up->iprog = isave();
else
delrun(Prelease);
lock(&isched.l);
if(*(pq = &isched.vmq) == nil && *(pq = &isched.idlevmq) == nil) {
isched.idle = 1;
f = isched.creating;
isched.creating = 1;
unlock(&isched.l);
if(f == 0)
kproc("dis", vmachine, nil, 0);
return;
}
p = *pq;
*pq = p->qnext;
unlock(&isched.l);
osready(p); /* wake up thread to run VM */
strcpy(up->text, "released");
}
void
iyield(void)
{
Proc *p;
lock(&isched.l);
p = isched.vmq;
if(p == nil) {
unlock(&isched.l);
return;
}
isched.nyield++;
isched.vmq = p->qnext;
if(up->iprog != nil)
panic("iyield but iprog, type %d", up->type);
if(up->type != Interp){
static int once;
if(!once++)
print("tell charles: #%p->type==%d\n", up, up->type);
}
up->qnext = isched.idlevmq;
isched.idlevmq = up;
unlock(&isched.l);
osready(p); /* wake up acquiring kproc */
strcpy(up->text, "yield");
osblock(); /* sleep */
strcpy(up->text, "dis");
}
void
startup(void)
{
up->type = Interp;
up->iprog = nil;
lock(&isched.l);
isched.creating = 0;
if(isched.idle) {
isched.idle = 0;
unlock(&isched.l);
return;
}
up->qnext = isched.idlevmq;
isched.idlevmq = up;
unlock(&isched.l);
osblock();
}
void
progexit(void)
{
Prog *r;
Module *m;
int broken;
char *estr, msg[ERRMAX+2*KNAMELEN];
estr = up->env->errstr;
broken = 0;
if(estr[0] != '\0' && strcmp(estr, Eintr) != 0 && strncmp(estr, "fail:", 5) != 0)
broken = 1;
r = up->iprog;
if(r != nil)
acquire();
else
r = currun();
if(*estr == '\0' && r->flags & Pkilled)
estr = "killed";
m = R.M->m;
if(broken){
if(cflag){ /* only works on Plan9 for now */
char *pc = strstr(estr, "pc=");
if(pc != nil)
R.PC = r->R.PC = (Inst*)strtol(pc+3, nil, 0); /* for debugging */
}
print("[%s] Broken: \"%s\"\n", m->name, estr);
}
snprint(msg, sizeof(msg), "%d \"%s\":%s", r->pid, m->name, estr);
if(up->env->debug != nil) {
dbgexit(r, broken, estr);
broken = 1;
/* must force it to break if in debug */
}else if(broken && (!keepbroken || strncmp(estr, "out of memory", 13)==0 || memusehigh()))
broken = 0; /* don't want them or short of memory */
if(broken){
tellsomeone(r, msg);
r = isave();
r->state = Pbroken;
return;
}
gclock();
destroystack(&R);
delprog(r, msg);
gcunlock();
if(isched.head == nil)
cleanexit(0);
}
void
disfault(void *reg, char *msg)
{
Prog *p;
USED(reg);
if(strncmp(msg, Eintr, 6) == 0)
exits(0);
if(up == nil) {
print("EMU: faults: %s\n", msg);
cleanexit(0);
}
if(up->type != Interp) {
print("SYS: process %s faults: %s\n", up->text, msg);
cleanexit(0);
}
if(up->iprog != nil)
acquire();
p = currun();
if(p == nil)
panic("Interp faults with no dis prog");
/* cause an exception in the dis prog. As for error(), but Plan 9 needs reg*/
kstrcpy(up->env->errstr, msg, ERRMAX);
oslongjmp(reg, up->estack[--up->nerr], 1);
}
void
vmachine(void *a)
{
Prog *r;
Osenv *o;
int cycles;
static int gccounter;
USED(a);
startup();
while(waserror()) {
if(up->iprog != nil)
acquire();
if(handler(up->env->errstr) == 0) {
propex(currun(), up->env->errstr);
progexit();
}
up->env = &up->defenv;
}
cycles = 0;
for(;;) {
if(tready(nil) == 0) {
execatidle();
strcpy(up->text, "idle");
Sleep(&isched.irend, tready, 0);
strcpy(up->text, "dis");
}
if(isched.vmq != nil && (isched.runhd == nil || ++cycles > 2)){
iyield();
cycles = 0;
}
r = isched.runhd;
if(r != nil) {
o = r->osenv;
up->env = o;
FPrestore(&o->fpu);
r->xec(r);
FPsave(&o->fpu);
if(isched.runhd != nil)
if(r == isched.runhd)
if(isched.runhd != isched.runtl) {
isched.runhd = r->link;
r->link = nil;
isched.runtl->link = r;
isched.runtl = r;
}
up->env = &up->defenv;
}
if(isched.runhd != nil)
if((++gccounter&0xFF) == 0 || memlow()) {
gcbusy++;
up->type = BusyGC;
pushrun(up->prog);
rungc(isched.head);
up->type = Interp;
delrunq(up->prog);
}
}
}
void
disinit(void *a)
{
Prog *p;
Osenv *o;
Module *root;
char *initmod = a;
if(waserror())
panic("disinit error: %r");
if(vflag)
print("Initial Dis: \"%s\"\n", initmod);
fmtinstall('D', Dconv);
FPinit();
FPsave(&up->env->fpu);
opinit();
modinit();
excinit();
root = load(initmod);
if(root == 0) {
kgerrstr(up->genbuf, sizeof up->genbuf);
panic("loading \"%s\": %s", initmod, up->genbuf);
}
p = schedmod(root);
memmove(p->osenv, up->env, sizeof(Osenv));
o = p->osenv;
incref(&o->pgrp->r);
incref(&o->fgrp->r);
incref(&o->egrp->r);
if(o->sigs != nil)
incref(&o->sigs->r);
o->user = nil;
kstrdup(&o->user, up->env->user);
o->errstr = o->errbuf0;
o->syserrstr = o->errbuf1;
isched.idle = 1;
poperror();
vmachine(nil);
}
void
pushrun(Prog *p)
{
if(p->addrun != nil)
panic("pushrun addrun");
p->state = Pready;
p->link = isched.runhd;
isched.runhd = p;
if(p->link == nil)
isched.runtl = p;
}