/* it should be unsigned. FIXME */
void
syscall(int badscallnr, Ureg* ureg)
{
unsigned int scallnr = (unsigned int) badscallnr;
char *e;
uintptr sp;
int s;
vlong startns, stopns;
Ar0 ar0;
static Ar0 zar0;
if(!userureg(ureg))
panic("syscall: cs %#llux\n", ureg->cs);
cycles(&up->kentry);
m->syscall++;
up->nsyscall++;
up->nqsyscall++;
up->insyscall = 1;
up->pc = ureg->ip;
up->dbgreg = ureg;
sp = ureg->sp;
startns = 0;
if(up->procctl == Proc_tracesyscall){
/*
* Redundant validaddr. Do we care?
* Tracing syscalls is not exactly a fast path...
* Beware, validaddr currently does a pexit rather
* than an error if there's a problem; that might
* change in the future.
*/
if(sp < (USTKTOP-BIGPGSZ) || sp > (USTKTOP-sizeof(up->arg)-BY2SE))
validaddr(UINT2PTR(sp), sizeof(up->arg)+BY2SE, 0);
syscallfmt(scallnr, (va_list)(sp+BY2SE));
up->procctl = Proc_stopme;
procctl(up);
if(up->syscalltrace)
free(up->syscalltrace);
up->syscalltrace = nil;
startns = todget(nil);
}
up->scallnr = scallnr;
if(scallnr == RFORK)
fpusysrfork(ureg);
spllo();
sp = ureg->sp;
up->nerrlab = 0;
ar0 = zar0;
if(!waserror()){
if(scallnr >= nsyscall || systab[scallnr].f == nil){
pprint("bad sys call number %d pc %#llux\n",
scallnr, ureg->ip);
postnote(up, 1, "sys: bad sys call", NDebug);
error(Ebadarg);
}
if(sp < (USTKTOP-BIGPGSZ) || sp > (USTKTOP-sizeof(up->arg)-BY2SE))
validaddr(UINT2PTR(sp), sizeof(up->arg)+BY2SE, 0);
memmove(up->arg, UINT2PTR(sp+BY2SE), sizeof(up->arg));
up->psstate = systab[scallnr].n;
systab[scallnr].f(&ar0, (va_list)up->arg);
if(scallnr == SYSR1){
/*
* BUG: must go when ron binaries go.
* NIX: Returning from execac().
* This means that the process is back to the
* time sharing core. However, the process did
* already return from the system call, when dispatching
* the user code to the AC. The only thing left is to
* return. The user registers should be ok, because
* up->dbgreg has been the user context for the process.
*/
return;
}
poperror();
}
else{
/* failure: save the error buffer for errstr */
e = up->syserrstr;
up->syserrstr = up->errstr;
up->errstr = e;
if(DBGFLG && up->pid == 1)
iprint("%s: syscall %s error %s\n",
up->text, systab[scallnr].n, up->syserrstr);
ar0 = systab[scallnr].r;
}
/*
* NIX: for the execac() syscall, what follows is done within
* the system call, because it never returns.
* See acore.c:/^retfromsyscall
*/
noerrorsleft();
/*
* Put return value in frame.
*/
ureg->ax = ar0.p;
if(up->procctl == Proc_tracesyscall){
stopns = todget(nil);
up->procctl = Proc_stopme;
sysretfmt(scallnr, (va_list)(sp+BY2SE), &ar0, startns, stopns);
s = splhi();
procctl(up);
splx(s);
if(up->syscalltrace)
free(up->syscalltrace);
up->syscalltrace = nil;
}else if(up->procctl == Proc_totc || up->procctl == Proc_toac)
procctl(up);
up->insyscall = 0;
up->psstate = 0;
if(scallnr == NOTED)
noted(ureg, *(uintptr*)(sp+BY2SE));
splhi();
if(scallnr != RFORK && (up->procctl || up->nnote))
notify(ureg);
/* if we delayed sched because we held a lock, sched now */
if(up->delaysched){
sched();
splhi();
}
kexit(ureg);
}
/*
* Move the current process to an application core.
* This is performed at the end of execac(), and
* we pretend to be returning to user-space, but instead we
* dispatch the process to another core.
* 1. We do the final bookkeeping that syscall() would do after
* a return from sysexec(), because we are not returning.
* 2. We dispatch the process to an AC using an ICC.
*
* This function won't return unless the process is reclaimed back
* to the time-sharing core, and is the handler for the process
* to deal with traps and system calls until the process dies.
*
* Remember that this function is the "line" between user and kernel
* space, it's not expected to raise|handle any error.
*
* We install a safety error label, just in case we raise errors,
* which we shouldn't. (noerrorsleft knows that for exotic processes
* there is an error label pushed by us).
*/
void
runacore(void)
{
Proc *up = externup();
Ureg *ureg;
void (*fn)(void);
int rc, flush, s;
char *n;
uint64_t t1;
if(waserror())
panic("runacore: error: %s\n", up->errstr);
ureg = up->dbgreg;
fakeretfromsyscall(ureg);
fpusysrfork(ureg);
procpriority(up, PriKproc, 1);
rc = runac(up->ac, actouser, 1, nil, 0);
procpriority(up, PriNormal, 0);
for(;;){
t1 = fastticks(nil);
flush = 0;
fn = nil;
switch(rc){
case ICCTRAP:
s = splhi();
machp()->MMU.cr2 = up->ac->MMU.cr2;
DBG("runacore: trap %llu cr2 %#llx ureg %#p\n",
ureg->type, machp()->MMU.cr2, ureg);
switch(ureg->type){
case IdtIPI:
if(up->procctl || up->nnote)
notify(up->dbgreg);
if(up->ac == nil)
goto ToTC;
kexit(up->dbgreg);
break;
case IdtNM:
case IdtMF:
case IdtXF:
/* these are handled in the AC;
* If we get here, they left in m->NIX.icc->data
* a note to be posted to the process.
* Post it, and make the vector a NOP.
*/
n = up->ac->NIX.icc->note;
if(n != nil)
postnote(up, 1, n, NDebug);
ureg->type = IdtIPI; /* NOP */
break;
default:
cr3put(machp()->MMU.pml4->pa);
if(0 && ureg->type == IdtPF){
print("before PF:\n");
print("AC:\n");
dumpptepg(4, up->ac->MMU.pml4->pa);
print("\n%s:\n", rolename[NIXTC]);
dumpptepg(4, machp()->MMU.pml4->pa);
}
trap(ureg);
}
splx(s);
flush = 1;
fn = actrapret;
break;
case ICCSYSCALL:
DBG("runacore: syscall ax %#llx ureg %#p\n",
ureg->ax, ureg);
cr3put(machp()->MMU.pml4->pa);
//syscall(ureg->ax, ureg);
flush = 1;
fn = acsysret;
if(0)
if(up->nqtrap > 2 || up->nsyscall > 1)
goto ToTC;
if(up->ac == nil)
goto ToTC;
break;
default:
panic("runacore: unexpected rc = %d", rc);
}
up->tctime += fastticks2us(fastticks(nil) - t1);
procpriority(up, PriExtra, 1);
rc = runac(up->ac, fn, flush, nil, 0);
procpriority(up, PriNormal, 0);
}
ToTC:
/*
* to procctl, then syscall, to
* be back in the TC
*/
DBG("runacore: up %#p: return\n", up);
}
void
syscall(Ureg* ureg)
{
char *e;
u32int s;
ulong sp;
long ret;
int i, scallnr;
vlong startns, stopns;
if(!userureg(ureg))
panic("syscall: from kernel: pc %#lux r14 %#lux psr %#lux",
ureg->pc, ureg->r14, ureg->psr);
cycles(&up->kentry);
m->syscall++;
up->insyscall = 1;
up->pc = ureg->pc;
up->dbgreg = ureg;
scallnr = ureg->r0;
up->scallnr = scallnr;
if(scallnr == RFORK)
fpusysrfork(ureg);
spllo();
sp = ureg->sp;
if(up->procctl == Proc_tracesyscall){
/*
* Redundant validaddr. Do we care?
* Tracing syscalls is not exactly a fast path...
* Beware, validaddr currently does a pexit rather
* than an error if there's a problem; that might
* change in the future.
*/
if(sp < (USTKTOP-BY2PG) || sp > (USTKTOP-sizeof(Sargs)-BY2WD))
validaddr(sp, sizeof(Sargs)+BY2WD, 0);
syscallfmt(scallnr, ureg->pc, (va_list)(sp+BY2WD));
up->procctl = Proc_stopme;
procctl(up);
if (up->syscalltrace)
free(up->syscalltrace);
up->syscalltrace = nil;
}
up->nerrlab = 0;
ret = -1;
startns = todget(nil);
if(!waserror()){
if(scallnr >= nsyscall){
pprint("bad sys call number %d pc %#lux\n",
scallnr, ureg->pc);
postnote(up, 1, "sys: bad sys call", NDebug);
error(Ebadarg);
}
if(sp < (USTKTOP-BY2PG) || sp > (USTKTOP-sizeof(Sargs)-BY2WD))
validaddr(sp, sizeof(Sargs)+BY2WD, 0);
up->s = *((Sargs*)(sp+BY2WD));
up->psstate = sysctab[scallnr];
/* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
ret = systab[scallnr](up->s.args);
poperror();
}else{
/* failure: save the error buffer for errstr */
e = up->syserrstr;
up->syserrstr = up->errstr;
up->errstr = e;
}
if(up->nerrlab){
print("bad errstack [%d]: %d extra\n", scallnr, up->nerrlab);
for(i = 0; i < NERR; i++)
print("sp=%#p pc=%#p\n",
up->errlab[i].sp, up->errlab[i].pc);
panic("error stack");
}
/*
* Put return value in frame. On the x86 the syscall is
* just another trap and the return value from syscall is
* ignored. On other machines the return value is put into
* the results register by caller of syscall.
*/
ureg->r0 = ret;
if(up->procctl == Proc_tracesyscall){
stopns = todget(nil);
up->procctl = Proc_stopme;
sysretfmt(scallnr, (va_list)(sp+BY2WD), ret, startns, stopns);
s = splhi();
procctl(up);
splx(s);
if(up->syscalltrace)
free(up->syscalltrace);
up->syscalltrace = nil;
}
up->insyscall = 0;
up->psstate = 0;
if(scallnr == NOTED)
noted(ureg, *(ulong*)(sp+BY2WD));
splhi();
if(scallnr != RFORK && (up->procctl || up->nnote))
notify(ureg);
/* if we delayed sched because we held a lock, sched now */
if(up->delaysched){
sched();
splhi();
}
kexit(ureg);
}
