void
sysfauth(Ar0* ar0, va_list list)
{
Chan *c, *ac;
char *aname;
int fd;
/*
* int fauth(int fd, char *aname);
*/
fd = va_arg(list, int);
aname = va_arg(list, char*);
aname = validaddr(aname, 1, 0);
aname = validnamedup(aname, 1);
if(waserror()){
free(aname);
nexterror();
}
c = fdtochan(fd, ORDWR, 0, 1);
if(waserror()){
cclose(c);
nexterror();
}
ac = mntauth(c, aname);
/* at this point ac is responsible for keeping c alive */
cclose(c);
poperror(); /* c */
free(aname);
poperror(); /* aname */
if(waserror()){
cclose(ac);
nexterror();
}
fd = newfd(ac);
if(fd < 0)
error(Enofd);
poperror(); /* ac */
/* always mark it close on exec */
ac->flag |= CCEXEC;
ar0->i = fd;
}
long
sysfauth(ulong *arg)
{
Chan *c, *ac;
char *aname;
int fd;
validaddr(arg[1], 1, 0);
aname = validnamedup((char*)arg[1], 1);
if(waserror()){
free(aname);
nexterror();
}
c = fdtochan(arg[0], ORDWR, 0, 1);
if(waserror()){
cclose(c);
nexterror();
}
ac = mntauth(c, aname);
/* at this point ac is responsible for keeping c alive */
poperror(); /* c */
cclose(c);
poperror(); /* aname */
free(aname);
if(waserror()){
cclose(ac);
nexterror();
}
fd = newfd(ac);
if(fd < 0)
error(Enofd);
poperror(); /* ac */
/* always mark it close on exec */
ac->flag |= CCEXEC;
return fd;
}
uintptr
syssegattach(va_list list)
{
ulong attr;
char *name;
uintptr va;
ulong len;
attr = va_arg(list, ulong);
name = va_arg(list, char*);
va = va_arg(list, uintptr);
len = va_arg(list, ulong);
validaddr((uintptr)name, 1, 0);
name = validnamedup(name, 1);
if(waserror()){
free(name);
nexterror();
}
va = segattach(up, attr, name, va, len);
free(name);
poperror();
return va;
}
/* if dc is non-zero, it means we're doing a mount and dc is the mount device to use. */
static int
bindmount(int dc, int fd, int afd, char* arg0, char* arg1, int flag, char* spec)
{
Proc *up = externup();
int i;
Dev *dev;
Chan *c0, *c1, *ac, *bc;
struct{
Chan *chan;
Chan *authchan;
char *spec;
int flags;
}bogus;
if((flag&~MMASK) || (flag&MORDER)==(MBEFORE|MAFTER))
error(Ebadarg);
bogus.flags = flag & MCACHE;
if(dc){
if (! checkdc(dc))
error(Ebadarg);
if(up->pgrp->noattach)
error(Enoattach);
ac = nil;
bc = fdtochan(fd, ORDWR, 0, 1);
if(waserror()) {
if(ac)
cclose(ac);
cclose(bc);
nexterror();
}
if(afd >= 0)
ac = fdtochan(afd, ORDWR, 0, 1);
bogus.chan = bc;
bogus.authchan = ac;
bogus.spec = validaddr(spec, 1, 0);
if(waserror())
error(Ebadspec);
spec = validnamedup(spec, 1);
poperror();
if(waserror()){
free(spec);
nexterror();
}
dev = devtabget(dc, 0); //XDYNX
if(waserror()){
//devtabdecr(dev);
nexterror();
}
c0 = dev->attach((char*)&bogus);
poperror();
//devtabdecr(dev);
poperror(); /* spec */
free(spec);
poperror(); /* ac bc */
if(ac)
cclose(ac);
cclose(bc);
}else{
bogus.spec = nil;
c0 = namec(validaddr(arg0, 1, 0), Abind, 0, 0);
}
if(waserror()){
cclose(c0);
nexterror();
}
c1 = namec(validaddr(arg1, 1, 0), Amount, 0, 0);
if(waserror()){
cclose(c1);
nexterror();
}
i = cmount(&c0, c1, flag, bogus.spec);
poperror();
cclose(c1);
poperror();
cclose(c0);
if(dc)
fdclose(fd, 0);
return i;
}
long
bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char* spec)
{
int ret;
Chan *c0, *c1, *ac, *bc;
struct{
Chan *chan;
Chan *authchan;
char *spec;
int flags;
}bogus;
if((flag&~MMASK) || (flag&MORDER)==(MBEFORE|MAFTER))
error(Ebadarg);
if(ismount){
validaddr((ulong)spec, 1, 0);
spec = validnamedup(spec, 1);
if(waserror()){
free(spec);
nexterror();
}
if(up->pgrp->noattach)
error(Enoattach);
ac = nil;
bc = fdtochan(fd, ORDWR, 0, 1);
if(waserror()) {
if(ac)
cclose(ac);
cclose(bc);
nexterror();
}
if(afd >= 0)
ac = fdtochan(afd, ORDWR, 0, 1);
bogus.flags = flag & MCACHE;
bogus.chan = bc;
bogus.authchan = ac;
bogus.spec = spec;
ret = devno('M', 0);
c0 = devtab[ret]->attach((char*)&bogus);
poperror(); /* ac bc */
if(ac)
cclose(ac);
cclose(bc);
}else{
spec = 0;
validaddr((ulong)arg0, 1, 0);
c0 = namec(arg0, Abind, 0, 0);
}
if(waserror()){
cclose(c0);
nexterror();
}
validaddr((ulong)arg1, 1, 0);
c1 = namec(arg1, Amount, 0, 0);
if(waserror()){
cclose(c1);
nexterror();
}
ret = cmount(&c0, c1, flag, spec);
poperror();
cclose(c1);
poperror();
cclose(c0);
if(ismount){
fdclose(fd, 0);
poperror();
free(spec);
}
return ret;
}
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);
}
uintptr
sysexec(va_list list)
{
Segment *s, *ts;
int i;
Chan *tc;
char **argv, **argp, **argp0;
char *a, *e, *charp, *args, *file, *file0;
char *progarg[sizeof(Exec)/2+1], *elem, progelem[64];
ulong magic, ssize, nargs, nbytes, n;
uintptr t, d, b, entry, bssend, text, data, bss, tstk, align;
int indir;
Exec exec;
char line[sizeof(Exec)];
Fgrp *f;
Image *img;
Tos *tos;
args = elem = nil;
file0 = va_arg(list, char*);
validaddr((uintptr)file0, 1, 0);
argp0 = va_arg(list, char**);
evenaddr((uintptr)argp0);
validaddr((uintptr)argp0, 2*BY2WD, 0);
if(*argp0 == nil)
error(Ebadarg);
file0 = validnamedup(file0, 1);
if(waserror()){
free(file0);
free(elem);
free(args);
/* Disaster after commit */
if(up->seg[SSEG] == nil)
pexit(up->errstr, 1);
s = up->seg[ESEG];
if(s != nil){
putseg(s);
up->seg[ESEG] = nil;
}
nexterror();
}
align = BY2PG;
indir = 0;
file = file0;
for(;;){
tc = namec(file, Aopen, OEXEC, 0);
if(waserror()){
cclose(tc);
nexterror();
}
if(!indir)
kstrdup(&elem, up->genbuf);
n = devtab[tc->type]->read(tc, &exec, sizeof(Exec), 0);
if(n <= 2)
error(Ebadexec);
magic = l2be(exec.magic);
if(n == sizeof(Exec) && (magic == AOUT_MAGIC)){
entry = l2be(exec.entry);
text = l2be(exec.text);
if(magic & HDR_MAGIC)
text += 8;
switch(magic){
case S_MAGIC: /* 2MB segment alignment for amd64 */
align = 0x200000;
break;
case V_MAGIC: /* 16K segment alignment for mips */
align = 0x4000;
break;
}
if(text >= (USTKTOP-USTKSIZE)-(UTZERO+sizeof(Exec))
|| entry < UTZERO+sizeof(Exec)
|| entry >= UTZERO+sizeof(Exec)+text)
error(Ebadexec);
break; /* for binary */
}
/*
* Process #! /bin/sh args ...
*/
memmove(line, &exec, n);
if(indir || line[0]!='#' || line[1]!='!')
error(Ebadexec);
n = shargs(line, n, progarg);
if(n < 1)
error(Ebadexec);
indir = 1;
/*
* First arg becomes complete file name
*/
progarg[n++] = file;
progarg[n] = nil;
argp0++;
file = progarg[0];
if(strlen(elem) >= sizeof progelem)
error(Ebadexec);
strcpy(progelem, elem);
progarg[0] = progelem;
poperror();
cclose(tc);
}
data = l2be(exec.data);
bss = l2be(exec.bss);
align--;
t = (UTZERO+sizeof(Exec)+text+align) & ~align;
align = BY2PG-1;
d = (t + data + align) & ~align;
bssend = t + data + bss;
b = (bssend + align) & ~align;
if(t >= (USTKTOP-USTKSIZE) || d >= (USTKTOP-USTKSIZE) || b >= (USTKTOP-USTKSIZE))
error(Ebadexec);
/*
* Args: pass 1: count
*/
nbytes = sizeof(Tos); /* hole for profiling clock at top of stack (and more) */
nargs = 0;
if(indir){
argp = progarg;
while(*argp != nil){
a = *argp++;
nbytes += strlen(a) + 1;
nargs++;
}
}
argp = argp0;
while(*argp != nil){
a = *argp++;
if(((uintptr)argp&(BY2PG-1)) < BY2WD)
validaddr((uintptr)argp, BY2WD, 0);
validaddr((uintptr)a, 1, 0);
e = vmemchr(a, 0, USTKSIZE);
if(e == nil)
error(Ebadarg);
nbytes += (e - a) + 1;
if(nbytes >= USTKSIZE)
error(Enovmem);
nargs++;
}
ssize = BY2WD*(nargs+1) + ((nbytes+(BY2WD-1)) & ~(BY2WD-1));
/*
* 8-byte align SP for those (e.g. sparc) that need it.
* execregs() will subtract another 4 bytes for argc.
*/
if(BY2WD == 4 && (ssize+4) & 7)
ssize += 4;
if(PGROUND(ssize) >= USTKSIZE)
error(Enovmem);
/*
* Build the stack segment, putting it in kernel virtual for the moment
*/
qlock(&up->seglock);
if(waserror()){
qunlock(&up->seglock);
nexterror();
}
s = up->seg[SSEG];
do {
tstk = s->base;
if(tstk <= USTKSIZE)
error(Enovmem);
} while((s = isoverlap(up, tstk-USTKSIZE, USTKSIZE)) != nil);
up->seg[ESEG] = newseg(SG_STACK, tstk-USTKSIZE, USTKSIZE/BY2PG);
/*
* Args: pass 2: assemble; the pages will be faulted in
*/
tos = (Tos*)(tstk - sizeof(Tos));
tos->cyclefreq = m->cyclefreq;
tos->kcycles = 0;
tos->pcycles = 0;
tos->clock = 0;
argv = (char**)(tstk - ssize);
charp = (char*)(tstk - nbytes);
if(indir)
argp = progarg;
else
argp = argp0;
for(i=0; i<nargs; i++){
if(indir && *argp==nil) {
indir = 0;
argp = argp0;
}
*argv++ = charp + (USTKTOP-tstk);
a = *argp++;
if(indir)
e = strchr(a, 0);
else {
validaddr((uintptr)a, 1, 0);
e = vmemchr(a, 0, (char*)tstk - charp);
if(e == nil)
error(Ebadarg);
}
n = (e - a) + 1;
memmove(charp, a, n);
charp += n;
}
/* copy args; easiest from new process's stack */
a = (char*)(tstk - nbytes);
n = charp - a;
if(n > 128) /* don't waste too much space on huge arg lists */
n = 128;
args = smalloc(n);
memmove(args, a, n);
if(n>0 && args[n-1]!='\0'){
/* make sure last arg is NUL-terminated */
/* put NUL at UTF-8 character boundary */
for(i=n-1; i>0; --i)
if(fullrune(args+i, n-i))
break;
args[i] = 0;
n = i+1;
}
/*
* Committed.
* Free old memory.
* Special segments are maintained across exec
*/
for(i = SSEG; i <= BSEG; i++) {
putseg(up->seg[i]);
/* prevent a second free if we have an error */
up->seg[i] = nil;
}
for(i = ESEG+1; i < NSEG; i++) {
s = up->seg[i];
if(s != nil && (s->type&SG_CEXEC) != 0) {
putseg(s);
up->seg[i] = nil;
}
}
/*
* Close on exec
*/
if((f = up->fgrp) != nil) {
for(i=0; i<=f->maxfd; i++)
fdclose(i, CCEXEC);
}
/* Text. Shared. Attaches to cache image if possible */
/* attachimage returns a locked cache image */
img = attachimage(SG_TEXT|SG_RONLY, tc, UTZERO, (t-UTZERO)>>PGSHIFT);
ts = img->s;
up->seg[TSEG] = ts;
ts->flushme = 1;
ts->fstart = 0;
ts->flen = sizeof(Exec)+text;
unlock(img);
/* Data. Shared. */
s = newseg(SG_DATA, t, (d-t)>>PGSHIFT);
up->seg[DSEG] = s;
/* Attached by hand */
incref(img);
s->image = img;
s->fstart = ts->fstart+ts->flen;
s->flen = data;
/* BSS. Zero fill on demand */
up->seg[BSEG] = newseg(SG_BSS, d, (b-d)>>PGSHIFT);
/*
* Move the stack
*/
s = up->seg[ESEG];
up->seg[ESEG] = nil;
s->base = USTKTOP-USTKSIZE;
s->top = USTKTOP;
relocateseg(s, USTKTOP-tstk);
up->seg[SSEG] = s;
qunlock(&up->seglock);
poperror(); /* seglock */
/*
* '/' processes are higher priority (hack to make /ip more responsive).
*/
if(devtab[tc->type]->dc == L'/')
up->basepri = PriRoot;
up->priority = up->basepri;
poperror(); /* tc */
cclose(tc);
poperror(); /* file0 */
free(file0);
qlock(&up->debug);
free(up->text);
up->text = elem;
free(up->args);
up->args = args;
up->nargs = n;
up->setargs = 0;
up->nnote = 0;
up->notify = 0;
up->notified = 0;
up->privatemem = 0;
up->noswap = 0;
procsetup(up);
qunlock(&up->debug);
/*
* At this point, the mmu contains info about the old address
* space and needs to be flushed
*/
flushmmu();
if(up->hang)
up->procctl = Proc_stopme;
return execregs(entry, ssize, nargs);
}
long
sysexec(ulong *arg)
{
Segment *s, *ts;
ulong t, d, b;
int i;
Chan *tc;
char **argv, **argp;
char *a, *charp, *args, *file, *file0;
char *progarg[sizeof(Exec)/2+1], *elem, progelem[64];
ulong ssize, spage, nargs, nbytes, n, bssend;
int indir;
Exec exec;
char line[sizeof(Exec)];
Fgrp *f;
Image *img;
ulong magic, text, entry, data, bss;
Tos *tos;
indir = 0;
elem = nil;
validaddr(arg[0], 1, 0);
file0 = validnamedup((char*)arg[0], 1);
if(waserror()){
free(file0);
free(elem);
nexterror();
}
file = file0;
for(;;){
tc = namec(file, Aopen, OEXEC, 0);
if(waserror()){
cclose(tc);
nexterror();
}
if(!indir)
kstrdup(&elem, up->genbuf);
n = devtab[tc->type]->read(tc, &exec, sizeof(Exec), 0);
if(n < 2)
error(Ebadexec);
magic = l2be(exec.magic);
text = l2be(exec.text);
entry = l2be(exec.entry);
if(n==sizeof(Exec) && (magic == AOUT_MAGIC)){
if(text >= USTKTOP-UTZERO
|| entry < UTZERO+sizeof(Exec)
|| entry >= UTZERO+sizeof(Exec)+text)
error(Ebadexec);
break; /* for binary */
}
/*
* Process #! /bin/sh args ...
*/
memmove(line, &exec, sizeof(Exec));
if(indir || line[0]!='#' || line[1]!='!')
error(Ebadexec);
n = shargs(line, n, progarg);
if(n == 0)
error(Ebadexec);
indir = 1;
/*
* First arg becomes complete file name
*/
progarg[n++] = file;
progarg[n] = 0;
validaddr(arg[1], BY2WD, 1);
arg[1] += BY2WD;
file = progarg[0];
if(strlen(elem) >= sizeof progelem)
error(Ebadexec);
strcpy(progelem, elem);
progarg[0] = progelem;
poperror();
cclose(tc);
}
data = l2be(exec.data);
bss = l2be(exec.bss);
t = (UTZERO+sizeof(Exec)+text+(BY2PG-1)) & ~(BY2PG-1);
d = (t + data + (BY2PG-1)) & ~(BY2PG-1);
bssend = t + data + bss;
b = (bssend + (BY2PG-1)) & ~(BY2PG-1);
if(t >= KZERO || d >= KZERO || b >= KZERO)
error(Ebadexec);
/*
* Args: pass 1: count
*/
nbytes = sizeof(Tos); /* hole for profiling clock at top of stack (and more) */
nargs = 0;
if(indir){
argp = progarg;
while(*argp){
a = *argp++;
nbytes += strlen(a) + 1;
nargs++;
}
}
evenaddr(arg[1]);
argp = (char**)arg[1];
validaddr((ulong)argp, BY2WD, 0);
while(*argp){
a = *argp++;
if(((ulong)argp&(BY2PG-1)) < BY2WD)
validaddr((ulong)argp, BY2WD, 0);
validaddr((ulong)a, 1, 0);
nbytes += ((char*)vmemchr(a, 0, 0x7FFFFFFF) - a) + 1;
nargs++;
}
ssize = BY2WD*(nargs+1) + ((nbytes+(BY2WD-1)) & ~(BY2WD-1));
/*
* 8-byte align SP for those (e.g. sparc) that need it.
* execregs() will subtract another 4 bytes for argc.
*/
if((ssize+4) & 7)
ssize += 4;
spage = (ssize+(BY2PG-1)) >> PGSHIFT;
/*
* Build the stack segment, putting it in kernel virtual for the moment
*/
if(spage > TSTKSIZ)
error(Enovmem);
qlock(&up->seglock);
if(waserror()){
qunlock(&up->seglock);
nexterror();
}
up->seg[ESEG] = newseg(SG_STACK, TSTKTOP-USTKSIZE, USTKSIZE/BY2PG);
/*
* Args: pass 2: assemble; the pages will be faulted in
*/
tos = (Tos*)(TSTKTOP - sizeof(Tos));
tos->cyclefreq = m->cyclefreq;
cycles((uvlong*)&tos->pcycles);
tos->pcycles = -tos->pcycles;
tos->kcycles = tos->pcycles;
tos->clock = 0;
argv = (char**)(TSTKTOP - ssize);
charp = (char*)(TSTKTOP - nbytes);
args = charp;
if(indir)
argp = progarg;
else
argp = (char**)arg[1];
for(i=0; i<nargs; i++){
if(indir && *argp==0) {
indir = 0;
argp = (char**)arg[1];
}
*argv++ = charp + (USTKTOP-TSTKTOP);
n = strlen(*argp) + 1;
memmove(charp, *argp++, n);
charp += n;
}
free(file0);
free(up->text);
up->text = elem;
elem = nil; /* so waserror() won't free elem */
USED(elem);
/* copy args; easiest from new process's stack */
n = charp - args;
if(n > 128) /* don't waste too much space on huge arg lists */
n = 128;
a = up->args;
up->args = nil;
free(a);
up->args = smalloc(n);
memmove(up->args, args, n);
if(n>0 && up->args[n-1]!='\0'){
/* make sure last arg is NUL-terminated */
/* put NUL at UTF-8 character boundary */
for(i=n-1; i>0; --i)
if(fullrune(up->args+i, n-i))
break;
up->args[i] = 0;
n = i+1;
}
up->nargs = n;
/*
* Committed.
* Free old memory.
* Special segments are maintained across exec
*/
for(i = SSEG; i <= BSEG; i++) {
putseg(up->seg[i]);
/* prevent a second free if we have an error */
up->seg[i] = 0;
}
for(i = BSEG+1; i < NSEG; i++) {
s = up->seg[i];
if(s != 0 && (s->type&SG_CEXEC)) {
putseg(s);
up->seg[i] = 0;
}
}
/*
* Close on exec
*/
f = up->fgrp;
for(i=0; i<=f->maxfd; i++)
fdclose(i, CCEXEC);
/* Text. Shared. Attaches to cache image if possible */
/* attachimage returns a locked cache image */
img = attachimage(SG_TEXT|SG_RONLY, tc, UTZERO, (t-UTZERO)>>PGSHIFT);
ts = img->s;
up->seg[TSEG] = ts;
ts->flushme = 1;
ts->fstart = 0;
ts->flen = sizeof(Exec)+text;
unlock(img);
/* Data. Shared. */
s = newseg(SG_DATA, t, (d-t)>>PGSHIFT);
up->seg[DSEG] = s;
/* Attached by hand */
incref(img);
s->image = img;
s->fstart = ts->fstart+ts->flen;
s->flen = data;
/* BSS. Zero fill on demand */
up->seg[BSEG] = newseg(SG_BSS, d, (b-d)>>PGSHIFT);
/*
* Move the stack
*/
s = up->seg[ESEG];
up->seg[ESEG] = 0;
up->seg[SSEG] = s;
qunlock(&up->seglock);
poperror(); /* seglock */
poperror(); /* elem */
s->base = USTKTOP-USTKSIZE;
s->top = USTKTOP;
relocateseg(s, USTKTOP-TSTKTOP);
/*
* '/' processes are higher priority (hack to make /ip more responsive).
*/
if(devtab[tc->type]->dc == L'/')
up->basepri = PriRoot;
up->priority = up->basepri;
poperror();
cclose(tc);
/*
* At this point, the mmu contains info about the old address
* space and needs to be flushed
*/
flushmmu();
qlock(&up->debug);
up->nnote = 0;
up->notify = 0;
up->notified = 0;
up->privatemem = 0;
procsetup(up);
qunlock(&up->debug);
if(up->hang)
up->procctl = Proc_stopme;
return execregs(entry, ssize, nargs);
}
