Fix fork/vfork statistics. forks and vforks were being improperly counted
[dragonfly.git] / sys / kern / kern_fork.c
1 /*
2  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * (c) UNIX System Laboratories, Inc.
5  * All or some portions of this file are derived from material licensed
6  * to the University of California by American Telephone and Telegraph
7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
8  * the permission of UNIX System Laboratories, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  *      @(#)kern_fork.c 8.6 (Berkeley) 4/8/94
39  * $FreeBSD: src/sys/kern/kern_fork.c,v 1.72.2.14 2003/06/26 04:15:10 silby Exp $
40  * $DragonFly: src/sys/kern/kern_fork.c,v 1.76 2008/05/09 06:38:19 dillon Exp $
41  */
42
43 #include "opt_ktrace.h"
44
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/sysproto.h>
48 #include <sys/filedesc.h>
49 #include <sys/kernel.h>
50 #include <sys/sysctl.h>
51 #include <sys/malloc.h>
52 #include <sys/proc.h>
53 #include <sys/resourcevar.h>
54 #include <sys/vnode.h>
55 #include <sys/acct.h>
56 #include <sys/ktrace.h>
57 #include <sys/unistd.h>
58 #include <sys/jail.h>
59 #include <sys/caps.h>
60
61 #include <vm/vm.h>
62 #include <sys/lock.h>
63 #include <vm/pmap.h>
64 #include <vm/vm_map.h>
65 #include <vm/vm_extern.h>
66 #include <vm/vm_zone.h>
67
68 #include <sys/vmmeter.h>
69 #include <sys/thread2.h>
70 #include <sys/signal2.h>
71 #include <sys/spinlock2.h>
72
73 static MALLOC_DEFINE(M_ATFORK, "atfork", "atfork callback");
74
75 /*
76  * These are the stuctures used to create a callout list for things to do
77  * when forking a process
78  */
79 struct forklist {
80         forklist_fn function;
81         TAILQ_ENTRY(forklist) next;
82 };
83
84 TAILQ_HEAD(forklist_head, forklist);
85 static struct forklist_head fork_list = TAILQ_HEAD_INITIALIZER(fork_list);
86
87 static struct lwp *lwp_fork(struct lwp *, struct proc *, int flags);
88
89 int forksleep; /* Place for fork1() to sleep on. */
90
91 /*
92  * Red-Black tree support for LWPs
93  */
94
95 static int
96 rb_lwp_compare(struct lwp *lp1, struct lwp *lp2)
97 {
98         if (lp1->lwp_tid < lp2->lwp_tid)
99                 return(-1);
100         if (lp1->lwp_tid > lp2->lwp_tid)
101                 return(1);
102         return(0);
103 }
104
105 RB_GENERATE2(lwp_rb_tree, lwp, u.lwp_rbnode, rb_lwp_compare, lwpid_t, lwp_tid);
106
107
108 /* ARGSUSED */
109 int
110 sys_fork(struct fork_args *uap)
111 {
112         struct lwp *lp = curthread->td_lwp;
113         struct proc *p2;
114         int error;
115
116         error = fork1(lp, RFFDG | RFPROC | RFPGLOCK, &p2);
117         if (error == 0) {
118                 start_forked_proc(lp, p2);
119                 uap->sysmsg_fds[0] = p2->p_pid;
120                 uap->sysmsg_fds[1] = 0;
121         }
122         return error;
123 }
124
125 /* ARGSUSED */
126 int
127 sys_vfork(struct vfork_args *uap)
128 {
129         struct lwp *lp = curthread->td_lwp;
130         struct proc *p2;
131         int error;
132
133         error = fork1(lp, RFFDG | RFPROC | RFPPWAIT | RFMEM | RFPGLOCK, &p2);
134         if (error == 0) {
135                 start_forked_proc(lp, p2);
136                 uap->sysmsg_fds[0] = p2->p_pid;
137                 uap->sysmsg_fds[1] = 0;
138         }
139         return error;
140 }
141
142 /*
143  * Handle rforks.  An rfork may (1) operate on the current process without
144  * creating a new, (2) create a new process that shared the current process's
145  * vmspace, signals, and/or descriptors, or (3) create a new process that does
146  * not share these things (normal fork).
147  *
148  * Note that we only call start_forked_proc() if a new process is actually
149  * created.
150  *
151  * rfork { int flags }
152  */
153 int
154 sys_rfork(struct rfork_args *uap)
155 {
156         struct lwp *lp = curthread->td_lwp;
157         struct proc *p2;
158         int error;
159
160         if ((uap->flags & RFKERNELONLY) != 0)
161                 return (EINVAL);
162
163         error = fork1(lp, uap->flags | RFPGLOCK, &p2);
164         if (error == 0) {
165                 if (p2)
166                         start_forked_proc(lp, p2);
167                 uap->sysmsg_fds[0] = p2 ? p2->p_pid : 0;
168                 uap->sysmsg_fds[1] = 0;
169         }
170         return error;
171 }
172
173 int
174 sys_lwp_create(struct lwp_create_args *uap)
175 {
176         struct proc *p = curproc;
177         struct lwp *lp;
178         struct lwp_params params;
179         int error;
180
181         error = copyin(uap->params, &params, sizeof(params));
182         if (error)
183                 goto fail2;
184
185         plimit_lwp_fork(p);     /* force exclusive access */
186         lp = lwp_fork(curthread->td_lwp, p, RFPROC);
187         error = cpu_prepare_lwp(lp, &params);
188         if (params.tid1 != NULL &&
189             (error = copyout(&lp->lwp_tid, params.tid1, sizeof(lp->lwp_tid))))
190                 goto fail;
191         if (params.tid2 != NULL &&
192             (error = copyout(&lp->lwp_tid, params.tid2, sizeof(lp->lwp_tid))))
193                 goto fail;
194
195         /*
196          * Now schedule the new lwp. 
197          */
198         p->p_usched->resetpriority(lp);
199         crit_enter();
200         lp->lwp_stat = LSRUN;
201         p->p_usched->setrunqueue(lp);
202         crit_exit();
203
204         return (0);
205
206 fail:
207         lwp_rb_tree_RB_REMOVE(&p->p_lwp_tree, lp);
208         --p->p_nthreads;
209         /* lwp_dispose expects an exited lwp, and a held proc */
210         lp->lwp_flag |= LWP_WEXIT;
211         lp->lwp_thread->td_flags |= TDF_EXITING;
212         PHOLD(p);
213         lwp_dispose(lp);
214 fail2:
215         return (error);
216 }
217
218 int     nprocs = 1;             /* process 0 */
219
220 int
221 fork1(struct lwp *lp1, int flags, struct proc **procp)
222 {
223         struct proc *p1 = lp1->lwp_proc;
224         struct proc *p2, *pptr;
225         struct pgrp *pgrp;
226         uid_t uid;
227         int ok, error;
228         static int curfail = 0;
229         static struct timeval lastfail;
230         struct forklist *ep;
231         struct filedesc_to_leader *fdtol;
232
233         if ((flags & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
234                 return (EINVAL);
235
236         /*
237          * Here we don't create a new process, but we divorce
238          * certain parts of a process from itself.
239          */
240         if ((flags & RFPROC) == 0) {
241                 /*
242                  * This kind of stunt does not work anymore if
243                  * there are native threads (lwps) running
244                  */
245                 if (p1->p_nthreads != 1)
246                         return (EINVAL);
247
248                 vm_fork(p1, 0, flags);
249
250                 /*
251                  * Close all file descriptors.
252                  */
253                 if (flags & RFCFDG) {
254                         struct filedesc *fdtmp;
255                         fdtmp = fdinit(p1);
256                         fdfree(p1);
257                         p1->p_fd = fdtmp;
258                 }
259
260                 /*
261                  * Unshare file descriptors (from parent.)
262                  */
263                 if (flags & RFFDG) {
264                         if (p1->p_fd->fd_refcnt > 1) {
265                                 struct filedesc *newfd;
266                                 newfd = fdcopy(p1);
267                                 fdfree(p1);
268                                 p1->p_fd = newfd;
269                         }
270                 }
271                 *procp = NULL;
272                 return (0);
273         }
274
275         /*
276          * Interlock against process group signal delivery.  If signals
277          * are pending after the interlock is obtained we have to restart
278          * the system call to process the signals.  If we don't the child
279          * can miss a pgsignal (such as ^C) sent during the fork.
280          *
281          * We can't use CURSIG() here because it will process any STOPs
282          * and cause the process group lock to be held indefinitely.  If
283          * a STOP occurs, the fork will be restarted after the CONT.
284          */
285         error = 0;
286         pgrp = NULL;
287         if ((flags & RFPGLOCK) && (pgrp = p1->p_pgrp) != NULL) {
288                 lockmgr(&pgrp->pg_lock, LK_SHARED);
289                 if (CURSIGNB(lp1)) {
290                         error = ERESTART;
291                         goto done;
292                 }
293         }
294
295         /*
296          * Although process entries are dynamically created, we still keep
297          * a global limit on the maximum number we will create.  Don't allow
298          * a nonprivileged user to use the last ten processes; don't let root
299          * exceed the limit. The variable nprocs is the current number of
300          * processes, maxproc is the limit.
301          */
302         uid = p1->p_ucred->cr_ruid;
303         if ((nprocs >= maxproc - 10 && uid != 0) || nprocs >= maxproc) {
304                 if (ppsratecheck(&lastfail, &curfail, 1))
305                         kprintf("maxproc limit exceeded by uid %d, please "
306                                "see tuning(7) and login.conf(5).\n", uid);
307                 tsleep(&forksleep, 0, "fork", hz / 2);
308                 error = EAGAIN;
309                 goto done;
310         }
311         /*
312          * Increment the nprocs resource before blocking can occur.  There
313          * are hard-limits as to the number of processes that can run.
314          */
315         nprocs++;
316
317         /*
318          * Increment the count of procs running with this uid. Don't allow
319          * a nonprivileged user to exceed their current limit.
320          */
321         ok = chgproccnt(p1->p_ucred->cr_ruidinfo, 1,
322                 (uid != 0) ? p1->p_rlimit[RLIMIT_NPROC].rlim_cur : 0);
323         if (!ok) {
324                 /*
325                  * Back out the process count
326                  */
327                 nprocs--;
328                 if (ppsratecheck(&lastfail, &curfail, 1))
329                         kprintf("maxproc limit exceeded by uid %d, please "
330                                "see tuning(7) and login.conf(5).\n", uid);
331                 tsleep(&forksleep, 0, "fork", hz / 2);
332                 error = EAGAIN;
333                 goto done;
334         }
335
336         /* Allocate new proc. */
337         p2 = kmalloc(sizeof(struct proc), M_PROC, M_WAITOK|M_ZERO);
338
339         /*
340          * Setup linkage for kernel based threading XXX lwp
341          */
342         if (flags & RFTHREAD) {
343                 p2->p_peers = p1->p_peers;
344                 p1->p_peers = p2;
345                 p2->p_leader = p1->p_leader;
346         } else {
347                 p2->p_leader = p2;
348         }
349
350         RB_INIT(&p2->p_lwp_tree);
351         spin_init(&p2->p_spin);
352         p2->p_lasttid = -1;     /* first tid will be 0 */
353
354         /*
355          * Setting the state to SIDL protects the partially initialized
356          * process once it starts getting hooked into the rest of the system.
357          */
358         p2->p_stat = SIDL;
359         proc_add_allproc(p2);
360
361         /*
362          * Make a proc table entry for the new process.
363          * The whole structure was zeroed above, so copy the section that is
364          * copied directly from the parent.
365          */
366         bcopy(&p1->p_startcopy, &p2->p_startcopy,
367             (unsigned) ((caddr_t)&p2->p_endcopy - (caddr_t)&p2->p_startcopy));
368
369         /*
370          * Duplicate sub-structures as needed.
371          * Increase reference counts on shared objects.
372          */
373         if (p1->p_flag & P_PROFIL)
374                 startprofclock(p2);
375         p2->p_ucred = crhold(p1->p_ucred);
376
377         if (jailed(p2->p_ucred))
378                 p2->p_flag |= P_JAILED;
379
380         if (p2->p_args)
381                 p2->p_args->ar_ref++;
382
383         p2->p_usched = p1->p_usched;
384
385         if (flags & RFSIGSHARE) {
386                 p2->p_sigacts = p1->p_sigacts;
387                 p2->p_sigacts->ps_refcnt++;
388         } else {
389                 p2->p_sigacts = (struct sigacts *)kmalloc(sizeof(*p2->p_sigacts),
390                     M_SUBPROC, M_WAITOK);
391                 bcopy(p1->p_sigacts, p2->p_sigacts, sizeof(*p2->p_sigacts));
392                 p2->p_sigacts->ps_refcnt = 1;
393         }
394         if (flags & RFLINUXTHPN) 
395                 p2->p_sigparent = SIGUSR1;
396         else
397                 p2->p_sigparent = SIGCHLD;
398
399         /* bump references to the text vnode (for procfs) */
400         p2->p_textvp = p1->p_textvp;
401         if (p2->p_textvp)
402                 vref(p2->p_textvp);
403
404         /*
405          * Handle file descriptors
406          */
407         if (flags & RFCFDG) {
408                 p2->p_fd = fdinit(p1);
409                 fdtol = NULL;
410         } else if (flags & RFFDG) {
411                 p2->p_fd = fdcopy(p1);
412                 fdtol = NULL;
413         } else {
414                 p2->p_fd = fdshare(p1);
415                 if (p1->p_fdtol == NULL)
416                         p1->p_fdtol =
417                                 filedesc_to_leader_alloc(NULL,
418                                                          p1->p_leader);
419                 if ((flags & RFTHREAD) != 0) {
420                         /*
421                          * Shared file descriptor table and
422                          * shared process leaders.
423                          */
424                         fdtol = p1->p_fdtol;
425                         fdtol->fdl_refcount++;
426                 } else {
427                         /* 
428                          * Shared file descriptor table, and
429                          * different process leaders 
430                          */
431                         fdtol = filedesc_to_leader_alloc(p1->p_fdtol, p2);
432                 }
433         }
434         p2->p_fdtol = fdtol;
435         p2->p_limit = plimit_fork(p1);
436
437         /*
438          * Preserve some more flags in subprocess.  P_PROFIL has already
439          * been preserved.
440          */
441         p2->p_flag |= p1->p_flag & P_SUGID;
442         if (p1->p_session->s_ttyvp != NULL && p1->p_flag & P_CONTROLT)
443                 p2->p_flag |= P_CONTROLT;
444         if (flags & RFPPWAIT)
445                 p2->p_flag |= P_PPWAIT;
446
447         /*
448          * Inherit the virtual kernel structure (allows a virtual kernel
449          * to fork to simulate multiple cpus).
450          */
451         if (p1->p_vkernel)
452                 vkernel_inherit(p1, p2);
453
454         /*
455          * Once we are on a pglist we may receive signals.  XXX we might
456          * race a ^C being sent to the process group by not receiving it
457          * at all prior to this line.
458          */
459         LIST_INSERT_AFTER(p1, p2, p_pglist);
460
461         /*
462          * Attach the new process to its parent.
463          *
464          * If RFNOWAIT is set, the newly created process becomes a child
465          * of init.  This effectively disassociates the child from the
466          * parent.
467          */
468         if (flags & RFNOWAIT)
469                 pptr = initproc;
470         else
471                 pptr = p1;
472         p2->p_pptr = pptr;
473         LIST_INSERT_HEAD(&pptr->p_children, p2, p_sibling);
474         LIST_INIT(&p2->p_children);
475         varsymset_init(&p2->p_varsymset, &p1->p_varsymset);
476         callout_init(&p2->p_ithandle);
477
478 #ifdef KTRACE
479         /*
480          * Copy traceflag and tracefile if enabled.  If not inherited,
481          * these were zeroed above but we still could have a trace race
482          * so make sure p2's p_tracenode is NULL.
483          */
484         if ((p1->p_traceflag & KTRFAC_INHERIT) && p2->p_tracenode == NULL) {
485                 p2->p_traceflag = p1->p_traceflag;
486                 p2->p_tracenode = ktrinherit(p1->p_tracenode);
487         }
488 #endif
489
490         /*
491          * This begins the section where we must prevent the parent
492          * from being swapped.
493          *
494          * Gets PRELE'd in the caller in start_forked_proc().
495          */
496         PHOLD(p1);
497
498         vm_fork(p1, p2, flags);
499
500         /*
501          * Create the first lwp associated with the new proc.
502          * It will return via a different execution path later, directly
503          * into userland, after it was put on the runq by
504          * start_forked_proc().
505          */
506         lwp_fork(lp1, p2, flags);
507
508         if (flags == (RFFDG | RFPROC | RFPGLOCK)) {
509                 mycpu->gd_cnt.v_forks++;
510                 mycpu->gd_cnt.v_forkpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
511         } else if (flags == (RFFDG | RFPROC | RFPPWAIT | RFMEM | RFPGLOCK)) {
512                 mycpu->gd_cnt.v_vforks++;
513                 mycpu->gd_cnt.v_vforkpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
514         } else if (p1 == &proc0) {
515                 mycpu->gd_cnt.v_kthreads++;
516                 mycpu->gd_cnt.v_kthreadpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
517         } else {
518                 mycpu->gd_cnt.v_rforks++;
519                 mycpu->gd_cnt.v_rforkpages += p2->p_vmspace->vm_dsize + p2->p_vmspace->vm_ssize;
520         }
521
522         /*
523          * Both processes are set up, now check if any loadable modules want
524          * to adjust anything.
525          *   What if they have an error? XXX
526          */
527         TAILQ_FOREACH(ep, &fork_list, next) {
528                 (*ep->function)(p1, p2, flags);
529         }
530
531         /*
532          * Set the start time.  Note that the process is not runnable.  The
533          * caller is responsible for making it runnable.
534          */
535         microtime(&p2->p_start);
536         p2->p_acflag = AFORK;
537
538         /*
539          * tell any interested parties about the new process
540          */
541         KNOTE(&p1->p_klist, NOTE_FORK | p2->p_pid);
542
543         /*
544          * Return child proc pointer to parent.
545          */
546         *procp = p2;
547 done:
548         if (pgrp)
549                 lockmgr(&pgrp->pg_lock, LK_RELEASE);
550         return (error);
551 }
552
553 static struct lwp *
554 lwp_fork(struct lwp *origlp, struct proc *destproc, int flags)
555 {
556         struct lwp *lp;
557         struct thread *td;
558
559         lp = zalloc(lwp_zone);
560         bzero(lp, sizeof(*lp));
561
562         lp->lwp_proc = destproc;
563         lp->lwp_vmspace = destproc->p_vmspace;
564         lp->lwp_stat = LSRUN;
565         bcopy(&origlp->lwp_startcopy, &lp->lwp_startcopy,
566             (unsigned) ((caddr_t)&lp->lwp_endcopy -
567                         (caddr_t)&lp->lwp_startcopy));
568         lp->lwp_flag |= origlp->lwp_flag & LWP_ALTSTACK;
569         /*
570          * Set cpbase to the last timeout that occured (not the upcoming
571          * timeout).
572          *
573          * A critical section is required since a timer IPI can update
574          * scheduler specific data.
575          */
576         crit_enter();
577         lp->lwp_cpbase = mycpu->gd_schedclock.time -
578                         mycpu->gd_schedclock.periodic;
579         destproc->p_usched->heuristic_forking(origlp, lp);
580         crit_exit();
581         lp->lwp_cpumask &= usched_mastermask;
582
583         /*
584          * Assign a TID to the lp.  Loop until the insert succeeds (returns
585          * NULL).
586          */
587         lp->lwp_tid = destproc->p_lasttid;
588         do {
589                 if (++lp->lwp_tid < 0)
590                         lp->lwp_tid = 1;
591         } while (lwp_rb_tree_RB_INSERT(&destproc->p_lwp_tree, lp) != NULL);
592         destproc->p_lasttid = lp->lwp_tid;
593         destproc->p_nthreads++;
594
595         td = lwkt_alloc_thread(NULL, LWKT_THREAD_STACK, -1, 0);
596         lp->lwp_thread = td;
597         td->td_proc = destproc;
598         td->td_lwp = lp;
599         td->td_switch = cpu_heavy_switch;
600 #ifdef SMP
601         KKASSERT(td->td_mpcount == 1);
602 #endif
603         lwkt_setpri(td, TDPRI_KERN_USER);
604         lwkt_set_comm(td, "%s", destproc->p_comm);
605
606         /*
607          * cpu_fork will copy and update the pcb, set up the kernel stack,
608          * and make the child ready to run.
609          */
610         cpu_fork(origlp, lp, flags);
611         caps_fork(origlp->lwp_thread, lp->lwp_thread);
612
613         return (lp);
614 }
615
616 /*
617  * The next two functionms are general routines to handle adding/deleting
618  * items on the fork callout list.
619  *
620  * at_fork():
621  * Take the arguments given and put them onto the fork callout list,
622  * However first make sure that it's not already there.
623  * Returns 0 on success or a standard error number.
624  */
625 int
626 at_fork(forklist_fn function)
627 {
628         struct forklist *ep;
629
630 #ifdef INVARIANTS
631         /* let the programmer know if he's been stupid */
632         if (rm_at_fork(function)) {
633                 kprintf("WARNING: fork callout entry (%p) already present\n",
634                     function);
635         }
636 #endif
637         ep = kmalloc(sizeof(*ep), M_ATFORK, M_WAITOK|M_ZERO);
638         ep->function = function;
639         TAILQ_INSERT_TAIL(&fork_list, ep, next);
640         return (0);
641 }
642
643 /*
644  * Scan the exit callout list for the given item and remove it..
645  * Returns the number of items removed (0 or 1)
646  */
647 int
648 rm_at_fork(forklist_fn function)
649 {
650         struct forklist *ep;
651
652         TAILQ_FOREACH(ep, &fork_list, next) {
653                 if (ep->function == function) {
654                         TAILQ_REMOVE(&fork_list, ep, next);
655                         kfree(ep, M_ATFORK);
656                         return(1);
657                 }
658         }       
659         return (0);
660 }
661
662 /*
663  * Add a forked process to the run queue after any remaining setup, such
664  * as setting the fork handler, has been completed.
665  */
666 void
667 start_forked_proc(struct lwp *lp1, struct proc *p2)
668 {
669         struct lwp *lp2 = ONLY_LWP_IN_PROC(p2);
670
671         /*
672          * Move from SIDL to RUN queue, and activate the process's thread.
673          * Activation of the thread effectively makes the process "a"
674          * current process, so we do not setrunqueue().
675          *
676          * YYY setrunqueue works here but we should clean up the trampoline
677          * code so we just schedule the LWKT thread and let the trampoline
678          * deal with the userland scheduler on return to userland.
679          */
680         KASSERT(p2->p_stat == SIDL,
681             ("cannot start forked process, bad status: %p", p2));
682         p2->p_usched->resetpriority(lp2);
683         crit_enter();
684         p2->p_stat = SACTIVE;
685         lp2->lwp_stat = LSRUN;
686         p2->p_usched->setrunqueue(lp2);
687         crit_exit();
688
689         /*
690          * Now can be swapped.
691          */
692         PRELE(lp1->lwp_proc);
693
694         /*
695          * Preserve synchronization semantics of vfork.  If waiting for
696          * child to exec or exit, set P_PPWAIT on child, and sleep on our
697          * proc (in case of exit).
698          */
699         while (p2->p_flag & P_PPWAIT)
700                 tsleep(lp1->lwp_proc, 0, "ppwait", 0);
701 }