void
userinit(void)
{
Proc *p;
Osenv *o;
p = newproc();
o = p->env;
o->fgrp = newfgrp(nil);
o->pgrp = newpgrp();
o->egrp = newegrp();
kstrdup(&o->user, eve);
strcpy(p->text, "interp");
p->fpstate = FPINIT;
/* Kernel Stack
N.B. The -12 for the stack pointer is important.
4 bytes for gotolabel's return PC */
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK-8;
ready(p);
}
void
userinit(void)
{
Proc *p;
Osenv *o;
p = newproc();
o = p->env;
o->fgrp = newfgrp(nil);
o->pgrp = newpgrp();
o->egrp = newegrp();
kstrdup(&o->user, eve);
strcpy(p->text, "interp");
/*
* Kernel Stack
*/
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK;
ready(p);
}
void
userinit(void)
{
Proc *p;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
p->fpstate = FPinit;
fpoff();
/*
* Kernel Stack
*
* N.B. make sure there's enough space for syscall to check
* for valid args and
* 4 bytes for gotolabel's return PC
*/
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK-(sizeof(Sargs)+BY2WD);
/* NB: no user stack nor text segments are set up */
ready(p);
}
void
userinit(void)
{
Proc *p;
Osenv *o;
p = newproc();
o = p->env;
o->fgrp = newfgrp(nil);
o->pgrp = newpgrp();
kstrdup(&o->user, eve);
strcpy(p->text,"interp");
p->fpstate = FPINIT;
fpinit();
/*
* Kernel Stack
*/
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK-8;
p->sched.sp &= ~7; /* SP must be 8-byte aligned */
ready(p);
}
hproc_t*
kern_baseproc(void (*start_func)(void *arg), char *start_module)
{
hproc_t *p;
Osdep *os;
Osenv *e;
/* create a kernel hosting proc */
p = new_hproc(uv_default_loop());
/* bind the base proc to the startup thread */
baseinit(p);
/* append it to the proc list */
procs.head = p;
p->prev = nil;
procs.tail = p;
/* setup the skeleton process environment */
e = p->env;
e->pgrp = newpgrp();
e->fgrp = newfgrp(nil);
e->egrp = newegrp();
e->errstr = e->errbuf0;
e->syserrstr = e->errbuf1;
//e->user = strdup("node9");
e->uid = hostuid;
e->gid = hostgid;
/* allocate the os dependency structure */
os = malloc(sizeof(*os));
if(os == nil) {
panic("host_proc: no memory");
}
p->os = os;
os->self = uv_thread_self(); // just the handle for primary thread
os->thread = nil; // because its the process thread itself
uv_sem_init(&os->sem, 0);
/* insert the startup function and module */
p->func = start_func;
p->arg = start_module;
/* debug watchers */
//uv_idle_init(p->loop, &idle_watcher);
//uv_idle_start(&idle_watcher, debug_idle);
//uv_prepare_init(p->loop, &prepare_watcher);
//uv_prepare_start(&prepare_watcher, debug_prepare);
//uv_poll_init(p->loop, &poll_watcher,0);
//uv_poll_start(&poll_watcher, 0, debug_poll);
//uv_check_init(p->loop, &check_watcher);
//uv_check_start(&check_watcher, debug_check);
return p;
}
void
userinit(void)
{
Proc *p;
Segment *s;
KMap *k;
char **av;
Page *pg;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
procsetup(p);
/*
* Kernel Stack
*/
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK-MAXSYSARG*BY2WD;
/*
* User Stack, pass input arguments to boot process
*/
s = newseg(SG_STACK, USTKTOP-USTKSIZE, USTKSIZE/BY2PG);
p->seg[SSEG] = s;
pg = newpage(1, 0, USTKTOP-BY2PG);
segpage(s, pg);
k = kmap(pg);
for(av = (char**)argbuf; *av; av++)
*av += (USTKTOP - sizeof(argbuf)) - (ulong)argbuf;
memmove((uchar*)VA(k) + BY2PG - sizeof(argbuf), argbuf, sizeof argbuf);
kunmap(k);
/*
* Text
*/
s = newseg(SG_TEXT, UTZERO, 1);
s->flushme++;
p->seg[TSEG] = s;
pg = newpage(1, 0, UTZERO);
pg->txtflush = ~0;
segpage(s, pg);
k = kmap(s->map[0]->pages[0]);
memmove((uchar*)VA(k), initcode, sizeof initcode);
kunmap(k);
ready(p);
}
/*
* create the first process
*/
void
userinit(void)
{
Proc *p;
Segment *s;
KMap *k;
Page *pg;
/* no processes yet */
up = nil;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
/*
* Kernel Stack
*/
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK-(sizeof(Sargs)+BY2WD);
/*
* User Stack
*/
s = newseg(SG_STACK, USTKTOP-USTKSIZE, USTKSIZE/BY2PG);
p->seg[SSEG] = s;
pg = newpage(1, 0, USTKTOP-BY2PG);
segpage(s, pg);
k = kmap(pg);
bootargs(VA(k));
kunmap(k);
/*
* Text
*/
s = newseg(SG_TEXT, UTZERO, 1);
p->seg[TSEG] = s;
pg = newpage(1, 0, UTZERO);
memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
segpage(s, pg);
k = kmap(s->map[0]->pages[0]);
memmove((ulong*)VA(k), initcode, sizeof initcode);
kunmap(k);
ready(p);
}
void
userinit(void)
{
Proc *p;
Segment *s;
KMap *k;
Page *pg;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
p->fpstate = FPinit;
/*
* Stack
*
* N.B. The -12 for the stack pointer is important.
* 4 bytes for gotolabel's return PC
*/
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK-(sizeof(Sargs)+BY2WD);
/*
* User Stack
*/
s = newseg(SG_STACK, USTKTOP-USTKSIZE, USTKSIZE/BY2PG);
p->seg[SSEG] = s;
pg = newpage(1, 0, USTKTOP-BY2PG);
segpage(s, pg);
/*
* Text
*/
s = newseg(SG_TEXT, UTZERO, 1);
s->flushme++;
p->seg[TSEG] = s;
pg = newpage(1, 0, UTZERO);
memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
segpage(s, pg);
k = kmap(s->map[0]->pages[0]);
memmove((ulong*)VA(k), initcode, sizeof initcode);
kunmap(k);
ready(p);
}
void
kproc(char *name, void (*func)(void *), void *arg)
{
Mach *m = machp();
Proc *p;
static Pgrp *kpgrp;
p = newproc();
p->psstate = 0;
p->procmode = 0640;
p->kp = 1;
p->noswap = 1;
p->scallnr = m->externup->scallnr;
memmove(p->arg, m->externup->arg, sizeof(m->externup->arg));
p->nerrlab = 0;
p->slash = m->externup->slash;
p->dot = m->externup->dot;
if(p->dot)
incref(p->dot);
memmove(p->note, m->externup->note, sizeof(p->note));
p->nnote = m->externup->nnote;
p->notified = 0;
p->lastnote = m->externup->lastnote;
p->notify = m->externup->notify;
p->ureg = 0;
p->dbgreg = 0;
procpriority(p, PriKproc, 0);
kprocchild(p, func, arg);
kstrdup(&p->user, eve);
kstrdup(&p->text, name);
if(kpgrp == 0)
kpgrp = newpgrp();
p->pgrp = kpgrp;
incref(kpgrp);
memset(p->time, 0, sizeof(p->time));
p->time[TReal] = sys->ticks;
ready(p);
/*
* since the bss/data segments are now shareable,
* any mmu info about this process is now stale
* and has to be discarded.
*/
p->newtlb = 1;
mmuflush();
}
void
kproc(char *name, void (*func)(void *), void *arg)
{
Proc *p;
static Pgrp *kpgrp;
p = newproc();
p->psstate = 0;
p->procmode = 0640;
p->kp = 1;
p->noswap = 1;
p->fpsave = up->fpsave;
p->scallnr = up->scallnr;
p->s = up->s;
p->nerrlab = 0;
p->slash = up->slash;
p->dot = up->dot;
if(p->dot)
incref(p->dot);
memmove(p->note, up->note, sizeof(p->note));
p->nnote = up->nnote;
p->notified = 0;
p->lastnote = up->lastnote;
p->notify = up->notify;
p->ureg = 0;
p->dbgreg = 0;
procpriority(p, PriKproc, 0);
kprocchild(p, func, arg);
kstrdup(&p->user, eve);
kstrdup(&p->text, name);
if(kpgrp == 0)
kpgrp = newpgrp();
p->pgrp = kpgrp;
incref(kpgrp);
memset(p->time, 0, sizeof(p->time));
p->time[TReal] = MACHP(0)->ticks;
ready(p);
}
void
userinit(void)
{
Proc *p;
Segment *s;
KMap *k;
Page *pg;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
/*
* Kernel Stack
*
* N.B. make sure there's enough space for syscall to check
* for valid args and
* space for gotolabel's return PC
* AMD64 stack must be quad-aligned.
*/
p->sched.pc = PTR2UINT(init0);
p->sched.sp = PTR2UINT(p->kstack+KSTACK-sizeof(up->arg)-sizeof(uintptr));
p->sched.sp = STACKALIGN(p->sched.sp);
/*
* User Stack
*
* Technically, newpage can't be called here because it
* should only be called when in a user context as it may
* try to sleep if there are no pages available, but that
* shouldn't be the case here.
*/
s = newseg(SG_STACK, USTKTOP-USTKSIZE, USTKSIZE/BIGPGSZ);
p->seg[SSEG] = s;
pg = newpage(1, 0, USTKTOP-BIGPGSZ, BIGPGSZ, -1);
segpage(s, pg);
k = kmap(pg);
bootargs(VA(k));
kunmap(k);
/*
* Text
*/
s = newseg(SG_TEXT, UTZERO, 1);
s->flushme++;
p->seg[TSEG] = s;
pg = newpage(1, 0, UTZERO, BIGPGSZ, -1);
memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
segpage(s, pg);
k = kmap(s->map[0]->pages[0]);
memmove(UINT2PTR(VA(k)), initcode, sizeof initcode);
kunmap(k);
ready(p);
}
void
userinit(void)
{
void *v;
Proc *p;
Segment *s;
Page *pg;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
p->fpstate = FPinit;
fpoff();
/*
* Kernel Stack
*
* N.B. make sure there's enough space for syscall to check
* for valid args and
* 4 bytes for gotolabel's return PC
*/
p->sched.pc = (ulong)init0;
p->sched.sp = (ulong)p->kstack+KSTACK-(sizeof(Sargs)+BY2WD);
/*
* User Stack
*
* N.B. cannot call newpage() with clear=1, because pc kmap
* requires up != nil. use tmpmap instead.
*/
s = newseg(SG_STACK, USTKTOP-USTKSIZE, USTKSIZE/BY2PG);
p->seg[SSEG] = s;
pg = newpage(0, 0, USTKTOP-BY2PG);
v = tmpmap(pg);
memset(v, 0, BY2PG);
segpage(s, pg);
bootargs(v);
tmpunmap(v);
/*
* Text
*/
s = newseg(SG_TEXT, UTZERO, 1);
s->flushme++;
p->seg[TSEG] = s;
pg = newpage(0, 0, UTZERO);
memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
segpage(s, pg);
v = tmpmap(pg);
memset(v, 0, BY2PG);
memmove(v, initcode, sizeof initcode);
tmpunmap(v);
ready(p);
}
void
emuinit(void *imod)
{
Osenv *e;
char *wdir;
e = up->env;
e->pgrp = newpgrp();
e->fgrp = newfgrp(nil);
e->egrp = newegrp();
e->errstr = e->errbuf0;
e->syserrstr = e->errbuf1;
e->user = strdup("");
links();
chandevinit();
if(waserror())
panic("setting root and dot");
e->pgrp->slash = namec("#/", Atodir, 0, 0);
cnameclose(e->pgrp->slash->name);
e->pgrp->slash->name = newcname("/");
e->pgrp->dot = cclone(e->pgrp->slash);
poperror();
strcpy(up->text, "main");
if(kopen("#c/cons", OREAD) != 0)
fprint(2, "failed to make fd0 from #c/cons: %r\n");
kopen("#c/cons", OWRITE);
kopen("#c/cons", OWRITE);
/* the setid cannot precede the bind of #U */
kbind("#U", "/", MAFTER|MCREATE);
setid(eve, 0);
kbind("#^", "/dev", MBEFORE); /* snarf */
kbind("#^", "/chan", MBEFORE);
kbind("#m", "/dev", MBEFORE); /* pointer */
kbind("#c", "/dev", MBEFORE);
kbind("#p", "/prog", MREPL);
kbind("#d", "/fd", MREPL);
kbind("#I", "/net", MAFTER); /* will fail on Plan 9 */
/* BUG: we actually only need to do these on Plan 9 */
kbind("#U/dev", "/dev", MAFTER);
kbind("#U/net", "/net", MAFTER);
kbind("#U/net.alt", "/net.alt", MAFTER);
if(cputype != nil)
ksetenv("cputype", cputype, 1);
putenvqv("emuargs", rebootargv, rebootargc, 1);
putenvq("emuroot", rootdir, 1);
ksetenv("emuhost", hosttype, 1);
wdir = malloc(1024);
if(wdir != nil){
if(getwd(wdir, 1024) != nil)
putenvq("emuwdir", wdir, 1);
free(wdir);
}
kproc("main", disinit, imod, KPDUPFDG|KPDUPPG|KPDUPENVG);
for(;;)
ospause();
}
/*
* create the first process
*/
void
userinit(void)
{
Proc *p;
Segment *s;
KMap *k;
Page *pg;
/* no processes yet */
up = nil;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
/*
* Kernel Stack
*/
p->sched.pc = PTR2UINT(init0);
p->sched.sp = PTR2UINT(p->kstack+KSTACK-sizeof(up->s.args)-sizeof(uintptr));
p->sched.sp = STACKALIGN(p->sched.sp);
/*
* User Stack
*
* Technically, newpage can't be called here because it
* should only be called when in a user context as it may
* try to sleep if there are no pages available, but that
* shouldn't be the case here.
*/
s = newseg(SG_STACK, USTKTOP-USTKSIZE, USTKSIZE/BY2PG);
p->seg[SSEG] = s;
pg = newpage(1, 0, USTKTOP-BY2PG);
segpage(s, pg);
k = kmap(pg);
bootargs(VA(k));
kunmap(k);
/*
* Text
*/
s = newseg(SG_TEXT, UTZERO, 1);
s->flushme++;
p->seg[TSEG] = s;
pg = newpage(1, 0, UTZERO);
memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
segpage(s, pg);
k = kmap(s->map[0]->pages[0]);
memmove(UINT2PTR(VA(k)), initcode, sizeof initcode);
kunmap(k);
ready(p);
}
Proc*
setupseg(int core)
{
Mach *m = machp();
Segment *s;
uintptr_t ka;
Proc *p;
static Pgrp *kpgrp;
Segment *tseg;
int sno;
// XXX: we're going to need this for locality domains.
USED(core);
p = newproc();
p->psstate = 0;
p->procmode = 0640;
p->kp = 1;
p->noswap = 1;
p->scallnr = m->externup->scallnr;
memmove(p->arg, m->externup->arg, sizeof(m->externup->arg));
p->nerrlab = 0;
p->slash = m->externup->slash;
p->dot = m->externup->dot;
if(p->dot)
incref(p->dot);
memmove(p->note, m->externup->note, sizeof(p->note));
p->nnote = m->externup->nnote;
p->notified = 0;
p->lastnote = m->externup->lastnote;
p->notify = m->externup->notify;
p->ureg = 0;
p->dbgreg = 0;
kstrdup(&p->user, eve);
if(kpgrp == 0)
kpgrp = newpgrp();
p->pgrp = kpgrp;
incref(kpgrp);
memset(p->time, 0, sizeof(p->time));
p->time[TReal] = sys->ticks;
procpriority(p, PriKproc, 0);
// XXX: kluge 4 pages of address space for this.
// how will it expand up? gives us <50 kprocs as is.
/*
* we create the color and core at allocation time, not execution. This
* is probably not the best idea but it's a start.
*/
sno = 0;
// XXX: now that we are asmalloc we are no long proc.
/* Stack */
ka = (uintptr_t)KADDR(asmalloc(0, BIGPGSZ, AsmMEMORY, 1));
tseg = newseg(SG_STACK|SG_READ|SG_WRITE, ka, 1);
tseg = p->seg[sno++];
ka = (uintptr_t)KADDR(asmalloc(0, BIGPGSZ, AsmMEMORY, 1));
s = newseg(SG_TEXT|SG_READ|SG_EXEC, ka, 1);
p->seg[sno++] = s;
// s->color = acpicorecolor(core);
/* Data. Shared. */
// XXX; Now that the address space is all funky how are we going to handle shared data segments?
ka = (uintptr_t)KADDR(asmalloc(0, BIGPGSZ, AsmMEMORY, 2));
s = newseg(SG_DATA|SG_READ|SG_WRITE, ka, 1);
p->seg[sno++] = s;
s->color = tseg->color;
/* BSS. Uses asm from data map. */
p->seg[sno++] = newseg(SG_BSS|SG_READ|SG_WRITE, ka+BIGPGSZ, 1);
p->seg[sno++]->color= tseg->color;
nixprepage(-1);
return p;
}
void
userinit(void)
{
Mach *m = machp();
Proc *p;
Segment *s;
KMap *k;
Page *pg;
int sno;
p = newproc();
p->pgrp = newpgrp();
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
p->fgrp = dupfgrp(nil);
p->rgrp = newrgrp();
p->procmode = 0640;
kstrdup(&eve, "");
kstrdup(&p->text, "*init*");
kstrdup(&p->user, eve);
/*
* Kernel Stack
*
* N.B. make sure there's enough space for syscall to check
* for valid args and
* space for gotolabel's return PC
* AMD64 stack must be quad-aligned.
*/
p->sched.pc = PTR2UINT(init0);
p->sched.sp = PTR2UINT(p->kstack+KSTACK-sizeof(m->externup->arg)-sizeof(uintptr_t));
p->sched.sp = STACKALIGN(p->sched.sp);
/*
* User Stack
*
* Technically, newpage can't be called here because it
* should only be called when in a user context as it may
* try to sleep if there are no pages available, but that
* shouldn't be the case here.
*/
sno = 0;
s = newseg(SG_STACK|SG_READ|SG_WRITE, USTKTOP-USTKSIZE, USTKSIZE/ BIGPGSZ);
p->seg[sno++] = s;
pg = newpage(1, 0, USTKTOP-BIGPGSZ, BIGPGSZ, -1);
segpage(s, pg);
k = kmap(pg);
bootargs(VA(k));
kunmap(k);
/*
* Text
*/
s = newseg(SG_TEXT|SG_READ|SG_EXEC, UTZERO, 1);
s->flushme++;
p->seg[sno++] = s;
pg = newpage(1, 0, UTZERO, BIGPGSZ, -1);
memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
segpage(s, pg);
k = kmap(s->map[0]->pages[0]);
/* UTZERO is only needed until we make init not have 2M block of zeros at the front. */
memmove(UINT2PTR(VA(k) + init_code_start - UTZERO), init_code_out, sizeof(init_code_out));
kunmap(k);
/*
* Data
*/
s = newseg(SG_DATA|SG_READ|SG_WRITE, UTZERO + BIGPGSZ, 1);
s->flushme++;
p->seg[sno++] = s;
pg = newpage(1, 0, UTZERO + BIGPGSZ, BIGPGSZ, -1);
memset(pg->cachectl, PG_TXTFLUSH, sizeof(pg->cachectl));
segpage(s, pg);
k = kmap(s->map[0]->pages[0]);
/* This depends on init having a text segment < 2M. */
memmove(UINT2PTR(VA(k) + init_data_start - (UTZERO + BIGPGSZ)), init_data_out, sizeof(init_data_out));
kunmap(k);
ready(p);
}
uintptr
sysrfork(va_list list)
{
Proc *p;
int n, i;
Fgrp *ofg;
Pgrp *opg;
Rgrp *org;
Egrp *oeg;
ulong pid, flag;
Mach *wm;
flag = va_arg(list, ulong);
/* Check flags before we commit */
if((flag & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
error(Ebadarg);
if((flag & (RFNAMEG|RFCNAMEG)) == (RFNAMEG|RFCNAMEG))
error(Ebadarg);
if((flag & (RFENVG|RFCENVG)) == (RFENVG|RFCENVG))
error(Ebadarg);
if((flag&RFPROC) == 0) {
if(flag & (RFMEM|RFNOWAIT))
error(Ebadarg);
if(flag & (RFFDG|RFCFDG)) {
ofg = up->fgrp;
if(flag & RFFDG)
up->fgrp = dupfgrp(ofg);
else
up->fgrp = dupfgrp(nil);
closefgrp(ofg);
}
if(flag & (RFNAMEG|RFCNAMEG)) {
opg = up->pgrp;
up->pgrp = newpgrp();
if(flag & RFNAMEG)
pgrpcpy(up->pgrp, opg);
/* inherit noattach */
up->pgrp->noattach = opg->noattach;
closepgrp(opg);
}
if(flag & RFNOMNT)
up->pgrp->noattach = 1;
if(flag & RFREND) {
org = up->rgrp;
up->rgrp = newrgrp();
closergrp(org);
}
if(flag & (RFENVG|RFCENVG)) {
oeg = up->egrp;
up->egrp = smalloc(sizeof(Egrp));
up->egrp->ref = 1;
if(flag & RFENVG)
envcpy(up->egrp, oeg);
closeegrp(oeg);
}
if(flag & RFNOTEG)
up->noteid = pidalloc(0);
return 0;
}
p = newproc();
p->scallnr = up->scallnr;
p->s = up->s;
p->nerrlab = 0;
p->slash = up->slash;
p->dot = up->dot;
incref(p->dot);
memmove(p->note, up->note, sizeof(p->note));
p->privatemem = up->privatemem;
p->noswap = up->noswap;
p->nnote = up->nnote;
p->notified = 0;
p->lastnote = up->lastnote;
p->notify = up->notify;
p->ureg = up->ureg;
p->dbgreg = 0;
/* Abort the child process on error */
if(waserror()){
p->kp = 1;
kprocchild(p, abortion, 0);
ready(p);
nexterror();
}
/* Make a new set of memory segments */
n = flag & RFMEM;
qlock(&p->seglock);
if(waserror()){
qunlock(&p->seglock);
nexterror();
}
for(i = 0; i < NSEG; i++)
if(up->seg[i] != nil)
p->seg[i] = dupseg(up->seg, i, n);
qunlock(&p->seglock);
poperror();
/* File descriptors */
if(flag & (RFFDG|RFCFDG)) {
if(flag & RFFDG)
p->fgrp = dupfgrp(up->fgrp);
else
p->fgrp = dupfgrp(nil);
}
else {
p->fgrp = up->fgrp;
incref(p->fgrp);
}
/* Process groups */
if(flag & (RFNAMEG|RFCNAMEG)) {
p->pgrp = newpgrp();
if(flag & RFNAMEG)
pgrpcpy(p->pgrp, up->pgrp);
/* inherit noattach */
p->pgrp->noattach = up->pgrp->noattach;
}
else {
p->pgrp = up->pgrp;
incref(p->pgrp);
}
if(flag & RFNOMNT)
p->pgrp->noattach = 1;
if(flag & RFREND)
p->rgrp = newrgrp();
else {
incref(up->rgrp);
p->rgrp = up->rgrp;
}
/* Environment group */
if(flag & (RFENVG|RFCENVG)) {
p->egrp = smalloc(sizeof(Egrp));
p->egrp->ref = 1;
if(flag & RFENVG)
envcpy(p->egrp, up->egrp);
}
else {
p->egrp = up->egrp;
incref(p->egrp);
}
p->hang = up->hang;
p->procmode = up->procmode;
if(up->procctl == Proc_tracesyscall)
p->procctl = Proc_tracesyscall;
poperror(); /* abortion */
/* Craft a return frame which will cause the child to pop out of
* the scheduler in user mode with the return register zero
*/
forkchild(p, up->dbgreg);
p->parent = up;
if((flag&RFNOWAIT) == 0){
p->parentpid = up->pid;
lock(&up->exl);
up->nchild++;
unlock(&up->exl);
}
if((flag&RFNOTEG) == 0)
p->noteid = up->noteid;
pid = p->pid;
memset(p->time, 0, sizeof(p->time));
p->time[TReal] = MACHP(0)->ticks;
kstrdup(&p->text, up->text);
kstrdup(&p->user, up->user);
procfork(p);
/*
* since the bss/data segments are now shareable,
* any mmu info about this process is now stale
* (i.e. has bad properties) and has to be discarded.
*/
flushmmu();
p->basepri = up->basepri;
p->priority = up->basepri;
p->fixedpri = up->fixedpri;
p->mp = up->mp;
wm = up->wired;
if(wm)
procwired(p, wm->machno);
ready(p);
sched();
return pid;
}
