[unix-history] / usr / src / sys / kern / kern_synch.c

/*	kern_synch.c	3.15	%G%	*/

#include "../h/param.h"
#include "../h/systm.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/proc.h"
#include "../h/file.h"
#include "../h/inode.h"
#include "../h/vm.h"
#include "../h/pte.h"
#include "../h/inline.h"


#define SQSIZE 0100	/* Must be power of 2 */
#define HASH(x)	(( (int) x >> 5) & (SQSIZE-1))
struct proc *slpque[SQSIZE];

/*
 * Give up the processor till a wakeup occurs
 * on chan, at which time the process
 * enters the scheduling queue at priority pri.
 * The most important effect of pri is that when
 * pri<=PZERO a signal cannot disturb the sleep;
 * if pri>PZERO signals will be processed.
 * Callers of this routine must be prepared for
 * premature return, and check that the reason for
 * sleeping has gone away.
 */
sleep(chan, pri)
caddr_t chan;
{
	register struct proc *rp, **hp;
	register s;

	rp = u.u_procp;
	s = spl6();
	if (chan==0 || rp->p_stat != SRUN || rp->p_rlink)
		panic("sleep");
	rp->p_wchan = chan;
	rp->p_slptime = 0;
	rp->p_pri = pri;
	hp = &slpque[HASH(chan)];
	rp->p_link = *hp;
	*hp = rp;
	if(pri > PZERO) {
		if(ISSIG(rp)) {
			if (rp->p_wchan)
				unsleep(rp);
			rp->p_stat = SRUN;
			(void) spl0();
			goto psig;
		}
		if (rp->p_wchan == 0)
			goto out;
		rp->p_stat = SSLEEP;
		(void) spl0();
		if(runin != 0) {
			runin = 0;
			wakeup((caddr_t)&runin);
		}
		swtch();
		if(ISSIG(rp))
			goto psig;
	} else {
		rp->p_stat = SSLEEP;
		(void) spl0();
		swtch();
	}
out:
	splx(s);
	return;

	/*
	 * If priority was low (>PZERO) and
	 * there has been a signal,
	 * execute non-local goto to
	 * the qsav location.
	 * (see trap1/trap.c)
	 */
psig:
	longjmp(u.u_qsav);
	/*NOTREACHED*/
}

/*
 * Sleep on chan at pri.
 * Return in no more than the indicated number of seconds.
 * (If seconds==0, no timeout implied)
 * Return	TS_OK if chan was awakened normally
 *		TS_TIME if timeout occurred
 *		TS_SIG if asynchronous signal occurred
 */
tsleep(chan, pri, seconds)
caddr_t chan;
{
	label_t lqsav;
	register struct proc *pp;
	register sec, n, rval;

	pp = u.u_procp;
	n = spl7();
	sec = 0;
	rval = 0;
	if (pp->p_clktim && pp->p_clktim<seconds)
		seconds = 0;
	if (seconds) {
		pp->p_flag |= STIMO;
		sec = pp->p_clktim-seconds;
		pp->p_clktim = seconds;
	}
	bcopy((caddr_t)u.u_qsav, (caddr_t)lqsav, sizeof (label_t));
	if (setjmp(u.u_qsav))
		rval = TS_SIG;
	else {
		sleep(chan, pri);
		if ((pp->p_flag&STIMO)==0 && seconds)
			rval = TS_TIME;
		else
			rval = TS_OK;
	}
	pp->p_flag &= ~STIMO;
	bcopy((caddr_t)lqsav, (caddr_t)u.u_qsav, sizeof (label_t));
	if (sec > 0)
		pp->p_clktim += sec;
	else
		pp->p_clktim = 0;
	splx(n);
	return(rval);
}

/*
 * Remove a process from its wait queue
 */
unsleep(p)
register struct proc *p;
{
	register struct proc **hp;
	register s;

	s = spl6();
	if (p->p_wchan) {
		hp = &slpque[HASH(p->p_wchan)];
		while (*hp != p)
			hp = &(*hp)->p_link;
		*hp = p->p_link;
		p->p_wchan = 0;
	}
	splx(s);
}

/*
 * Wake up all processes sleeping on chan.
 */
wakeup(chan)
register caddr_t chan;
{
	register struct proc *p, **q, **h;
	int s;

	s = spl6();
	h = &slpque[HASH(chan)];
restart:
	for (q = h; p = *q; ) {
		if (p->p_rlink || p->p_stat != SSLEEP && p->p_stat != SSTOP)
			panic("wakeup");
		if (p->p_wchan==chan) {
			p->p_wchan = 0;
			*q = p->p_link;
			p->p_slptime = 0;
			if (p->p_stat == SSLEEP) {
				/* OPTIMIZED INLINE EXPANSION OF setrun(p) */
				p->p_stat = SRUN;
				if (p->p_flag & SLOAD) {
#ifndef FASTVAX
					p->p_link = runq;
					runq = p->p_link;
#else
					setrq(p);
#endif
				}
				if(p->p_pri < curpri)
					runrun++;
				if(runout != 0 && (p->p_flag&SLOAD) == 0) {
					runout = 0;
					wakeup((caddr_t)&runout);
				}
				/* END INLINE EXPANSION */
				goto restart;
			}
		} else
			q = &p->p_link;
	}
	splx(s);
}

#ifdef FASTVAX
/*
 * Initialize the (doubly-linked) run queues
 * to be empty.
 */
rqinit()
{
	register int i;

	for (i = 0; i < NQS; i++)
		qs[i].ph_link = qs[i].ph_rlink = (struct proc *)&qs[i];
}
#endif

/*
 * Set the process running;
 * arrange for it to be swapped in if necessary.
 */
setrun(p)
register struct proc *p;
{
	register s;

	s = spl6();
	switch (p->p_stat) {

	case 0:
	case SWAIT:
	case SRUN:
	case SZOMB:
	default:
		panic("setrun");

	case SSTOP:
	case SSLEEP:
		unsleep(p);		/* e.g. when sending signals */
		break;

	case SIDL:
		break;
	}
	p->p_stat = SRUN;
	if (p->p_flag & SLOAD)
		setrq(p);
	splx(s);
	if(p->p_pri < curpri)
		runrun++;
	if(runout != 0 && (p->p_flag&SLOAD) == 0) {
		runout = 0;
		wakeup((caddr_t)&runout);
	}
}

/*
 * Set user priority.
 * The rescheduling flag (runrun)
 * is set if the priority is better
 * than the currently running process.
 */
setpri(pp)
register struct proc *pp;
{
	register p;

	p = (pp->p_cpu & 0377)/16;
	p += PUSER + pp->p_nice - NZERO;
	if(p > 127)
		p = 127;
	if(p < curpri)
		runrun++;
	pp->p_usrpri = p;
	return(p);
}

/*
 * Create a new process-- the internal version of
 * sys fork.
 * It returns 1 in the new process, 0 in the old.
 */
newproc(isvfork)
{
	register struct proc *p;
	register struct proc *rpp, *rip;
	register int n;

	p = NULL;
	/*
	 * First, just locate a slot for a process
	 * and copy the useful info from this process into it.
	 * The panic "cannot happen" because fork has already
	 * checked for the existence of a slot.
	 */
retry:
	mpid++;
	if(mpid >= 30000) {
		mpid = 0;
		goto retry;
	}
	for(rpp = &proc[0]; rpp < &proc[NPROC]; rpp++) {
		if(rpp->p_stat == NULL && p==NULL)
			p = rpp;
		if (rpp->p_pid==mpid || rpp->p_pgrp==mpid)
			goto retry;
	}
	if ((rpp = p)==NULL)
		panic("no procs");

	/*
	 * make proc entry for new proc
	 */

	rip = u.u_procp;
	rpp->p_stat = SIDL;
	rpp->p_clktim = 0;
	rpp->p_flag = SLOAD | (rip->p_flag & (SPAGI|SDETACH|SNUSIG));
	if (isvfork) {
		rpp->p_flag |= SVFORK;
		rpp->p_ndx = rip->p_ndx;
	} else
		rpp->p_ndx = rpp - proc;
	rpp->p_uid = rip->p_uid;
	rpp->p_pgrp = rip->p_pgrp;
	rpp->p_nice = rip->p_nice;
	rpp->p_textp = isvfork ? 0 : rip->p_textp;
	rpp->p_pid = mpid;
	rpp->p_ppid = rip->p_pid;
	rpp->p_pptr = rip;
	rpp->p_time = 0;
	rpp->p_cpu = 0;
	rpp->p_siga0 = rip->p_siga0;
	rpp->p_siga1 = rip->p_siga1;
	/* take along any pending signals, like stops? */
	if (isvfork) {
		rpp->p_tsize = rpp->p_dsize = rpp->p_ssize = 0;
		rpp->p_szpt = clrnd(ctopt(UPAGES));
		forkstat.cntvfork++;
		forkstat.sizvfork += rip->p_dsize + rip->p_ssize;
	} else {
		rpp->p_tsize = rip->p_tsize;
		rpp->p_dsize = rip->p_dsize;
		rpp->p_ssize = rip->p_ssize;
		rpp->p_szpt = rip->p_szpt;
		forkstat.cntfork++;
		forkstat.sizfork += rip->p_dsize + rip->p_ssize;
	}
	rpp->p_rssize = 0;
	rpp->p_wchan = 0;
	rpp->p_slptime = 0;
	rpp->p_pctcpu = 0;
	rpp->p_cpticks = 0;
	n = PIDHASH(rpp->p_pid);
	p->p_idhash = pidhash[n];
	pidhash[n] = rpp - proc;

	/*
	 * make duplicate entries
	 * where needed
	 */

	multprog++;

	for(n=0; n<NOFILE; n++)
		if(u.u_ofile[n] != NULL) {
			u.u_ofile[n]->f_count++;
			if(!isvfork && u.u_vrpages[n])
				u.u_ofile[n]->f_inode->i_vfdcnt++;
		}

	u.u_cdir->i_count++;
	if (u.u_rdir)
		u.u_rdir->i_count++;
	/*
	 * Partially simulate the environment
	 * of the new process so that when it is actually
	 * created (by copying) it will look right.
	 */

	rip->p_flag |= SKEEP;	/* prevent parent from being swapped */

	if (procdup(rpp, isvfork))
		return (1);

	spl6();
	rpp->p_stat = SRUN;
	setrq(rpp);
	spl0();
	/* SSWAP NOT NEEDED IN THIS CASE AS u.u_pcb.pcb_sswap SUFFICES */
	/* rpp->p_flag |= SSWAP; */
	rip->p_flag &= ~SKEEP;
	if (isvfork) {
		u.u_procp->p_xlink = rpp;
		u.u_procp->p_flag |= SNOVM;
		while (rpp->p_flag & SVFORK)
			sleep((caddr_t)rpp, PZERO - 1);
		if ((rpp->p_flag & SLOAD) == 0)
			panic("newproc vfork");
		uaccess(rpp, Vfmap, &vfutl);
		u.u_procp->p_xlink = 0;
		vpassvm(rpp, u.u_procp, &vfutl, &u, Vfmap);
		for (n = 0; n < NOFILE; n++)
			if (vfutl.u_vrpages[n]) {
				if ((u.u_vrpages[n] = vfutl.u_vrpages[n] - 1) == 0)
					if (--u.u_ofile[n]->f_inode->i_vfdcnt < 0)
						panic("newproc i_vfdcnt");
				vfutl.u_vrpages[n] = 0;
			}
		u.u_procp->p_flag &= ~SNOVM;
		rpp->p_ndx = rpp - proc;
		rpp->p_flag |= SVFDONE;
		wakeup((caddr_t)rpp);
	}
	return (0);
}
Commit	Line	Data
dd808ba3	1	/* kern_synch.c 3.15 %G% */
a379cce8 BJ	2
	3	#include "../h/param.h"
	4	#include "../h/systm.h"
	5	#include "../h/dir.h"
	6	#include "../h/user.h"
	7	#include "../h/proc.h"
	8	#include "../h/file.h"
	9	#include "../h/inode.h"
	10	#include "../h/vm.h"
	11	#include "../h/pte.h"
87d0f32e	12	#include "../h/inline.h"
a379cce8	13
a379cce8 BJ	14
	15	#define SQSIZE 0100 /* Must be power of 2 */
	16	#define HASH(x) (( (int) x >> 5) & (SQSIZE-1))
	17	struct proc *slpque[SQSIZE];
	18
	19	/*
	20	* Give up the processor till a wakeup occurs
	21	* on chan, at which time the process
	22	* enters the scheduling queue at priority pri.
	23	* The most important effect of pri is that when
	24	* pri<=PZERO a signal cannot disturb the sleep;
	25	* if pri>PZERO signals will be processed.
	26	* Callers of this routine must be prepared for
	27	* premature return, and check that the reason for
	28	* sleeping has gone away.
	29	*/
	30	sleep(chan, pri)
	31	caddr_t chan;
	32	{
e5df4be8	33	register struct proc rp, *hp;
6fdc0335	34	register s;
a379cce8 BJ	35
	36	rp = u.u_procp;
	37	s = spl6();
	38	if (chan==0 \|\| rp->p_stat != SRUN \|\| rp->p_rlink)
	39	panic("sleep");
a379cce8 BJ	40	rp->p_wchan = chan;
	41	rp->p_slptime = 0;
	42	rp->p_pri = pri;
e5df4be8 BJ	43	hp = &slpque[HASH(chan)];
	44	rp->p_link = *hp;
	45	*hp = rp;
a379cce8	46	if(pri > PZERO) {
87d0f32e	47	if(ISSIG(rp)) {
e5df4be8 BJ	48	if (rp->p_wchan)
e5df4be8 BJ	49	unsleep(rp);
a379cce8	50	rp->p_stat = SRUN;
81263dba	51	(void) spl0();
a379cce8 BJ	52	goto psig;
a379cce8 BJ	53	}
e5df4be8 BJ	54	if (rp->p_wchan == 0)
	55	goto out;
	56	rp->p_stat = SSLEEP;
81263dba	57	(void) spl0();
a379cce8 BJ	58	if(runin != 0) {
	59	runin = 0;
	60	wakeup((caddr_t)&runin);
	61	}
	62	swtch();
87d0f32e	63	if(ISSIG(rp))
a379cce8 BJ	64	goto psig;
a379cce8 BJ	65	} else {
6fdc0335	66	rp->p_stat = SSLEEP;
81263dba	67	(void) spl0();
a379cce8 BJ	68	swtch();
a379cce8 BJ	69	}
e5df4be8	70	out:
a379cce8 BJ	71	splx(s);
	72	return;
	73
	74	/*
	75	* If priority was low (>PZERO) and
	76	* there has been a signal,
	77	* execute non-local goto to
	78	* the qsav location.
	79	* (see trap1/trap.c)
	80	*/
	81	psig:
a379cce8	82	longjmp(u.u_qsav);
a379cce8 BJ	83	/NOTREACHED/
	84	}
	85
a7bf190d BJ	86	/*
	87	* Sleep on chan at pri.
	88	* Return in no more than the indicated number of seconds.
	89	* (If seconds==0, no timeout implied)
	90	* Return TS_OK if chan was awakened normally
	91	* TS_TIME if timeout occurred
	92	* TS_SIG if asynchronous signal occurred
	93	*/
	94	tsleep(chan, pri, seconds)
	95	caddr_t chan;
	96	{
	97	label_t lqsav;
	98	register struct proc *pp;
	99	register sec, n, rval;
	100
	101	pp = u.u_procp;
b05a921d	102	n = spl7();
a7bf190d BJ	103	sec = 0;
a7bf190d BJ	104	rval = 0;
a7bf190d BJ	105	if (pp->p_clktim && pp->p_clktim<seconds)
	106	seconds = 0;
	107	if (seconds) {
	108	pp->p_flag \|= STIMO;
06f9e714	109	sec = pp->p_clktim-seconds;
a7bf190d BJ	110	pp->p_clktim = seconds;
	111	}
	112	bcopy((caddr_t)u.u_qsav, (caddr_t)lqsav, sizeof (label_t));
	113	if (setjmp(u.u_qsav))
	114	rval = TS_SIG;
	115	else {
	116	sleep(chan, pri);
	117	if ((pp->p_flag&STIMO)==0 && seconds)
	118	rval = TS_TIME;
	119	else
	120	rval = TS_OK;
	121	}
	122	pp->p_flag &= ~STIMO;
	123	bcopy((caddr_t)lqsav, (caddr_t)u.u_qsav, sizeof (label_t));
06f9e714 BJ	124	if (sec > 0)
	125	pp->p_clktim += sec;
	126	else
	127	pp->p_clktim = 0;
a7bf190d BJ	128	splx(n);
	129	return(rval);
	130	}
	131
87d0f32e BJ	132	/*
	133	* Remove a process from its wait queue
	134	*/
	135	unsleep(p)
	136	register struct proc *p;
	137	{
	138	register struct proc **hp;
	139	register s;
	140
	141	s = spl6();
	142	if (p->p_wchan) {
	143	hp = &slpque[HASH(p->p_wchan)];
	144	while (*hp != p)
	145	hp = &(*hp)->p_link;
	146	*hp = p->p_link;
	147	p->p_wchan = 0;
	148	}
	149	splx(s);
	150	}
	151
a379cce8 BJ	152	/*
	153	* Wake up all processes sleeping on chan.
	154	*/
	155	wakeup(chan)
	156	register caddr_t chan;
	157	{
e5df4be8	158	register struct proc p, q, *h;
a379cce8 BJ	159	int s;
	160
	161	s = spl6();
e5df4be8	162	h = &slpque[HASH(chan)];
a379cce8	163	restart:
e5df4be8	164	for (q = h; p = *q; ) {
87d0f32e	165	if (p->p_rlink \|\| p->p_stat != SSLEEP && p->p_stat != SSTOP)
a379cce8	166	panic("wakeup");
6fdc0335	167	if (p->p_wchan==chan) {
a379cce8	168	p->p_wchan = 0;
e5df4be8	169	*q = p->p_link;
a379cce8	170	p->p_slptime = 0;
87d0f32e BJ	171	if (p->p_stat == SSLEEP) {
	172	/* OPTIMIZED INLINE EXPANSION OF setrun(p) */
	173	p->p_stat = SRUN;
	174	if (p->p_flag & SLOAD) {
a379cce8	175	#ifndef FASTVAX
87d0f32e BJ	176	p->p_link = runq;
87d0f32e BJ	177	runq = p->p_link;
a379cce8	178	#else
87d0f32e	179	setrq(p);
a379cce8	180	#endif
87d0f32e BJ	181	}
	182	if(p->p_pri < curpri)
	183	runrun++;
	184	if(runout != 0 && (p->p_flag&SLOAD) == 0) {
	185	runout = 0;
	186	wakeup((caddr_t)&runout);
	187	}
	188	/* END INLINE EXPANSION */
e5df4be8	189	goto restart;
a379cce8	190	}
e5df4be8 BJ	191	} else
e5df4be8 BJ	192	q = &p->p_link;
a379cce8 BJ	193	}
	194	splx(s);
	195	}
	196
	197	#ifdef FASTVAX
	198	/*
	199	* Initialize the (doubly-linked) run queues
	200	* to be empty.
	201	*/
	202	rqinit()
	203	{
	204	register int i;
	205
	206	for (i = 0; i < NQS; i++)
	207	qs[i].ph_link = qs[i].ph_rlink = (struct proc *)&qs[i];
	208	}
	209	#endif
	210
	211	/*
	212	* Set the process running;
	213	* arrange for it to be swapped in if necessary.
	214	*/
	215	setrun(p)
	216	register struct proc *p;
	217	{
a379cce8 BJ	218	register s;
	219
	220	s = spl6();
	221	switch (p->p_stat) {
	222
	223	case 0:
	224	case SWAIT:
	225	case SRUN:
	226	case SZOMB:
	227	default:
	228	panic("setrun");
	229
6fdc0335	230	case SSTOP:
a379cce8	231	case SSLEEP:
87d0f32e	232	unsleep(p); /* e.g. when sending signals */
a379cce8 BJ	233	break;
	234
	235	case SIDL:
a379cce8 BJ	236	break;
	237	}
	238	p->p_stat = SRUN;
	239	if (p->p_flag & SLOAD)
	240	setrq(p);
	241	splx(s);
	242	if(p->p_pri < curpri)
	243	runrun++;
	244	if(runout != 0 && (p->p_flag&SLOAD) == 0) {
	245	runout = 0;
	246	wakeup((caddr_t)&runout);
	247	}
	248	}
	249
	250	/*
	251	* Set user priority.
	252	* The rescheduling flag (runrun)
	253	* is set if the priority is better
	254	* than the currently running process.
	255	*/
	256	setpri(pp)
	257	register struct proc *pp;
	258	{
	259	register p;
	260
	261	p = (pp->p_cpu & 0377)/16;
	262	p += PUSER + pp->p_nice - NZERO;
	263	if(p > 127)
	264	p = 127;
	265	if(p < curpri)
	266	runrun++;
	267	pp->p_usrpri = p;
	268	return(p);
	269	}
	270
	271	/*
	272	* Create a new process-- the internal version of
	273	* sys fork.
	274	* It returns 1 in the new process, 0 in the old.
	275	*/
	276	newproc(isvfork)
	277	{
	278	register struct proc *p;
	279	register struct proc rpp, rip;
	280	register int n;
	281
	282	p = NULL;
	283	/*
	284	* First, just locate a slot for a process
	285	* and copy the useful info from this process into it.
	286	* The panic "cannot happen" because fork has already
	287	* checked for the existence of a slot.
	288	*/
	289	retry:
	290	mpid++;
	291	if(mpid >= 30000) {
	292	mpid = 0;
	293	goto retry;
	294	}
	295	for(rpp = &proc[0]; rpp < &proc[NPROC]; rpp++) {
	296	if(rpp->p_stat == NULL && p==NULL)
	297	p = rpp;
	298	if (rpp->p_pid==mpid \|\| rpp->p_pgrp==mpid)
	299	goto retry;
300	}
301	if ((rpp = p)==NULL)
302	panic("no procs");
303
304	/*
305	* make proc entry for new proc
306	*/
307
308	rip = u.u_procp;
309	rpp->p_stat = SIDL;
310	rpp->p_clktim = 0;
49745575	311	rpp->p_flag = SLOAD \| (rip->p_flag & (SPAGI\|SDETACH\|SNUSIG));
a379cce8 BJ	312	if (isvfork) {
	313	rpp->p_flag \|= SVFORK;
	314	rpp->p_ndx = rip->p_ndx;
	315	} else
	316	rpp->p_ndx = rpp - proc;
	317	rpp->p_uid = rip->p_uid;
	318	rpp->p_pgrp = rip->p_pgrp;
	319	rpp->p_nice = rip->p_nice;
	320	rpp->p_textp = isvfork ? 0 : rip->p_textp;
	321	rpp->p_pid = mpid;
	322	rpp->p_ppid = rip->p_pid;
87d0f32e	323	rpp->p_pptr = rip;
a379cce8 BJ	324	rpp->p_time = 0;
a379cce8 BJ	325	rpp->p_cpu = 0;
87d0f32e BJ	326	rpp->p_siga0 = rip->p_siga0;
	327	rpp->p_siga1 = rip->p_siga1;
	328	/* take along any pending signals, like stops? */
a379cce8 BJ	329	if (isvfork) {
	330	rpp->p_tsize = rpp->p_dsize = rpp->p_ssize = 0;
	331	rpp->p_szpt = clrnd(ctopt(UPAGES));
	332	forkstat.cntvfork++;
	333	forkstat.sizvfork += rip->p_dsize + rip->p_ssize;
	334	} else {
	335	rpp->p_tsize = rip->p_tsize;
	336	rpp->p_dsize = rip->p_dsize;
	337	rpp->p_ssize = rip->p_ssize;
	338	rpp->p_szpt = rip->p_szpt;
	339	forkstat.cntfork++;
	340	forkstat.sizfork += rip->p_dsize + rip->p_ssize;
	341	}
	342	rpp->p_rssize = 0;
	343	rpp->p_wchan = 0;
	344	rpp->p_slptime = 0;
dd808ba3 BJ	345	rpp->p_pctcpu = 0;
dd808ba3 BJ	346	rpp->p_cpticks = 0;
a379cce8 BJ	347	n = PIDHASH(rpp->p_pid);
	348	p->p_idhash = pidhash[n];
	349	pidhash[n] = rpp - proc;
	350
	351	/*
	352	* make duplicate entries
	353	* where needed
	354	*/
	355
	356	multprog++;
	357
	358	for(n=0; n<NOFILE; n++)
	359	if(u.u_ofile[n] != NULL) {
	360	u.u_ofile[n]->f_count++;
	361	if(!isvfork && u.u_vrpages[n])
	362	u.u_ofile[n]->f_inode->i_vfdcnt++;
	363	}
	364
	365	u.u_cdir->i_count++;
	366	if (u.u_rdir)
	367	u.u_rdir->i_count++;
	368	/*
	369	* Partially simulate the environment
	370	* of the new process so that when it is actually
	371	* created (by copying) it will look right.
	372	*/
	373
	374	rip->p_flag \|= SKEEP; /* prevent parent from being swapped */
	375
	376	if (procdup(rpp, isvfork))
	377	return (1);
	378
	379	spl6();
	380	rpp->p_stat = SRUN;
	381	setrq(rpp);
	382	spl0();
e56fe3d3	383	/* SSWAP NOT NEEDED IN THIS CASE AS u.u_pcb.pcb_sswap SUFFICES */
a379cce8 BJ	384	/* rpp->p_flag \|= SSWAP; */
	385	rip->p_flag &= ~SKEEP;
	386	if (isvfork) {
	387	u.u_procp->p_xlink = rpp;
	388	u.u_procp->p_flag \|= SNOVM;
	389	while (rpp->p_flag & SVFORK)
	390	sleep((caddr_t)rpp, PZERO - 1);
	391	if ((rpp->p_flag & SLOAD) == 0)
	392	panic("newproc vfork");
	393	uaccess(rpp, Vfmap, &vfutl);
	394	u.u_procp->p_xlink = 0;
	395	vpassvm(rpp, u.u_procp, &vfutl, &u, Vfmap);
	396	for (n = 0; n < NOFILE; n++)
	397	if (vfutl.u_vrpages[n]) {
	398	if ((u.u_vrpages[n] = vfutl.u_vrpages[n] - 1) == 0)
	399	if (--u.u_ofile[n]->f_inode->i_vfdcnt < 0)
	400	panic("newproc i_vfdcnt");
	401	vfutl.u_vrpages[n] = 0;
	402	}
	403	u.u_procp->p_flag &= ~SNOVM;
	404	rpp->p_ndx = rpp - proc;
	405	rpp->p_flag \|= SVFDONE;
	406	wakeup((caddr_t)rpp);
	407	}
	408	return (0);
	409	}