void getac(int* ac,int pos){
int acl[15],acr[15];
int i;
if(tree[pos]=='*'){
for(i=0;i<n;i++){
if(i>=(n-m))
ac[i]=1;
else
ac[i]=0;
}
}
else if( pos < ((int)pow(2,level)-1) ){
getac(acl,2*pos+1);
getac(acr,2*pos+2);
getaclist(ac,acl,acr,tree[pos]);
}
else{
for(i=0;i<n;i++){
if(i>=(n-m)){
acl[i]=1;
acr[i]=1;
}
else{
acl[i]=0;
acr[i]=0;
}
}
getaclist(ac,acl,acr,tree[pos]);
}
return;
}
/*
* All traps come here. It is slower to have all traps call trap()
* rather than directly vectoring the handler. However, this avoids a
* lot of code duplication and possible bugs. The only exception is
* VectorSYSCALL.
* Trap is called with interrupts disabled via interrupt-gates.
*/
void
trap(Ureg* ureg)
{
int clockintr, vno, user;
// cache the previous vno to see what might be causing
// trouble
static int lastvno;
vno = ureg->type;
uint64_t gsbase = rdmsr(GSbase);
//if (sce > scx) iprint("====================");
if (vno == 8) {
iprint("Lstar is %p\n", (void *)rdmsr(Lstar));
iprint("GSbase is %p\n", (void *)gsbase);
iprint("ire %d irx %d sce %d scx %d lastvno %d\n",
ire, irx, sce, scx, lastvno);
iprint("irxe %d \n",
irxe);
die("8");
}
lastvno = vno;
if (gsbase < 1ULL<<63)
die("bogus gsbase");
Mach *m = machp();
char buf[ERRMAX];
Vctl *ctl, *v;
if (0 && m && m->externup && m->externup->pid == 6) {
//iprint("type %x\n", ureg->type);
if (ureg->type != 0x49)
die("6\n");
}
m->perf.intrts = perfticks();
user = userureg(ureg);
if(user && (m->nixtype == NIXTC)){
m->externup->dbgreg = ureg;
cycles(&m->externup->kentry);
}
clockintr = 0;
//_pmcupdate(m);
if(ctl = vctl[vno]){
if(ctl->isintr){
m->intr++;
if(vno >= VectorPIC && vno != VectorSYSCALL)
m->lastintr = ctl->irq;
}else
if(m->externup)
m->externup->nqtrap++;
if(ctl->isr)
ctl->isr(vno);
for(v = ctl; v != nil; v = v->next){
if(v->f)
v->f(ureg, v->a);
}
if(ctl->eoi)
ctl->eoi(vno);
intrtime(vno);
if(ctl->isintr){
if(ctl->irq == IrqCLOCK || ctl->irq == IrqTIMER)
clockintr = 1;
if(m->externup && !clockintr)
preempted();
}
}
else if(vno < nelem(excname) && user){
spllo();
snprint(buf, sizeof buf, "sys: trap: %s", excname[vno]);
postnote(m->externup, 1, buf, NDebug);
}
else if(vno >= VectorPIC && vno != VectorSYSCALL){
/*
* An unknown interrupt.
* Check for a default IRQ7. This can happen when
* the IRQ input goes away before the acknowledge.
* In this case, a 'default IRQ7' is generated, but
* the corresponding bit in the ISR isn't set.
* In fact, just ignore all such interrupts.
*/
/* clear the interrupt */
i8259isr(vno);
iprint("cpu%d: spurious interrupt %d, last %d\n",
m->machno, vno, m->lastintr);
intrtime(vno);
if(user)
kexit(ureg);
return;
}
else{
if(vno == VectorNMI){
nmienable();
if(m->machno != 0){
iprint("cpu%d: PC %#llux\n",
m->machno, ureg->ip);
for(;;);
}
}
dumpregs(ureg);
if(!user){
ureg->sp = PTR2UINT(&ureg->sp);
dumpstackwithureg(ureg);
}
if(vno < nelem(excname))
panic("%s", excname[vno]);
panic("unknown trap/intr: %d\n", vno);
}
splhi();
/* delaysched set because we held a lock or because our quantum ended */
if(m->externup && m->externup->delaysched && clockintr){
if(0)
if(user && m->externup->ac == nil && m->externup->nqtrap == 0 && m->externup->nqsyscall == 0){
if(!waserror()){
m->externup->ac = getac(m->externup, -1);
poperror();
runacore();
return;
}
}
sched();
splhi();
}
if(user){
if(m->externup && m->externup->procctl || m->externup->nnote)
notify(ureg);
kexit(ureg);
}
}
void
kforkexecac(Proc *p, int core, char *ufile, char **argv)
{
Mach *m = machp();
Khdr hdr;
Tos *tos;
Chan *chan;
int argc, i, n, sno;
char *a, *elem, *file, *args;
int32_t hdrsz, magic, textsz, datasz, bsssz;
uintptr_t textlim, datalim, bsslim, entry, tbase, tsize, dbase, dsize, bbase, bsize, sbase, ssize, stack;
Mach *mp;
// static Pgrp *kpgrp;
panic("kexec not done\n");
// XXX: since this is kernel code we can't do attachimage,
// we should be reading the file into kernel memory.
// this only matters if we are using ufile.
// YYY: look at dev reboot for help.
file = nil;
elem = nil;
chan = nil;
mp = nil;
USED(chan);
if(waserror()){
DBG("kforkexecac: failing: %s\n", m->externup->errstr);
if(file)
free(file);
if(elem)
free(elem);
if(chan)
cclose(chan);
if(core > 0 && mp != nil)
mp->proc = nil;
if(core != 0)
p->ac = nil;
nexterror();
}
if(core != 0)
p->ac = getac(p, core);
argc = 0;
if(ufile != nil){
panic("ufile not implemented yet");
file = validnamedup(ufile, 1);
DBG("kforkexecac: up %#p file %s\n", m->externup, file);
chan = namec(file, Aopen, OEXEC, 0);
kstrdup(&elem, m->externup->genbuf);
hdrsz = chan->dev->read(chan, &hdr, sizeof(Khdr), 0);
DBG("wrote ufile\n");
if(hdrsz < 2)
error(Ebadexec);
}else{
/* somebody already wrote in our text segment */
for(sno = 0; sno < NSEG; sno++)
if(p->seg[sno] != nil)
if((p->seg[sno]->type & SG_EXEC) != 0)
break;
if(sno == NSEG)
error("kforkexecac: no text segment!");
hdr = *(Khdr*)p->seg[sno]->base;
hdrsz = sizeof(Khdr);
}
// p = (char*)&hdr;
magic = l2be(hdr.magic);
DBG("badexec3\n");
if(hdrsz != sizeof(Khdr) || magic != AOUT_MAGIC)
error(Ebadexec);
if(magic & HDR_MAGIC){
entry = vl2be(hdr.hdr[0]);
hdrsz = sizeof(Khdr);
}
else{
entry = l2be(hdr.entry);
hdrsz = sizeof(Exec);
}
textsz = l2be(hdr.text);
datasz = l2be(hdr.data);
bsssz = l2be(hdr.bss);
panic("aki broke it before it even got working.");
/* TODO(aki): figure out what to do with this.
tbase = p->seg[TSEG]->base;
tsize = tbase - p->seg[TSEG]->top;
dbase = p->seg[DSEG]->base;
dsize = dbase - p->seg[DSEG]->top;
bbase = p->seg[BSEG]->base;
bsize = bbase - p->seg[BSEG]->top;
sbase = p->seg[SSEG]->base;
ssize = sbase - p->seg[SSEG]->top;
*/
// XXX: we are no longer contiguous.
textlim = ROUNDUP(hdrsz+textsz, BIGPGSZ);
// XXX: we are going to be at least two pages here.
datalim = BIGPGROUND(datasz);
bsslim = BIGPGROUND(datalim+bsssz);
// XXX: this is pretty fragile
memmove((void*)dbase, (void*)(entry+textsz), datasz);
DBG("writing data dbase %#p tbase %#p textsz %ld datasz %ld\n", dbase, tbase, textsz, datasz);
// memmove((void*)dbase, (void*)"testing data", 13);
/*
* Check the binary header for consistency,
* e.g. the entry point is within the text segment and
* the segments don't overlap each other.
*/
// XXX: max instruction size on amd64 is 15 bytes provide a check for consistency.
DBG("kexec: entry %#p tbase %#p hdrsz %ld textsz %ld\n", entry, tbase, hdrsz, textsz);
if(entry < tbase+hdrsz || entry >= tbase+hdrsz+textsz)
error(Ebadexec);
// XXX: what about the kernel stack we are making here?
DBG("kexec: testing if sizes overflow limits\n");
if(textsz >= textlim || datasz > datalim || bsssz > bsslim)
error(Ebadexec);
DBG("kexec: do the top of the segments overflow limits?\n");
if(textlim >= tbase+tsize || datalim >= dbase+dsize || bsslim >= bbase+bsize)
error(Ebadexec);
DBG("kexec: is bss below data?\n");
if(bsslim < datalim)
error(Ebadexec);
/*
Interesting thought, the previously allocated segments for
data and text are shared and constant. The BSS and the stack
are not. What you really want is the ability to make an
executable text and data and then create child executables on
top of that. This will lower external fragmentation and allow
a bunch of communicating shared memory processes (ie. go) in
kernel space.
Fundamentally this means that the allocation of the text and
the data should be separate from the bss and the stack. This
will require that you change the linkers as well to allow the
separation of data and bss sections.
*/
/*
* Stack is a pointer into the temporary stack
* segment, and will move as items are pushed.
*/
// need to work something out here with the stack.
stack = sbase+ssize-sizeof(Tos);
/*
* XXX: When we are linking this how do we set the tos? We will need to change trap right?
*/
tos = (Tos*)stack;
tos->cyclefreq = m->cyclefreq;
cycles((uint64_t*)&tos->pcycles);
tos->pcycles = -tos->pcycles;
tos->kcycles = tos->pcycles;
tos->clock = 0;
DBG("kexec: argument processing\n");
if(0)
for(i = 0;; i++, argv++){
a = *(char**)validaddr(argv, sizeof(char**), 0);
if(a == nil)
break;
a = validaddr(a, 1, 0);
n = ((char*)vmemchr(a, 0, 0x7fffffff) - a) + 1;
if(argc > 0 && i == 0)
continue;
stack -= n;
if(stack < sbase+ssize-4096)
error(Enovmem);
args = UINT2PTR(stack);
memmove(args, a, n);
args[n-1] = 0;
argc++;
}
// DBG("kexec: ensuring we have argc\n");
if(0)
if(argc < 1)
error(Ebadexec);
a = args = UINT2PTR(stack);
stack = sysexecstack(stack, argc);
// XXX: look through math on this. look at ../../9/port/ exec.c
// YYY: this looks like a Jimism for 9k.
// DBG("kexec: ensuring the stack \n");
if(0)
if(stack-(argc+1)*sizeof(char**)-BIGPGSZ < sbase+ssize-4096)
error(Ebadexec);
argv = (char**)stack;
*--argv = nil;
// XXX: replace USTKTOP with a new variable representing the top of stack.
if(0)
for(i = 0; i < argc; i++){
*--argv = args + (USTKTOP-sbase+ssize);
args += strlen(args) + 1;
}
DBG("argsing\n");
n = args - a;
if(0)
if(n <= 0)
error(Egreg);
if(n > 128)
n = 128;
DBG("kexec: allocating args\n");
// XXX: hangs in smalloc, not sure why.
// args = smalloc(n);
// if(waserror()){
// DBG("erroring\n");
// free(args);
// nexterror();
// }
// DBG("kexec: moving args\n");
// memmove(args, a, n);
// if(0)
// while(n > 0 && (args[n-1] & 0xc0) == 0x80)
// n--;
// args[n-1] = '\0';
kstrdup(&p->text, "kexecproc");
p->args = nil;
//elem;
// elem = nil;
// p->args = args;
// p->nargs = n;
poperror(); /* p (m->externup->args) */
/*
qlock(&p->debug);
sysprocsetup(p);
qunlock(&p->debug);
*/
// why is this sched and not ureg?
p->sched.pc = entry;
// the real question here is how do you set up the stack?
p->sched.sp = PTR2UINT(stack-BY2SE);
p->sched.sp = STACKALIGN(p->sched.sp);
// XXX: what does it imply if you have a kproc that runs on an ac?
if(core > 0){
DBG("kexec: coring %d\n", core);
mp = p->ac;
mp->icc->flushtlb = 1;
mp->icc->rc = ICCOK;
DBG("kexec: exotic proc on cpu%d\n", mp->machno);
qlock(&p->debug);
if(waserror()){
DBG("kexec: had error");
qunlock(&p->debug);
nexterror();
}
p->nicc++;
p->state = Exotic;
p->psstate = 0;
DBG("kexec: unlocking");
qunlock(&p->debug);
poperror();
mfence();
mp->icc->fn = (void*)entry;
sched();
}else{
DBG("kexec: readying\n");
ready(p);
p->newtlb = 1;
mmuflush();
}
DBG("kforkexecac up %#p done\n"
"textsz %lx datasz %lx bsssz %lx hdrsz %lx\n"
"textlim %ullx datalim %ullx bsslim %ullx\n", m->externup,
textsz, datasz, bsssz, hdrsz, textlim, datalim, bsslim);
}
int main(){
int i,j;
int ac[15];
char buf[1000];
int st;
char c;
int a,b;
int num=0;
int check;
while(1){
num++;
scanf("%d %d %d",&n,&m,&k);
if(!m&&!n&&!k)
break;
if(num>1)
printf("\n");
printf("NTA%d:\n",num);
gets(buf);
for(i=0;i<n;i++){
for(j=0;j<k;j++){
tr[i][j] = createlist();
gets(buf);
if(buf[0]){
while(1){
sscanf(buf,"%d %d",&a,&b);
do_buf(buf);
tr[i][j]=addlist(tr[i][j],a,b);
if(buf[0]){
break;
return 0;
}
}
}
}
}
while(1){
scanf("%d",&level);
if(level<0)
break;
for(i=0;i<((int)pow(2,level+1)-1);i++){
while(1){
scanf("%c",&c);
if('a'<=c && c<='z' || c=='*'){
tree[i]=c;
break;
}
}
}
getac(ac,0);
check=0;
for(i=0;i<n;i++){
if(ac[i]){
printf("Valid\n");
check=1;
break;
}
}
if(!check)
printf("Invalid\n");
}
for(i=0;i<n;i++)
for(j=0;j<k;j++)
free(tr[i][j]);
}
return 0;
}
/*
* All traps come here. It is slower to have all traps call trap()
* rather than directly vectoring the handler. However, this avoids a
* lot of code duplication and possible bugs. The only exception is
* VectorSYSCALL.
* Trap is called with interrupts disabled via interrupt-gates.
*/
void
trap(Ureg* ureg)
{
int clockintr, vno, user;
// cache the previous vno to see what might be causing
// trouble
vno = ureg->type;
uint64_t gsbase = rdmsr(GSbase);
//if (sce > scx) iprint("====================");
lastvno = vno;
if (gsbase < 1ULL<<63)
die("bogus gsbase");
Proc *up = externup();
char buf[ERRMAX];
Vctl *ctl, *v;
machp()->perf.intrts = perfticks();
user = userureg(ureg);
if(user && (machp()->NIX.nixtype == NIXTC)){
up->dbgreg = ureg;
cycles(&up->kentry);
}
clockintr = 0;
//_pmcupdate(machp());
if((ctl = vctl[vno]) != nil){
if(ctl->isintr){
machp()->intr++;
if(vno >= VectorPIC && vno != VectorSYSCALL)
machp()->lastintr = ctl->Vkey.irq;
}else
if(up)
up->nqtrap++;
if(ctl->isr){
ctl->isr(vno);
if(islo())print("trap %d: isr %p enabled interrupts\n", vno, ctl->isr);
}
for(v = ctl; v != nil; v = v->next){
if(v->f){
v->f(ureg, v->a);
if(islo())print("trap %d: ctlf %p enabled interrupts\n", vno, v->f);
}
}
if(ctl->eoi){
ctl->eoi(vno);
if(islo())print("trap %d: eoi %p enabled interrupts\n", vno, ctl->eoi);
}
intrtime(vno);
if(ctl->isintr){
if(ctl->Vkey.irq == IrqCLOCK || ctl->Vkey.irq == IrqTIMER)
clockintr = 1;
if (ctl->Vkey.irq == IrqTIMER)
oprof_alarm_handler(ureg);
if(up && !clockintr)
preempted();
}
}
else if(vno < nelem(excname) && user){
spllo();
snprint(buf, sizeof buf, "sys: trap: %s", excname[vno]);
postnote(up, 1, buf, NDebug);
}
else if(vno >= VectorPIC && vno != VectorSYSCALL){
/*
* An unknown interrupt.
* Check for a default IRQ7. This can happen when
* the IRQ input goes away before the acknowledge.
* In this case, a 'default IRQ7' is generated, but
* the corresponding bit in the ISR isn't set.
* In fact, just ignore all such interrupts.
*/
/* clear the interrupt */
i8259isr(vno);
iprint("cpu%d: spurious interrupt %d, last %d\n",
machp()->machno, vno, machp()->lastintr);
intrtime(vno);
if(user)
kexit(ureg);
return;
}
else{
if(vno == VectorNMI){
nmienable();
if(machp()->machno != 0){
iprint("cpu%d: PC %#llx\n",
machp()->machno, ureg->ip);
for(;;);
}
}
dumpregs(ureg);
if(!user){
ureg->sp = PTR2UINT(&ureg->sp);
dumpstackwithureg(ureg);
}
if(vno < nelem(excname))
panic("%s", excname[vno]);
panic("unknown trap/intr: %d\n", vno);
}
splhi();
/* delaysched set because we held a lock or because our quantum ended */
if(up && up->delaysched && clockintr){
if(0)
if(user && up->ac == nil && up->nqtrap == 0 && up->nqsyscall == 0){
if(!waserror()){
up->ac = getac(up, -1);
poperror();
runacore();
return;
}
}
sched();
splhi();
}
if(user){
if(up != nil && (up->procctl || up->nnote))
notify(ureg);
kexit(ureg);
}
}
