17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
5ab9a77c7Sahl * Common Development and Distribution License (the "License").
6ab9a77c7Sahl * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
218132eb48Sraf
227c478bd9Sstevel@tonic-gate /*
23ff19e029SMenno Lageman * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
242dc692e0SJerry Jelinek * Copyright 2013, Joyent, Inc. All rights reserved.
257c478bd9Sstevel@tonic-gate */
267c478bd9Sstevel@tonic-gate
277c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
287c478bd9Sstevel@tonic-gate /* All Rights Reserved */
297c478bd9Sstevel@tonic-gate
307c478bd9Sstevel@tonic-gate #include <sys/types.h>
317c478bd9Sstevel@tonic-gate #include <sys/param.h>
327c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
337c478bd9Sstevel@tonic-gate #include <sys/signal.h>
347c478bd9Sstevel@tonic-gate #include <sys/cred.h>
357c478bd9Sstevel@tonic-gate #include <sys/policy.h>
367c478bd9Sstevel@tonic-gate #include <sys/user.h>
377c478bd9Sstevel@tonic-gate #include <sys/systm.h>
387c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
397c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
407c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
417c478bd9Sstevel@tonic-gate #include <sys/file.h>
427c478bd9Sstevel@tonic-gate #include <sys/errno.h>
437c478bd9Sstevel@tonic-gate #include <sys/time.h>
447c478bd9Sstevel@tonic-gate #include <sys/proc.h>
457c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
467c478bd9Sstevel@tonic-gate #include <sys/acct.h>
477c478bd9Sstevel@tonic-gate #include <sys/tuneable.h>
487c478bd9Sstevel@tonic-gate #include <sys/class.h>
497c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
507c478bd9Sstevel@tonic-gate #include <sys/session.h>
517c478bd9Sstevel@tonic-gate #include <sys/ucontext.h>
527c478bd9Sstevel@tonic-gate #include <sys/stack.h>
537c478bd9Sstevel@tonic-gate #include <sys/procfs.h>
547c478bd9Sstevel@tonic-gate #include <sys/prsystm.h>
557c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h>
567c478bd9Sstevel@tonic-gate #include <sys/vtrace.h>
577c478bd9Sstevel@tonic-gate #include <sys/debug.h>
587c478bd9Sstevel@tonic-gate #include <sys/shm_impl.h>
597c478bd9Sstevel@tonic-gate #include <sys/door_data.h>
607c478bd9Sstevel@tonic-gate #include <vm/as.h>
617c478bd9Sstevel@tonic-gate #include <vm/rm.h>
627c478bd9Sstevel@tonic-gate #include <c2/audit.h>
637c478bd9Sstevel@tonic-gate #include <sys/var.h>
647c478bd9Sstevel@tonic-gate #include <sys/schedctl.h>
657c478bd9Sstevel@tonic-gate #include <sys/utrap.h>
667c478bd9Sstevel@tonic-gate #include <sys/task.h>
677c478bd9Sstevel@tonic-gate #include <sys/resource.h>
687c478bd9Sstevel@tonic-gate #include <sys/cyclic.h>
697c478bd9Sstevel@tonic-gate #include <sys/lgrp.h>
707c478bd9Sstevel@tonic-gate #include <sys/rctl.h>
717c478bd9Sstevel@tonic-gate #include <sys/contract_impl.h>
727c478bd9Sstevel@tonic-gate #include <sys/contract/process_impl.h>
737c478bd9Sstevel@tonic-gate #include <sys/list.h>
747c478bd9Sstevel@tonic-gate #include <sys/dtrace.h>
757c478bd9Sstevel@tonic-gate #include <sys/pool.h>
767c478bd9Sstevel@tonic-gate #include <sys/zone.h>
777c478bd9Sstevel@tonic-gate #include <sys/sdt.h>
787c478bd9Sstevel@tonic-gate #include <sys/class.h>
797c478bd9Sstevel@tonic-gate #include <sys/corectl.h>
809acbbeafSnn #include <sys/brand.h>
81657b1f3dSraf #include <sys/fork.h>
827c478bd9Sstevel@tonic-gate
83657b1f3dSraf static int64_t cfork(int, int, int);
8435a5a358SJonathan Adams static int getproc(proc_t **, pid_t, uint_t);
8535a5a358SJonathan Adams #define GETPROC_USER 0x0
8635a5a358SJonathan Adams #define GETPROC_KERNEL 0x1
8735a5a358SJonathan Adams
887c478bd9Sstevel@tonic-gate static void fork_fail(proc_t *);
897c478bd9Sstevel@tonic-gate static void forklwp_fail(proc_t *);
907c478bd9Sstevel@tonic-gate
917c478bd9Sstevel@tonic-gate int fork_fail_pending;
927c478bd9Sstevel@tonic-gate
937c478bd9Sstevel@tonic-gate extern struct kmem_cache *process_cache;
947c478bd9Sstevel@tonic-gate
957c478bd9Sstevel@tonic-gate /*
968fd04b83SRoger A. Faulkner * The vfork() system call trap is no longer invoked by libc.
978fd04b83SRoger A. Faulkner * It is retained only for the benefit of applications running
988fd04b83SRoger A. Faulkner * within a solaris10 branded zone. It should be eliminated
998fd04b83SRoger A. Faulkner * when we no longer support solaris10 branded zones.
1007c478bd9Sstevel@tonic-gate */
1017c478bd9Sstevel@tonic-gate int64_t
vfork(void)1027c478bd9Sstevel@tonic-gate vfork(void)
1037c478bd9Sstevel@tonic-gate {
1047c478bd9Sstevel@tonic-gate curthread->t_post_sys = 1; /* so vfwait() will be called */
105657b1f3dSraf return (cfork(1, 1, 0));
1067c478bd9Sstevel@tonic-gate }
1077c478bd9Sstevel@tonic-gate
1087c478bd9Sstevel@tonic-gate /*
1098fd04b83SRoger A. Faulkner * forksys system call - forkx, forkallx, vforkx. This is the
1108fd04b83SRoger A. Faulkner * interface invoked by libc for fork1(), forkall(), and vfork()
111657b1f3dSraf */
112657b1f3dSraf int64_t
forksys(int subcode,int flags)113657b1f3dSraf forksys(int subcode, int flags)
114657b1f3dSraf {
115657b1f3dSraf switch (subcode) {
116657b1f3dSraf case 0:
117657b1f3dSraf return (cfork(0, 1, flags)); /* forkx(flags) */
118657b1f3dSraf case 1:
119657b1f3dSraf return (cfork(0, 0, flags)); /* forkallx(flags) */
120657b1f3dSraf case 2:
121657b1f3dSraf curthread->t_post_sys = 1; /* so vfwait() will be called */
122657b1f3dSraf return (cfork(1, 1, flags)); /* vforkx(flags) */
123657b1f3dSraf default:
124657b1f3dSraf return ((int64_t)set_errno(EINVAL));
125657b1f3dSraf }
1267c478bd9Sstevel@tonic-gate }
1277c478bd9Sstevel@tonic-gate
1286aca388dSPatrick Mooney /*
1296aca388dSPatrick Mooney * Remove the associations of a child process from its parent and siblings.
1306aca388dSPatrick Mooney */
1316aca388dSPatrick Mooney static void
disown_proc(proc_t * pp,proc_t * cp)1326aca388dSPatrick Mooney disown_proc(proc_t *pp, proc_t *cp)
1336aca388dSPatrick Mooney {
1346aca388dSPatrick Mooney proc_t **orphpp;
1356aca388dSPatrick Mooney
1366aca388dSPatrick Mooney ASSERT(MUTEX_HELD(&pidlock));
1376aca388dSPatrick Mooney
1386aca388dSPatrick Mooney orphpp = &pp->p_orphan;
1396aca388dSPatrick Mooney while (*orphpp != cp)
1406aca388dSPatrick Mooney orphpp = &(*orphpp)->p_nextorph;
1416aca388dSPatrick Mooney *orphpp = cp->p_nextorph;
1426aca388dSPatrick Mooney
1436aca388dSPatrick Mooney if (pp->p_child == cp)
1446aca388dSPatrick Mooney pp->p_child = cp->p_sibling;
1456aca388dSPatrick Mooney if (cp->p_sibling)
1466aca388dSPatrick Mooney cp->p_sibling->p_psibling = cp->p_psibling;
1476aca388dSPatrick Mooney if (cp->p_psibling)
1486aca388dSPatrick Mooney cp->p_psibling->p_sibling = cp->p_sibling;
1496aca388dSPatrick Mooney }
1506aca388dSPatrick Mooney
1517c478bd9Sstevel@tonic-gate /* ARGSUSED */
1527c478bd9Sstevel@tonic-gate static int64_t
cfork(int isvfork,int isfork1,int flags)153657b1f3dSraf cfork(int isvfork, int isfork1, int flags)
1547c478bd9Sstevel@tonic-gate {
1557c478bd9Sstevel@tonic-gate proc_t *p = ttoproc(curthread);
1567c478bd9Sstevel@tonic-gate struct as *as;
1576aca388dSPatrick Mooney proc_t *cp;
1587c478bd9Sstevel@tonic-gate klwp_t *clone;
1597c478bd9Sstevel@tonic-gate kthread_t *t;
1607c478bd9Sstevel@tonic-gate task_t *tk;
1617c478bd9Sstevel@tonic-gate rval_t r;
1627c478bd9Sstevel@tonic-gate int error;
1637c478bd9Sstevel@tonic-gate int i;
1647c478bd9Sstevel@tonic-gate rctl_set_t *dup_set;
1657c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *dup_gp;
1667c478bd9Sstevel@tonic-gate rctl_entity_p_t e;
1677c478bd9Sstevel@tonic-gate lwpdir_t *ldp;
1687c478bd9Sstevel@tonic-gate lwpent_t *lep;
1697c478bd9Sstevel@tonic-gate lwpent_t *clep;
1707c478bd9Sstevel@tonic-gate
171*c6f039c7SToomas Soome clone = NULL;
172657b1f3dSraf /*
173657b1f3dSraf * Allow only these two flags.
174657b1f3dSraf */
175657b1f3dSraf if ((flags & ~(FORK_NOSIGCHLD | FORK_WAITPID)) != 0) {
176657b1f3dSraf error = EINVAL;
1772dc692e0SJerry Jelinek atomic_inc_32(&curproc->p_zone->zone_ffmisc);
178657b1f3dSraf goto forkerr;
179657b1f3dSraf }
180657b1f3dSraf
1817c478bd9Sstevel@tonic-gate /*
1827c478bd9Sstevel@tonic-gate * fork is not supported for the /proc agent lwp.
1837c478bd9Sstevel@tonic-gate */
1847c478bd9Sstevel@tonic-gate if (curthread == p->p_agenttp) {
1857c478bd9Sstevel@tonic-gate error = ENOTSUP;
1862dc692e0SJerry Jelinek atomic_inc_32(&curproc->p_zone->zone_ffmisc);
1877c478bd9Sstevel@tonic-gate goto forkerr;
1887c478bd9Sstevel@tonic-gate }
1897c478bd9Sstevel@tonic-gate
1902dc692e0SJerry Jelinek if ((error = secpolicy_basic_fork(CRED())) != 0) {
1912dc692e0SJerry Jelinek atomic_inc_32(&p->p_zone->zone_ffmisc);
1927c478bd9Sstevel@tonic-gate goto forkerr;
1932dc692e0SJerry Jelinek }
1947c478bd9Sstevel@tonic-gate
1957c478bd9Sstevel@tonic-gate /*
1967c478bd9Sstevel@tonic-gate * If the calling lwp is doing a fork1() then the
1977c478bd9Sstevel@tonic-gate * other lwps in this process are not duplicated and
1987c478bd9Sstevel@tonic-gate * don't need to be held where their kernel stacks can be
1997c478bd9Sstevel@tonic-gate * cloned. If doing forkall(), the process is held with
2007c478bd9Sstevel@tonic-gate * SHOLDFORK, so that the lwps are at a point where their
2017c478bd9Sstevel@tonic-gate * stacks can be copied which is on entry or exit from
2027c478bd9Sstevel@tonic-gate * the kernel.
2037c478bd9Sstevel@tonic-gate */
2047c478bd9Sstevel@tonic-gate if (!holdlwps(isfork1 ? SHOLDFORK1 : SHOLDFORK)) {
2057c478bd9Sstevel@tonic-gate aston(curthread);
2067c478bd9Sstevel@tonic-gate error = EINTR;
2072dc692e0SJerry Jelinek atomic_inc_32(&p->p_zone->zone_ffmisc);
2087c478bd9Sstevel@tonic-gate goto forkerr;
2097c478bd9Sstevel@tonic-gate }
2107c478bd9Sstevel@tonic-gate
2117c478bd9Sstevel@tonic-gate #if defined(__sparc)
2127c478bd9Sstevel@tonic-gate /*
2137c478bd9Sstevel@tonic-gate * Ensure that the user stack is fully constructed
2147c478bd9Sstevel@tonic-gate * before creating the child process structure.
2157c478bd9Sstevel@tonic-gate */
2167c478bd9Sstevel@tonic-gate (void) flush_user_windows_to_stack(NULL);
2177c478bd9Sstevel@tonic-gate #endif
2187c478bd9Sstevel@tonic-gate
219f787e422Sraf mutex_enter(&p->p_lock);
220f787e422Sraf /*
221f787e422Sraf * If this is vfork(), cancel any suspend request we might
222f787e422Sraf * have gotten from some other thread via lwp_suspend().
223f787e422Sraf * Otherwise we could end up with a deadlock on return
224f787e422Sraf * from the vfork() in both the parent and the child.
225f787e422Sraf */
226f787e422Sraf if (isvfork)
227f787e422Sraf curthread->t_proc_flag &= ~TP_HOLDLWP;
2287c478bd9Sstevel@tonic-gate /*
2297c478bd9Sstevel@tonic-gate * Prevent our resource set associations from being changed during fork.
2307c478bd9Sstevel@tonic-gate */
2317c478bd9Sstevel@tonic-gate pool_barrier_enter();
2327c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
2337c478bd9Sstevel@tonic-gate
2347c478bd9Sstevel@tonic-gate /*
2357c478bd9Sstevel@tonic-gate * Create a child proc struct. Place a VN_HOLD on appropriate vnodes.
2367c478bd9Sstevel@tonic-gate */
23735a5a358SJonathan Adams if (getproc(&cp, 0, GETPROC_USER) < 0) {
2387c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
2397c478bd9Sstevel@tonic-gate pool_barrier_exit();
2407c478bd9Sstevel@tonic-gate continuelwps(p);
2417c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
2427c478bd9Sstevel@tonic-gate error = EAGAIN;
2437c478bd9Sstevel@tonic-gate goto forkerr;
2447c478bd9Sstevel@tonic-gate }
2457c478bd9Sstevel@tonic-gate
2467c478bd9Sstevel@tonic-gate TRACE_2(TR_FAC_PROC, TR_PROC_FORK, "proc_fork:cp %p p %p", cp, p);
2477c478bd9Sstevel@tonic-gate
2487c478bd9Sstevel@tonic-gate /*
2497c478bd9Sstevel@tonic-gate * Assign an address space to child
2507c478bd9Sstevel@tonic-gate */
2517c478bd9Sstevel@tonic-gate if (isvfork) {
2527c478bd9Sstevel@tonic-gate /*
2537c478bd9Sstevel@tonic-gate * Clear any watched areas and remember the
2547c478bd9Sstevel@tonic-gate * watched pages for restoring in vfwait().
2557c478bd9Sstevel@tonic-gate */
2567c478bd9Sstevel@tonic-gate as = p->p_as;
2577c478bd9Sstevel@tonic-gate if (avl_numnodes(&as->a_wpage) != 0) {
258dc32d872SJosef 'Jeff' Sipek AS_LOCK_ENTER(as, RW_WRITER);
2597c478bd9Sstevel@tonic-gate as_clearwatch(as);
2607c478bd9Sstevel@tonic-gate p->p_wpage = as->a_wpage;
2617c478bd9Sstevel@tonic-gate avl_create(&as->a_wpage, wp_compare,
2627c478bd9Sstevel@tonic-gate sizeof (struct watched_page),
2637c478bd9Sstevel@tonic-gate offsetof(struct watched_page, wp_link));
264dc32d872SJosef 'Jeff' Sipek AS_LOCK_EXIT(as);
2657c478bd9Sstevel@tonic-gate }
2667c478bd9Sstevel@tonic-gate cp->p_as = as;
2677c478bd9Sstevel@tonic-gate cp->p_flag |= SVFORK;
268bb637ba7SVamsi Nagineni
269bb637ba7SVamsi Nagineni /*
270bb637ba7SVamsi Nagineni * Use the parent's shm segment list information for
271bb637ba7SVamsi Nagineni * the child as it uses its address space till it execs.
272bb637ba7SVamsi Nagineni */
273bb637ba7SVamsi Nagineni cp->p_segacct = p->p_segacct;
2747c478bd9Sstevel@tonic-gate } else {
2757c478bd9Sstevel@tonic-gate /*
2767c478bd9Sstevel@tonic-gate * We need to hold P_PR_LOCK until the address space has
2777c478bd9Sstevel@tonic-gate * been duplicated and we've had a chance to remove from the
2787c478bd9Sstevel@tonic-gate * child any DTrace probes that were in the parent. Holding
2797c478bd9Sstevel@tonic-gate * P_PR_LOCK prevents any new probes from being added and any
2807c478bd9Sstevel@tonic-gate * extant probes from being removed.
2817c478bd9Sstevel@tonic-gate */
2827c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
2837c478bd9Sstevel@tonic-gate sprlock_proc(p);
284ab9a77c7Sahl p->p_flag |= SFORKING;
2857c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
2867c478bd9Sstevel@tonic-gate
287bb5ca623SVamsi Nagineni error = as_dup(p->p_as, cp);
2887c478bd9Sstevel@tonic-gate if (error != 0) {
289aa47d340Sethindra mutex_enter(&p->p_lock);
290aa47d340Sethindra sprunlock(p);
2917c478bd9Sstevel@tonic-gate fork_fail(cp);
2927c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
2936aca388dSPatrick Mooney disown_proc(p, cp);
2947c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
2957c478bd9Sstevel@tonic-gate tk = cp->p_task;
2967c478bd9Sstevel@tonic-gate task_detach(cp);
2977c478bd9Sstevel@tonic-gate ASSERT(cp->p_pool->pool_ref > 0);
2981a5e258fSJosef 'Jeff' Sipek atomic_dec_32(&cp->p_pool->pool_ref);
2997c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
3004bcbe6e7SMenno Lageman pid_exit(cp, tk);
3017c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
3027c478bd9Sstevel@tonic-gate task_rele(tk);
3037c478bd9Sstevel@tonic-gate
3047c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
305ab9a77c7Sahl p->p_flag &= ~SFORKING;
3067c478bd9Sstevel@tonic-gate pool_barrier_exit();
3077c478bd9Sstevel@tonic-gate continuelwps(p);
308aa47d340Sethindra mutex_exit(&p->p_lock);
3097c478bd9Sstevel@tonic-gate /*
3107c478bd9Sstevel@tonic-gate * Preserve ENOMEM error condition but
3117c478bd9Sstevel@tonic-gate * map all others to EAGAIN.
3127c478bd9Sstevel@tonic-gate */
3137c478bd9Sstevel@tonic-gate error = (error == ENOMEM) ? ENOMEM : EAGAIN;
3142dc692e0SJerry Jelinek atomic_inc_32(&p->p_zone->zone_ffnomem);
3157c478bd9Sstevel@tonic-gate goto forkerr;
3167c478bd9Sstevel@tonic-gate }
317c6939658Ssl
318ab9a77c7Sahl /*
319ab9a77c7Sahl * Remove all DTrace tracepoints from the child process. We
320ab9a77c7Sahl * need to do this _before_ duplicating USDT providers since
321ab9a77c7Sahl * any associated probes may be immediately enabled.
322ab9a77c7Sahl */
323ab9a77c7Sahl if (p->p_dtrace_count > 0)
324ab9a77c7Sahl dtrace_fasttrap_fork(p, cp);
325ab9a77c7Sahl
3263cd189deSEthindra Ramamurthy mutex_enter(&p->p_lock);
3273cd189deSEthindra Ramamurthy sprunlock(p);
3283cd189deSEthindra Ramamurthy
3293cd189deSEthindra Ramamurthy /* Duplicate parent's shared memory */
3303cd189deSEthindra Ramamurthy if (p->p_segacct)
3313cd189deSEthindra Ramamurthy shmfork(p, cp);
3323cd189deSEthindra Ramamurthy
333ab9a77c7Sahl /*
334ab9a77c7Sahl * Duplicate any helper actions and providers. The SFORKING
335ab9a77c7Sahl * we set above informs the code to enable USDT probes that
336ab9a77c7Sahl * sprlock() may fail because the child is being forked.
337ab9a77c7Sahl */
3387c478bd9Sstevel@tonic-gate if (p->p_dtrace_helpers != NULL) {
3397c478bd9Sstevel@tonic-gate ASSERT(dtrace_helpers_fork != NULL);
3407c478bd9Sstevel@tonic-gate (*dtrace_helpers_fork)(p, cp);
341dcafa303Sahl }
3423cd189deSEthindra Ramamurthy
3433cd189deSEthindra Ramamurthy mutex_enter(&p->p_lock);
3443cd189deSEthindra Ramamurthy p->p_flag &= ~SFORKING;
3453cd189deSEthindra Ramamurthy mutex_exit(&p->p_lock);
3467c478bd9Sstevel@tonic-gate }
3477c478bd9Sstevel@tonic-gate
3487c478bd9Sstevel@tonic-gate /*
3497c478bd9Sstevel@tonic-gate * Duplicate parent's resource controls.
3507c478bd9Sstevel@tonic-gate */
3517c478bd9Sstevel@tonic-gate dup_set = rctl_set_create();
3527c478bd9Sstevel@tonic-gate for (;;) {
3537c478bd9Sstevel@tonic-gate dup_gp = rctl_set_dup_prealloc(p->p_rctls);
3547c478bd9Sstevel@tonic-gate mutex_enter(&p->p_rctls->rcs_lock);
3557c478bd9Sstevel@tonic-gate if (rctl_set_dup_ready(p->p_rctls, dup_gp))
3567c478bd9Sstevel@tonic-gate break;
3577c478bd9Sstevel@tonic-gate mutex_exit(&p->p_rctls->rcs_lock);
3587c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(dup_gp);
3597c478bd9Sstevel@tonic-gate }
3607c478bd9Sstevel@tonic-gate e.rcep_p.proc = cp;
3617c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_PROCESS;
3627c478bd9Sstevel@tonic-gate cp->p_rctls = rctl_set_dup(p->p_rctls, p, cp, &e, dup_set, dup_gp,
3637c478bd9Sstevel@tonic-gate RCD_DUP | RCD_CALLBACK);
3647c478bd9Sstevel@tonic-gate mutex_exit(&p->p_rctls->rcs_lock);
3657c478bd9Sstevel@tonic-gate
3667c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(dup_gp);
3677c478bd9Sstevel@tonic-gate
3687c478bd9Sstevel@tonic-gate /*
3697c478bd9Sstevel@tonic-gate * Allocate the child's lwp directory and lwpid hash table.
3707c478bd9Sstevel@tonic-gate */
3717c478bd9Sstevel@tonic-gate if (isfork1)
3727c478bd9Sstevel@tonic-gate cp->p_lwpdir_sz = 2;
3737c478bd9Sstevel@tonic-gate else
3747c478bd9Sstevel@tonic-gate cp->p_lwpdir_sz = p->p_lwpdir_sz;
3757c478bd9Sstevel@tonic-gate cp->p_lwpdir = cp->p_lwpfree = ldp =
376d3e55dcdSgww kmem_zalloc(cp->p_lwpdir_sz * sizeof (lwpdir_t), KM_SLEEP);
3777c478bd9Sstevel@tonic-gate for (i = 1; i < cp->p_lwpdir_sz; i++, ldp++)
3787c478bd9Sstevel@tonic-gate ldp->ld_next = ldp + 1;
3797c478bd9Sstevel@tonic-gate cp->p_tidhash_sz = (cp->p_lwpdir_sz + 2) / 2;
3807c478bd9Sstevel@tonic-gate cp->p_tidhash =
3816eb30ec3SRoger A. Faulkner kmem_zalloc(cp->p_tidhash_sz * sizeof (tidhash_t), KM_SLEEP);
3827c478bd9Sstevel@tonic-gate
3837c478bd9Sstevel@tonic-gate /*
3847c478bd9Sstevel@tonic-gate * Duplicate parent's lwps.
3857c478bd9Sstevel@tonic-gate * Mutual exclusion is not needed because the process is
3867c478bd9Sstevel@tonic-gate * in the hold state and only the current lwp is running.
3877c478bd9Sstevel@tonic-gate */
3887c478bd9Sstevel@tonic-gate klgrpset_clear(cp->p_lgrpset);
3897c478bd9Sstevel@tonic-gate if (isfork1) {
3907c478bd9Sstevel@tonic-gate clone = forklwp(ttolwp(curthread), cp, curthread->t_tid);
3917c478bd9Sstevel@tonic-gate if (clone == NULL)
3927c478bd9Sstevel@tonic-gate goto forklwperr;
3937c478bd9Sstevel@tonic-gate /*
3947c478bd9Sstevel@tonic-gate * Inherit only the lwp_wait()able flag,
3957c478bd9Sstevel@tonic-gate * Daemon threads should not call fork1(), but oh well...
3967c478bd9Sstevel@tonic-gate */
3977c478bd9Sstevel@tonic-gate lwptot(clone)->t_proc_flag |=
398d3e55dcdSgww (curthread->t_proc_flag & TP_TWAIT);
3997c478bd9Sstevel@tonic-gate } else {
4007c478bd9Sstevel@tonic-gate /* this is forkall(), no one can be in lwp_wait() */
4017c478bd9Sstevel@tonic-gate ASSERT(p->p_lwpwait == 0 && p->p_lwpdwait == 0);
4027c478bd9Sstevel@tonic-gate /* for each entry in the parent's lwp directory... */
4037c478bd9Sstevel@tonic-gate for (i = 0, ldp = p->p_lwpdir; i < p->p_lwpdir_sz; i++, ldp++) {
4047c478bd9Sstevel@tonic-gate klwp_t *clwp;
405c4978b50Sraf kthread_t *ct;
4067c478bd9Sstevel@tonic-gate
4077c478bd9Sstevel@tonic-gate if ((lep = ldp->ld_entry) == NULL)
4087c478bd9Sstevel@tonic-gate continue;
4097c478bd9Sstevel@tonic-gate
4107c478bd9Sstevel@tonic-gate if ((t = lep->le_thread) != NULL) {
4117c478bd9Sstevel@tonic-gate clwp = forklwp(ttolwp(t), cp, t->t_tid);
4127c478bd9Sstevel@tonic-gate if (clwp == NULL)
4137c478bd9Sstevel@tonic-gate goto forklwperr;
414c4978b50Sraf ct = lwptot(clwp);
4157c478bd9Sstevel@tonic-gate /*
4167c478bd9Sstevel@tonic-gate * Inherit lwp_wait()able and daemon flags.
4177c478bd9Sstevel@tonic-gate */
418c4978b50Sraf ct->t_proc_flag |=
4197c478bd9Sstevel@tonic-gate (t->t_proc_flag & (TP_TWAIT|TP_DAEMON));
4207c478bd9Sstevel@tonic-gate /*
4217c478bd9Sstevel@tonic-gate * Keep track of the clone of curthread to
4227c478bd9Sstevel@tonic-gate * post return values through lwp_setrval().
423c4978b50Sraf * Mark other threads for special treatment
424c4978b50Sraf * by lwp_rtt() / post_syscall().
4257c478bd9Sstevel@tonic-gate */
4267c478bd9Sstevel@tonic-gate if (t == curthread)
4277c478bd9Sstevel@tonic-gate clone = clwp;
428c4978b50Sraf else
429c4978b50Sraf ct->t_flag |= T_FORKALL;
4307c478bd9Sstevel@tonic-gate } else {
4317c478bd9Sstevel@tonic-gate /*
4327c478bd9Sstevel@tonic-gate * Replicate zombie lwps in the child.
4337c478bd9Sstevel@tonic-gate */
4347c478bd9Sstevel@tonic-gate clep = kmem_zalloc(sizeof (*clep), KM_SLEEP);
4357c478bd9Sstevel@tonic-gate clep->le_lwpid = lep->le_lwpid;
4367c478bd9Sstevel@tonic-gate clep->le_start = lep->le_start;
4376eb30ec3SRoger A. Faulkner lwp_hash_in(cp, clep,
4386eb30ec3SRoger A. Faulkner cp->p_tidhash, cp->p_tidhash_sz, 0);
4397c478bd9Sstevel@tonic-gate }
4407c478bd9Sstevel@tonic-gate }
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate
4437c478bd9Sstevel@tonic-gate /*
4447c478bd9Sstevel@tonic-gate * Put new process in the parent's process contract, or put it
4457c478bd9Sstevel@tonic-gate * in a new one if there is an active process template. Send a
4467c478bd9Sstevel@tonic-gate * fork event (if requested) to whatever contract the child is
4477c478bd9Sstevel@tonic-gate * a member of. Fails if the parent has been SIGKILLed.
4487c478bd9Sstevel@tonic-gate */
4492dc692e0SJerry Jelinek if (contract_process_fork(NULL, cp, p, B_TRUE) == NULL) {
4502dc692e0SJerry Jelinek atomic_inc_32(&p->p_zone->zone_ffmisc);
4517c478bd9Sstevel@tonic-gate goto forklwperr;
4522dc692e0SJerry Jelinek }
4537c478bd9Sstevel@tonic-gate
4547c478bd9Sstevel@tonic-gate /*
4557c478bd9Sstevel@tonic-gate * No fork failures occur beyond this point.
4567c478bd9Sstevel@tonic-gate */
4577c478bd9Sstevel@tonic-gate
4587c478bd9Sstevel@tonic-gate cp->p_lwpid = p->p_lwpid;
4597c478bd9Sstevel@tonic-gate if (!isfork1) {
4607c478bd9Sstevel@tonic-gate cp->p_lwpdaemon = p->p_lwpdaemon;
4617c478bd9Sstevel@tonic-gate cp->p_zombcnt = p->p_zombcnt;
4627c478bd9Sstevel@tonic-gate /*
4637c478bd9Sstevel@tonic-gate * If the parent's lwp ids have wrapped around, so have the
4647c478bd9Sstevel@tonic-gate * child's.
4657c478bd9Sstevel@tonic-gate */
4667c478bd9Sstevel@tonic-gate cp->p_flag |= p->p_flag & SLWPWRAP;
4677c478bd9Sstevel@tonic-gate }
4687c478bd9Sstevel@tonic-gate
46980283c8fSkk mutex_enter(&p->p_lock);
4707c478bd9Sstevel@tonic-gate corectl_path_hold(cp->p_corefile = p->p_corefile);
4717c478bd9Sstevel@tonic-gate corectl_content_hold(cp->p_content = p->p_content);
47280283c8fSkk mutex_exit(&p->p_lock);
4737c478bd9Sstevel@tonic-gate
4747c478bd9Sstevel@tonic-gate /*
4750baeff3dSrab * Duplicate process context ops, if any.
4767c478bd9Sstevel@tonic-gate */
4770baeff3dSrab if (p->p_pctx)
4780baeff3dSrab forkpctx(p, cp);
4797c478bd9Sstevel@tonic-gate
4807c478bd9Sstevel@tonic-gate #ifdef __sparc
4817c478bd9Sstevel@tonic-gate utrap_dup(p, cp);
4827c478bd9Sstevel@tonic-gate #endif
4837c478bd9Sstevel@tonic-gate /*
4847c478bd9Sstevel@tonic-gate * If the child process has been marked to stop on exit
4857c478bd9Sstevel@tonic-gate * from this fork, arrange for all other lwps to stop in
4867c478bd9Sstevel@tonic-gate * sympathy with the active lwp.
4877c478bd9Sstevel@tonic-gate */
4887c478bd9Sstevel@tonic-gate if (PTOU(cp)->u_systrap &&
4897c478bd9Sstevel@tonic-gate prismember(&PTOU(cp)->u_exitmask, curthread->t_sysnum)) {
4907c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
4917c478bd9Sstevel@tonic-gate t = cp->p_tlist;
4927c478bd9Sstevel@tonic-gate do {
4937c478bd9Sstevel@tonic-gate t->t_proc_flag |= TP_PRSTOP;
4947c478bd9Sstevel@tonic-gate aston(t); /* so TP_PRSTOP will be seen */
4957c478bd9Sstevel@tonic-gate } while ((t = t->t_forw) != cp->p_tlist);
4967c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
4977c478bd9Sstevel@tonic-gate }
4987c478bd9Sstevel@tonic-gate /*
4997c478bd9Sstevel@tonic-gate * If the parent process has been marked to stop on exit
5007c478bd9Sstevel@tonic-gate * from this fork, and its asynchronous-stop flag has not
5017c478bd9Sstevel@tonic-gate * been set, arrange for all other lwps to stop before
5027c478bd9Sstevel@tonic-gate * they return back to user level.
5037c478bd9Sstevel@tonic-gate */
5047c478bd9Sstevel@tonic-gate if (!(p->p_proc_flag & P_PR_ASYNC) && PTOU(p)->u_systrap &&
5057c478bd9Sstevel@tonic-gate prismember(&PTOU(p)->u_exitmask, curthread->t_sysnum)) {
5067c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
5077c478bd9Sstevel@tonic-gate t = p->p_tlist;
5087c478bd9Sstevel@tonic-gate do {
5097c478bd9Sstevel@tonic-gate t->t_proc_flag |= TP_PRSTOP;
5107c478bd9Sstevel@tonic-gate aston(t); /* so TP_PRSTOP will be seen */
5117c478bd9Sstevel@tonic-gate } while ((t = t->t_forw) != p->p_tlist);
5127c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
5137c478bd9Sstevel@tonic-gate }
5147c478bd9Sstevel@tonic-gate
5159acbbeafSnn if (PROC_IS_BRANDED(p))
5169acbbeafSnn BROP(p)->b_lwp_setrval(clone, p->p_pid, 1);
5179acbbeafSnn else
5189acbbeafSnn lwp_setrval(clone, p->p_pid, 1);
5197c478bd9Sstevel@tonic-gate
5207c478bd9Sstevel@tonic-gate /* set return values for parent */
5217c478bd9Sstevel@tonic-gate r.r_val1 = (int)cp->p_pid;
5227c478bd9Sstevel@tonic-gate r.r_val2 = 0;
5237c478bd9Sstevel@tonic-gate
5247c478bd9Sstevel@tonic-gate /*
5257c478bd9Sstevel@tonic-gate * pool_barrier_exit() can now be called because the child process has:
5267c478bd9Sstevel@tonic-gate * - all identifying features cloned or set (p_pid, p_task, p_pool)
5277c478bd9Sstevel@tonic-gate * - all resource sets associated (p_tlist->*->t_cpupart, p_as->a_mset)
5287c478bd9Sstevel@tonic-gate * - any other fields set which are used in resource set binding.
5297c478bd9Sstevel@tonic-gate */
5307c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
5317c478bd9Sstevel@tonic-gate pool_barrier_exit();
5327c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
5337c478bd9Sstevel@tonic-gate
5347c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
5357c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
5367c478bd9Sstevel@tonic-gate
537657b1f3dSraf /*
538657b1f3dSraf * Set flags telling the child what (not) to do on exit.
539657b1f3dSraf */
540657b1f3dSraf if (flags & FORK_NOSIGCHLD)
541657b1f3dSraf cp->p_pidflag |= CLDNOSIGCHLD;
542657b1f3dSraf if (flags & FORK_WAITPID)
543657b1f3dSraf cp->p_pidflag |= CLDWAITPID;
544657b1f3dSraf
5457c478bd9Sstevel@tonic-gate /*
5467c478bd9Sstevel@tonic-gate * Now that there are lwps and threads attached, add the new
5477c478bd9Sstevel@tonic-gate * process to the process group.
5487c478bd9Sstevel@tonic-gate */
5497c478bd9Sstevel@tonic-gate pgjoin(cp, p->p_pgidp);
5507c478bd9Sstevel@tonic-gate cp->p_stat = SRUN;
5517c478bd9Sstevel@tonic-gate /*
5527c478bd9Sstevel@tonic-gate * We are now done with all the lwps in the child process.
5537c478bd9Sstevel@tonic-gate */
5547c478bd9Sstevel@tonic-gate t = cp->p_tlist;
5557c478bd9Sstevel@tonic-gate do {
5567c478bd9Sstevel@tonic-gate /*
5577c478bd9Sstevel@tonic-gate * Set the lwp_suspend()ed lwps running.
5587c478bd9Sstevel@tonic-gate * They will suspend properly at syscall exit.
5597c478bd9Sstevel@tonic-gate */
5607c478bd9Sstevel@tonic-gate if (t->t_proc_flag & TP_HOLDLWP)
5617c478bd9Sstevel@tonic-gate lwp_create_done(t);
5627c478bd9Sstevel@tonic-gate else {
5637c478bd9Sstevel@tonic-gate /* set TS_CREATE to allow continuelwps() to work */
5647c478bd9Sstevel@tonic-gate thread_lock(t);
5657c478bd9Sstevel@tonic-gate ASSERT(t->t_state == TS_STOPPED &&
5667c478bd9Sstevel@tonic-gate !(t->t_schedflag & (TS_CREATE|TS_CSTART)));
5677c478bd9Sstevel@tonic-gate t->t_schedflag |= TS_CREATE;
5687c478bd9Sstevel@tonic-gate thread_unlock(t);
5697c478bd9Sstevel@tonic-gate }
5707c478bd9Sstevel@tonic-gate } while ((t = t->t_forw) != cp->p_tlist);
5717c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
5727c478bd9Sstevel@tonic-gate
5737c478bd9Sstevel@tonic-gate if (isvfork) {
5747c478bd9Sstevel@tonic-gate CPU_STATS_ADDQ(CPU, sys, sysvfork, 1);
5757c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
5768d186f16Sraf p->p_flag |= SVFWAIT;
5778d186f16Sraf curthread->t_flag |= T_VFPARENT;
5787c478bd9Sstevel@tonic-gate DTRACE_PROC1(create, proc_t *, cp);
5797c478bd9Sstevel@tonic-gate cv_broadcast(&pr_pid_cv[p->p_slot]); /* inform /proc */
5807c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
5817c478bd9Sstevel@tonic-gate /*
5827c478bd9Sstevel@tonic-gate * Grab child's p_lock before dropping pidlock to ensure
5837c478bd9Sstevel@tonic-gate * the process will not disappear before we set it running.
5847c478bd9Sstevel@tonic-gate */
5857c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
5867c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
5877c478bd9Sstevel@tonic-gate sigdefault(cp);
5887c478bd9Sstevel@tonic-gate continuelwps(cp);
5897c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
5907c478bd9Sstevel@tonic-gate } else {
5917c478bd9Sstevel@tonic-gate CPU_STATS_ADDQ(CPU, sys, sysfork, 1);
5927c478bd9Sstevel@tonic-gate DTRACE_PROC1(create, proc_t *, cp);
5937c478bd9Sstevel@tonic-gate /*
5947c478bd9Sstevel@tonic-gate * It is CL_FORKRET's job to drop pidlock.
5957c478bd9Sstevel@tonic-gate * If we do it here, the process could be set running
5967c478bd9Sstevel@tonic-gate * and disappear before CL_FORKRET() is called.
5977c478bd9Sstevel@tonic-gate */
5987c478bd9Sstevel@tonic-gate CL_FORKRET(curthread, cp->p_tlist);
599d4204c85Sraf schedctl_set_cidpri(curthread);
6007c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&pidlock));
6017c478bd9Sstevel@tonic-gate }
6027c478bd9Sstevel@tonic-gate
6037c478bd9Sstevel@tonic-gate return (r.r_vals);
6047c478bd9Sstevel@tonic-gate
6057c478bd9Sstevel@tonic-gate forklwperr:
6067c478bd9Sstevel@tonic-gate if (isvfork) {
6077c478bd9Sstevel@tonic-gate if (avl_numnodes(&p->p_wpage) != 0) {
6087c478bd9Sstevel@tonic-gate /* restore watchpoints to parent */
6097c478bd9Sstevel@tonic-gate as = p->p_as;
610dc32d872SJosef 'Jeff' Sipek AS_LOCK_ENTER(as, RW_WRITER);
6117c478bd9Sstevel@tonic-gate as->a_wpage = p->p_wpage;
6127c478bd9Sstevel@tonic-gate avl_create(&p->p_wpage, wp_compare,
6137c478bd9Sstevel@tonic-gate sizeof (struct watched_page),
6147c478bd9Sstevel@tonic-gate offsetof(struct watched_page, wp_link));
6157c478bd9Sstevel@tonic-gate as_setwatch(as);
616dc32d872SJosef 'Jeff' Sipek AS_LOCK_EXIT(as);
6177c478bd9Sstevel@tonic-gate }
6187c478bd9Sstevel@tonic-gate } else {
6197c478bd9Sstevel@tonic-gate if (cp->p_segacct)
6207c478bd9Sstevel@tonic-gate shmexit(cp);
6217c478bd9Sstevel@tonic-gate as = cp->p_as;
6227c478bd9Sstevel@tonic-gate cp->p_as = &kas;
6237c478bd9Sstevel@tonic-gate as_free(as);
6247c478bd9Sstevel@tonic-gate }
6257c478bd9Sstevel@tonic-gate
6267c478bd9Sstevel@tonic-gate if (cp->p_lwpdir) {
6277c478bd9Sstevel@tonic-gate for (i = 0, ldp = cp->p_lwpdir; i < cp->p_lwpdir_sz; i++, ldp++)
6287c478bd9Sstevel@tonic-gate if ((lep = ldp->ld_entry) != NULL)
6297c478bd9Sstevel@tonic-gate kmem_free(lep, sizeof (*lep));
6307c478bd9Sstevel@tonic-gate kmem_free(cp->p_lwpdir,
6317c478bd9Sstevel@tonic-gate cp->p_lwpdir_sz * sizeof (*cp->p_lwpdir));
6327c478bd9Sstevel@tonic-gate }
6337c478bd9Sstevel@tonic-gate cp->p_lwpdir = NULL;
6347c478bd9Sstevel@tonic-gate cp->p_lwpfree = NULL;
6357c478bd9Sstevel@tonic-gate cp->p_lwpdir_sz = 0;
6367c478bd9Sstevel@tonic-gate
6377c478bd9Sstevel@tonic-gate if (cp->p_tidhash)
6387c478bd9Sstevel@tonic-gate kmem_free(cp->p_tidhash,
6397c478bd9Sstevel@tonic-gate cp->p_tidhash_sz * sizeof (*cp->p_tidhash));
6407c478bd9Sstevel@tonic-gate cp->p_tidhash = NULL;
6417c478bd9Sstevel@tonic-gate cp->p_tidhash_sz = 0;
6427c478bd9Sstevel@tonic-gate
6437c478bd9Sstevel@tonic-gate forklwp_fail(cp);
6447c478bd9Sstevel@tonic-gate fork_fail(cp);
6459d7cab14SPatrick Mooney if (cp->p_dtrace_helpers != NULL) {
6469d7cab14SPatrick Mooney ASSERT(dtrace_helpers_cleanup != NULL);
6479d7cab14SPatrick Mooney (*dtrace_helpers_cleanup)(cp);
6489d7cab14SPatrick Mooney }
6497c478bd9Sstevel@tonic-gate rctl_set_free(cp->p_rctls);
6507c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
6517c478bd9Sstevel@tonic-gate
6527c478bd9Sstevel@tonic-gate /*
6537c478bd9Sstevel@tonic-gate * Detach failed child from task.
6547c478bd9Sstevel@tonic-gate */
6557c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
6567c478bd9Sstevel@tonic-gate tk = cp->p_task;
6577c478bd9Sstevel@tonic-gate task_detach(cp);
6587c478bd9Sstevel@tonic-gate ASSERT(cp->p_pool->pool_ref > 0);
6591a5e258fSJosef 'Jeff' Sipek atomic_dec_32(&cp->p_pool->pool_ref);
6607c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
6617c478bd9Sstevel@tonic-gate
6626aca388dSPatrick Mooney disown_proc(p, cp);
6634bcbe6e7SMenno Lageman pid_exit(cp, tk);
6647c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
6657c478bd9Sstevel@tonic-gate
6667c478bd9Sstevel@tonic-gate task_rele(tk);
6677c478bd9Sstevel@tonic-gate
6687c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
6697c478bd9Sstevel@tonic-gate pool_barrier_exit();
6707c478bd9Sstevel@tonic-gate continuelwps(p);
6717c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
6727c478bd9Sstevel@tonic-gate error = EAGAIN;
6737c478bd9Sstevel@tonic-gate forkerr:
6747c478bd9Sstevel@tonic-gate return ((int64_t)set_errno(error));
6757c478bd9Sstevel@tonic-gate }
6767c478bd9Sstevel@tonic-gate
6777c478bd9Sstevel@tonic-gate /*
6787c478bd9Sstevel@tonic-gate * Free allocated resources from getproc() if a fork failed.
6797c478bd9Sstevel@tonic-gate */
6807c478bd9Sstevel@tonic-gate static void
fork_fail(proc_t * cp)6817c478bd9Sstevel@tonic-gate fork_fail(proc_t *cp)
6827c478bd9Sstevel@tonic-gate {
6837c478bd9Sstevel@tonic-gate uf_info_t *fip = P_FINFO(cp);
6847c478bd9Sstevel@tonic-gate
6857c478bd9Sstevel@tonic-gate fcnt_add(fip, -1);
6867c478bd9Sstevel@tonic-gate sigdelq(cp, NULL, 0);
6877c478bd9Sstevel@tonic-gate
6887c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
6897c478bd9Sstevel@tonic-gate upcount_dec(crgetruid(cp->p_cred), crgetzoneid(cp->p_cred));
6907c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
6917c478bd9Sstevel@tonic-gate
6927c478bd9Sstevel@tonic-gate /*
6937c478bd9Sstevel@tonic-gate * single threaded, so no locking needed here
6947c478bd9Sstevel@tonic-gate */
6957c478bd9Sstevel@tonic-gate crfree(cp->p_cred);
6967c478bd9Sstevel@tonic-gate
6977c478bd9Sstevel@tonic-gate kmem_free(fip->fi_list, fip->fi_nfiles * sizeof (uf_entry_t));
6987c478bd9Sstevel@tonic-gate
699ae115bc7Smrj VN_RELE(PTOU(curproc)->u_cdir);
700ae115bc7Smrj if (PTOU(curproc)->u_rdir)
701ae115bc7Smrj VN_RELE(PTOU(curproc)->u_rdir);
7027c478bd9Sstevel@tonic-gate if (cp->p_exec)
7037c478bd9Sstevel@tonic-gate VN_RELE(cp->p_exec);
7047c478bd9Sstevel@tonic-gate if (cp->p_execdir)
7057c478bd9Sstevel@tonic-gate VN_RELE(cp->p_execdir);
706ae115bc7Smrj if (PTOU(curproc)->u_cwd)
707ae115bc7Smrj refstr_rele(PTOU(curproc)->u_cwd);
708e9f7cbf0SVamsi Nagineni if (PROC_IS_BRANDED(cp)) {
709e9f7cbf0SVamsi Nagineni brand_clearbrand(cp, B_TRUE);
710e9f7cbf0SVamsi Nagineni }
7117c478bd9Sstevel@tonic-gate }
7127c478bd9Sstevel@tonic-gate
7137c478bd9Sstevel@tonic-gate /*
7147c478bd9Sstevel@tonic-gate * Clean up the lwps already created for this child process.
7157c478bd9Sstevel@tonic-gate * The fork failed while duplicating all the lwps of the parent
7167c478bd9Sstevel@tonic-gate * and those lwps already created must be freed.
7177c478bd9Sstevel@tonic-gate * This process is invisible to the rest of the system,
7187c478bd9Sstevel@tonic-gate * so we don't need to hold p->p_lock to protect the list.
7197c478bd9Sstevel@tonic-gate */
7207c478bd9Sstevel@tonic-gate static void
forklwp_fail(proc_t * p)7217c478bd9Sstevel@tonic-gate forklwp_fail(proc_t *p)
7227c478bd9Sstevel@tonic-gate {
7237c478bd9Sstevel@tonic-gate kthread_t *t;
7247c478bd9Sstevel@tonic-gate task_t *tk;
725e9f7cbf0SVamsi Nagineni int branded = 0;
726e9f7cbf0SVamsi Nagineni
727e9f7cbf0SVamsi Nagineni if (PROC_IS_BRANDED(p))
728e9f7cbf0SVamsi Nagineni branded = 1;
7297c478bd9Sstevel@tonic-gate
7307c478bd9Sstevel@tonic-gate while ((t = p->p_tlist) != NULL) {
7317c478bd9Sstevel@tonic-gate /*
7327c478bd9Sstevel@tonic-gate * First remove the lwp from the process's p_tlist.
7337c478bd9Sstevel@tonic-gate */
7347c478bd9Sstevel@tonic-gate if (t != t->t_forw)
7357c478bd9Sstevel@tonic-gate p->p_tlist = t->t_forw;
7367c478bd9Sstevel@tonic-gate else
7377c478bd9Sstevel@tonic-gate p->p_tlist = NULL;
7387c478bd9Sstevel@tonic-gate p->p_lwpcnt--;
7397c478bd9Sstevel@tonic-gate t->t_forw->t_back = t->t_back;
7407c478bd9Sstevel@tonic-gate t->t_back->t_forw = t->t_forw;
7417c478bd9Sstevel@tonic-gate
7427c478bd9Sstevel@tonic-gate tk = p->p_task;
7437c478bd9Sstevel@tonic-gate mutex_enter(&p->p_zone->zone_nlwps_lock);
7447c478bd9Sstevel@tonic-gate tk->tk_nlwps--;
7457c478bd9Sstevel@tonic-gate tk->tk_proj->kpj_nlwps--;
7467c478bd9Sstevel@tonic-gate p->p_zone->zone_nlwps--;
7477c478bd9Sstevel@tonic-gate mutex_exit(&p->p_zone->zone_nlwps_lock);
7487c478bd9Sstevel@tonic-gate
7497c478bd9Sstevel@tonic-gate ASSERT(t->t_schedctl == NULL);
7507c478bd9Sstevel@tonic-gate
751e9f7cbf0SVamsi Nagineni if (branded)
752e9f7cbf0SVamsi Nagineni BROP(p)->b_freelwp(ttolwp(t));
753e9f7cbf0SVamsi Nagineni
7547c478bd9Sstevel@tonic-gate if (t->t_door != NULL) {
7557c478bd9Sstevel@tonic-gate kmem_free(t->t_door, sizeof (door_data_t));
7567c478bd9Sstevel@tonic-gate t->t_door = NULL;
7577c478bd9Sstevel@tonic-gate }
7587c478bd9Sstevel@tonic-gate lwp_ctmpl_clear(ttolwp(t));
7597c478bd9Sstevel@tonic-gate
7607c478bd9Sstevel@tonic-gate /*
7617c478bd9Sstevel@tonic-gate * Remove the thread from the all threads list.
7627c478bd9Sstevel@tonic-gate * We need to hold pidlock for this.
7637c478bd9Sstevel@tonic-gate */
7647c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
7657c478bd9Sstevel@tonic-gate t->t_next->t_prev = t->t_prev;
7667c478bd9Sstevel@tonic-gate t->t_prev->t_next = t->t_next;
7677c478bd9Sstevel@tonic-gate CL_EXIT(t); /* tell the scheduler that we're exiting */
7687c478bd9Sstevel@tonic-gate cv_broadcast(&t->t_joincv); /* tell anyone in thread_join */
7697c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
7707c478bd9Sstevel@tonic-gate
7717c478bd9Sstevel@tonic-gate /*
7727c478bd9Sstevel@tonic-gate * Let the lgroup load averages know that this thread isn't
7737c478bd9Sstevel@tonic-gate * going to show up (i.e. un-do what was done on behalf of
7747c478bd9Sstevel@tonic-gate * this thread by the earlier lgrp_move_thread()).
7757c478bd9Sstevel@tonic-gate */
7767c478bd9Sstevel@tonic-gate kpreempt_disable();
7777c478bd9Sstevel@tonic-gate lgrp_move_thread(t, NULL, 1);
7787c478bd9Sstevel@tonic-gate kpreempt_enable();
7797c478bd9Sstevel@tonic-gate
7807c478bd9Sstevel@tonic-gate /*
7817c478bd9Sstevel@tonic-gate * The thread was created TS_STOPPED.
7827c478bd9Sstevel@tonic-gate * We change it to TS_FREE to avoid an
7837c478bd9Sstevel@tonic-gate * ASSERT() panic in thread_free().
7847c478bd9Sstevel@tonic-gate */
7857c478bd9Sstevel@tonic-gate t->t_state = TS_FREE;
7867c478bd9Sstevel@tonic-gate thread_rele(t);
7877c478bd9Sstevel@tonic-gate thread_free(t);
7887c478bd9Sstevel@tonic-gate }
7897c478bd9Sstevel@tonic-gate }
7907c478bd9Sstevel@tonic-gate
7917c478bd9Sstevel@tonic-gate extern struct as kas;
7927c478bd9Sstevel@tonic-gate
7937c478bd9Sstevel@tonic-gate /*
7947c478bd9Sstevel@tonic-gate * fork a kernel process.
7957c478bd9Sstevel@tonic-gate */
7967c478bd9Sstevel@tonic-gate int
newproc(void (* pc)(),caddr_t arg,id_t cid,int pri,struct contract ** ct,pid_t pid)79735a5a358SJonathan Adams newproc(void (*pc)(), caddr_t arg, id_t cid, int pri, struct contract **ct,
79835a5a358SJonathan Adams pid_t pid)
7997c478bd9Sstevel@tonic-gate {
8007c478bd9Sstevel@tonic-gate proc_t *p;
8017c478bd9Sstevel@tonic-gate struct user *up;
80235a5a358SJonathan Adams kthread_t *t;
8037c478bd9Sstevel@tonic-gate cont_process_t *ctp = NULL;
8047c478bd9Sstevel@tonic-gate rctl_entity_p_t e;
8057c478bd9Sstevel@tonic-gate
80635a5a358SJonathan Adams ASSERT(cid != sysdccid);
80735a5a358SJonathan Adams ASSERT(cid != syscid || ct == NULL);
80835a5a358SJonathan Adams if (CLASS_KERNEL(cid)) {
8097c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *init_gp;
8107c478bd9Sstevel@tonic-gate rctl_set_t *init_set;
8117c478bd9Sstevel@tonic-gate
81235a5a358SJonathan Adams ASSERT(pid != 1);
81335a5a358SJonathan Adams
81435a5a358SJonathan Adams if (getproc(&p, pid, GETPROC_KERNEL) < 0)
8157c478bd9Sstevel@tonic-gate return (EAGAIN);
8167c478bd9Sstevel@tonic-gate
817cdf26504SPramod Batni /*
818cdf26504SPramod Batni * Release the hold on the p_exec and p_execdir, these
819cdf26504SPramod Batni * were acquired in getproc()
820cdf26504SPramod Batni */
821cdf26504SPramod Batni if (p->p_execdir != NULL)
822cdf26504SPramod Batni VN_RELE(p->p_execdir);
823cdf26504SPramod Batni if (p->p_exec != NULL)
824cdf26504SPramod Batni VN_RELE(p->p_exec);
8257c478bd9Sstevel@tonic-gate p->p_flag |= SNOWAIT;
8267c478bd9Sstevel@tonic-gate p->p_exec = NULL;
8277c478bd9Sstevel@tonic-gate p->p_execdir = NULL;
8287c478bd9Sstevel@tonic-gate
8297c478bd9Sstevel@tonic-gate init_set = rctl_set_create();
8307c478bd9Sstevel@tonic-gate init_gp = rctl_set_init_prealloc(RCENTITY_PROCESS);
8317c478bd9Sstevel@tonic-gate
8327c478bd9Sstevel@tonic-gate /*
8337c478bd9Sstevel@tonic-gate * kernel processes do not inherit /proc tracing flags.
8347c478bd9Sstevel@tonic-gate */
8357c478bd9Sstevel@tonic-gate sigemptyset(&p->p_sigmask);
8367c478bd9Sstevel@tonic-gate premptyset(&p->p_fltmask);
8377c478bd9Sstevel@tonic-gate up = PTOU(p);
8387c478bd9Sstevel@tonic-gate up->u_systrap = 0;
8397c478bd9Sstevel@tonic-gate premptyset(&(up->u_entrymask));
8407c478bd9Sstevel@tonic-gate premptyset(&(up->u_exitmask));
8417c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
8427c478bd9Sstevel@tonic-gate e.rcep_p.proc = p;
8437c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_PROCESS;
8447c478bd9Sstevel@tonic-gate p->p_rctls = rctl_set_init(RCENTITY_PROCESS, p, &e, init_set,
8457c478bd9Sstevel@tonic-gate init_gp);
8467c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
8477c478bd9Sstevel@tonic-gate
8487c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(init_gp);
84935a5a358SJonathan Adams
85035a5a358SJonathan Adams t = lwp_kernel_create(p, pc, arg, TS_STOPPED, pri);
85135a5a358SJonathan Adams } else {
8527c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *init_gp, *default_gp;
8537c478bd9Sstevel@tonic-gate rctl_set_t *init_set;
8547c478bd9Sstevel@tonic-gate task_t *tk, *tk_old;
85535a5a358SJonathan Adams klwp_t *lwp;
85635a5a358SJonathan Adams
85735a5a358SJonathan Adams if (getproc(&p, pid, GETPROC_USER) < 0)
8587c478bd9Sstevel@tonic-gate return (EAGAIN);
8597c478bd9Sstevel@tonic-gate /*
8607c478bd9Sstevel@tonic-gate * init creates a new task, distinct from the task
8617c478bd9Sstevel@tonic-gate * containing kernel "processes".
8627c478bd9Sstevel@tonic-gate */
8637c478bd9Sstevel@tonic-gate tk = task_create(0, p->p_zone);
8647c478bd9Sstevel@tonic-gate mutex_enter(&tk->tk_zone->zone_nlwps_lock);
8657c478bd9Sstevel@tonic-gate tk->tk_proj->kpj_ntasks++;
866ff19e029SMenno Lageman tk->tk_nprocs++;
8677c478bd9Sstevel@tonic-gate mutex_exit(&tk->tk_zone->zone_nlwps_lock);
8687c478bd9Sstevel@tonic-gate
8697c478bd9Sstevel@tonic-gate default_gp = rctl_rlimit_set_prealloc(RLIM_NLIMITS);
8707c478bd9Sstevel@tonic-gate init_gp = rctl_set_init_prealloc(RCENTITY_PROCESS);
8717c478bd9Sstevel@tonic-gate init_set = rctl_set_create();
8727c478bd9Sstevel@tonic-gate
8737c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
8747c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
8757c478bd9Sstevel@tonic-gate tk_old = p->p_task; /* switch to new task */
8767c478bd9Sstevel@tonic-gate
8777c478bd9Sstevel@tonic-gate task_detach(p);
8787c478bd9Sstevel@tonic-gate task_begin(tk, p);
8797c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
8807c478bd9Sstevel@tonic-gate
881ff19e029SMenno Lageman mutex_enter(&tk_old->tk_zone->zone_nlwps_lock);
882ff19e029SMenno Lageman tk_old->tk_nprocs--;
883ff19e029SMenno Lageman mutex_exit(&tk_old->tk_zone->zone_nlwps_lock);
884ff19e029SMenno Lageman
8857c478bd9Sstevel@tonic-gate e.rcep_p.proc = p;
8867c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_PROCESS;
8877c478bd9Sstevel@tonic-gate p->p_rctls = rctl_set_init(RCENTITY_PROCESS, p, &e, init_set,
8887c478bd9Sstevel@tonic-gate init_gp);
8897c478bd9Sstevel@tonic-gate rctlproc_default_init(p, default_gp);
8907c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
8917c478bd9Sstevel@tonic-gate
8927c478bd9Sstevel@tonic-gate task_rele(tk_old);
8937c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(default_gp);
8947c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(init_gp);
8957c478bd9Sstevel@tonic-gate
89635a5a358SJonathan Adams if ((lwp = lwp_create(pc, arg, 0, p, TS_STOPPED, pri,
89735a5a358SJonathan Adams &curthread->t_hold, cid, 1)) == NULL) {
89835a5a358SJonathan Adams task_t *tk;
8996aca388dSPatrick Mooney
90035a5a358SJonathan Adams fork_fail(p);
90135a5a358SJonathan Adams mutex_enter(&pidlock);
9026aca388dSPatrick Mooney disown_proc(p->p_parent, p);
9036aca388dSPatrick Mooney
90435a5a358SJonathan Adams mutex_enter(&p->p_lock);
90535a5a358SJonathan Adams tk = p->p_task;
90635a5a358SJonathan Adams task_detach(p);
90735a5a358SJonathan Adams ASSERT(p->p_pool->pool_ref > 0);
90835a5a358SJonathan Adams atomic_add_32(&p->p_pool->pool_ref, -1);
90935a5a358SJonathan Adams mutex_exit(&p->p_lock);
9106aca388dSPatrick Mooney
9114bcbe6e7SMenno Lageman pid_exit(p, tk);
91235a5a358SJonathan Adams mutex_exit(&pidlock);
91335a5a358SJonathan Adams task_rele(tk);
91435a5a358SJonathan Adams return (EAGAIN);
91535a5a358SJonathan Adams }
91635a5a358SJonathan Adams t = lwptot(lwp);
9177c478bd9Sstevel@tonic-gate
9187c478bd9Sstevel@tonic-gate ctp = contract_process_fork(sys_process_tmpl, p, curproc,
9197c478bd9Sstevel@tonic-gate B_FALSE);
9207c478bd9Sstevel@tonic-gate ASSERT(ctp != NULL);
9217c478bd9Sstevel@tonic-gate if (ct != NULL)
9227c478bd9Sstevel@tonic-gate *ct = &ctp->conp_contract;
9237c478bd9Sstevel@tonic-gate }
9247c478bd9Sstevel@tonic-gate
92535a5a358SJonathan Adams ASSERT3U(t->t_tid, ==, 1);
9267c478bd9Sstevel@tonic-gate p->p_lwpid = 1;
9277c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
92835a5a358SJonathan Adams pgjoin(p, p->p_parent->p_pgidp);
9297c478bd9Sstevel@tonic-gate p->p_stat = SRUN;
9307c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
93135a5a358SJonathan Adams t->t_proc_flag &= ~TP_HOLDLWP;
93235a5a358SJonathan Adams lwp_create_done(t);
9337c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
9347c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
9357c478bd9Sstevel@tonic-gate return (0);
9367c478bd9Sstevel@tonic-gate }
9377c478bd9Sstevel@tonic-gate
9387c478bd9Sstevel@tonic-gate /*
9397c478bd9Sstevel@tonic-gate * create a child proc struct.
9407c478bd9Sstevel@tonic-gate */
9417c478bd9Sstevel@tonic-gate static int
getproc(proc_t ** cpp,pid_t pid,uint_t flags)94235a5a358SJonathan Adams getproc(proc_t **cpp, pid_t pid, uint_t flags)
9437c478bd9Sstevel@tonic-gate {
9447c478bd9Sstevel@tonic-gate proc_t *pp, *cp;
9457c478bd9Sstevel@tonic-gate pid_t newpid;
9467c478bd9Sstevel@tonic-gate struct user *uarea;
9477c478bd9Sstevel@tonic-gate extern uint_t nproc;
9487c478bd9Sstevel@tonic-gate struct cred *cr;
9497c478bd9Sstevel@tonic-gate uid_t ruid;
9507c478bd9Sstevel@tonic-gate zoneid_t zoneid;
951ff19e029SMenno Lageman task_t *task;
952ff19e029SMenno Lageman kproject_t *proj;
953ff19e029SMenno Lageman zone_t *zone;
954ff19e029SMenno Lageman int rctlfail = 0;
9557c478bd9Sstevel@tonic-gate
9567c478bd9Sstevel@tonic-gate if (zone_status_get(curproc->p_zone) >= ZONE_IS_SHUTTING_DOWN)
9577c478bd9Sstevel@tonic-gate return (-1); /* no point in starting new processes */
9587c478bd9Sstevel@tonic-gate
95935a5a358SJonathan Adams pp = (flags & GETPROC_KERNEL) ? &p0 : curproc;
960ff19e029SMenno Lageman task = pp->p_task;
961ff19e029SMenno Lageman proj = task->tk_proj;
962ff19e029SMenno Lageman zone = pp->p_zone;
963ff19e029SMenno Lageman
964ff19e029SMenno Lageman mutex_enter(&pp->p_lock);
965ff19e029SMenno Lageman mutex_enter(&zone->zone_nlwps_lock);
966ff19e029SMenno Lageman if (proj != proj0p) {
967ff19e029SMenno Lageman if (task->tk_nprocs >= task->tk_nprocs_ctl)
968ff19e029SMenno Lageman if (rctl_test(rc_task_nprocs, task->tk_rctls,
969ff19e029SMenno Lageman pp, 1, 0) & RCT_DENY)
970ff19e029SMenno Lageman rctlfail = 1;
971ff19e029SMenno Lageman
972ff19e029SMenno Lageman if (proj->kpj_nprocs >= proj->kpj_nprocs_ctl)
973ff19e029SMenno Lageman if (rctl_test(rc_project_nprocs, proj->kpj_rctls,
974ff19e029SMenno Lageman pp, 1, 0) & RCT_DENY)
975ff19e029SMenno Lageman rctlfail = 1;
976ff19e029SMenno Lageman
977ff19e029SMenno Lageman if (zone->zone_nprocs >= zone->zone_nprocs_ctl)
978ff19e029SMenno Lageman if (rctl_test(rc_zone_nprocs, zone->zone_rctls,
979ff19e029SMenno Lageman pp, 1, 0) & RCT_DENY)
980ff19e029SMenno Lageman rctlfail = 1;
981ff19e029SMenno Lageman
982ff19e029SMenno Lageman if (rctlfail) {
983ff19e029SMenno Lageman mutex_exit(&zone->zone_nlwps_lock);
984ff19e029SMenno Lageman mutex_exit(&pp->p_lock);
9852dc692e0SJerry Jelinek atomic_inc_32(&zone->zone_ffcap);
986ff19e029SMenno Lageman goto punish;
987ff19e029SMenno Lageman }
988ff19e029SMenno Lageman }
989ff19e029SMenno Lageman task->tk_nprocs++;
990ff19e029SMenno Lageman proj->kpj_nprocs++;
991ff19e029SMenno Lageman zone->zone_nprocs++;
992ff19e029SMenno Lageman mutex_exit(&zone->zone_nlwps_lock);
993ff19e029SMenno Lageman mutex_exit(&pp->p_lock);
994ff19e029SMenno Lageman
9957c478bd9Sstevel@tonic-gate cp = kmem_cache_alloc(process_cache, KM_SLEEP);
9967c478bd9Sstevel@tonic-gate bzero(cp, sizeof (proc_t));
9977c478bd9Sstevel@tonic-gate
9987c478bd9Sstevel@tonic-gate /*
9997c478bd9Sstevel@tonic-gate * Make proc entry for child process
10007c478bd9Sstevel@tonic-gate */
10019acbbeafSnn mutex_init(&cp->p_splock, NULL, MUTEX_DEFAULT, NULL);
10027c478bd9Sstevel@tonic-gate mutex_init(&cp->p_crlock, NULL, MUTEX_DEFAULT, NULL);
10037c478bd9Sstevel@tonic-gate mutex_init(&cp->p_pflock, NULL, MUTEX_DEFAULT, NULL);
10047c478bd9Sstevel@tonic-gate #if defined(__x86)
10057c478bd9Sstevel@tonic-gate mutex_init(&cp->p_ldtlock, NULL, MUTEX_DEFAULT, NULL);
10067c478bd9Sstevel@tonic-gate #endif
10077c478bd9Sstevel@tonic-gate mutex_init(&cp->p_maplock, NULL, MUTEX_DEFAULT, NULL);
10087c478bd9Sstevel@tonic-gate cp->p_stat = SIDL;
10097c478bd9Sstevel@tonic-gate cp->p_mstart = gethrtime();
101035a5a358SJonathan Adams cp->p_as = &kas;
1011ae5aeae1Sgjelinek /*
1012ae5aeae1Sgjelinek * p_zone must be set before we call pid_allocate since the process
1013ae5aeae1Sgjelinek * will be visible after that and code such as prfind_zone will
1014ae5aeae1Sgjelinek * look at the p_zone field.
1015ae5aeae1Sgjelinek */
1016ae5aeae1Sgjelinek cp->p_zone = pp->p_zone;
10172cb27123Saguzovsk cp->p_t1_lgrpid = LGRP_NONE;
10182cb27123Saguzovsk cp->p_tr_lgrpid = LGRP_NONE;
10197c478bd9Sstevel@tonic-gate
102035a5a358SJonathan Adams if ((newpid = pid_allocate(cp, pid, PID_ALLOC_PROC)) == -1) {
10217c478bd9Sstevel@tonic-gate if (nproc == v.v_proc) {
10227c478bd9Sstevel@tonic-gate CPU_STATS_ADDQ(CPU, sys, procovf, 1);
10237c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "out of processes");
10247c478bd9Sstevel@tonic-gate }
10257c478bd9Sstevel@tonic-gate goto bad;
10267c478bd9Sstevel@tonic-gate }
10277c478bd9Sstevel@tonic-gate
1028a4aeef46SDonghai Qiao mutex_enter(&pp->p_lock);
1029a4aeef46SDonghai Qiao cp->p_exec = pp->p_exec;
1030a4aeef46SDonghai Qiao cp->p_execdir = pp->p_execdir;
1031a4aeef46SDonghai Qiao mutex_exit(&pp->p_lock);
1032a4aeef46SDonghai Qiao
1033a4aeef46SDonghai Qiao if (cp->p_exec) {
1034a4aeef46SDonghai Qiao VN_HOLD(cp->p_exec);
1035a4aeef46SDonghai Qiao /*
1036a4aeef46SDonghai Qiao * Each VOP_OPEN() must be paired with a corresponding
1037a4aeef46SDonghai Qiao * VOP_CLOSE(). In this case, the executable will be
1038a4aeef46SDonghai Qiao * closed for the child in either proc_exit() or gexec().
1039a4aeef46SDonghai Qiao */
1040a4aeef46SDonghai Qiao if (VOP_OPEN(&cp->p_exec, FREAD, CRED(), NULL) != 0) {
1041a4aeef46SDonghai Qiao VN_RELE(cp->p_exec);
1042a4aeef46SDonghai Qiao cp->p_exec = NULLVP;
1043a4aeef46SDonghai Qiao cp->p_execdir = NULLVP;
1044a4aeef46SDonghai Qiao goto bad;
1045a4aeef46SDonghai Qiao }
1046a4aeef46SDonghai Qiao }
1047a4aeef46SDonghai Qiao if (cp->p_execdir)
1048a4aeef46SDonghai Qiao VN_HOLD(cp->p_execdir);
1049a4aeef46SDonghai Qiao
10507c478bd9Sstevel@tonic-gate /*
10517c478bd9Sstevel@tonic-gate * If not privileged make sure that this user hasn't exceeded
10527c478bd9Sstevel@tonic-gate * v.v_maxup processes, and that users collectively haven't
10537c478bd9Sstevel@tonic-gate * exceeded v.v_maxupttl processes.
10547c478bd9Sstevel@tonic-gate */
10557c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
10567c478bd9Sstevel@tonic-gate ASSERT(nproc < v.v_proc); /* otherwise how'd we get our pid? */
10577c478bd9Sstevel@tonic-gate cr = CRED();
10587c478bd9Sstevel@tonic-gate ruid = crgetruid(cr);
10597c478bd9Sstevel@tonic-gate zoneid = crgetzoneid(cr);
10607c478bd9Sstevel@tonic-gate if (nproc >= v.v_maxup && /* short-circuit; usually false */
10617c478bd9Sstevel@tonic-gate (nproc >= v.v_maxupttl ||
10627c478bd9Sstevel@tonic-gate upcount_get(ruid, zoneid) >= v.v_maxup) &&
10637c478bd9Sstevel@tonic-gate secpolicy_newproc(cr) != 0) {
10647c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
10657c478bd9Sstevel@tonic-gate zcmn_err(zoneid, CE_NOTE,
10667c478bd9Sstevel@tonic-gate "out of per-user processes for uid %d", ruid);
10677c478bd9Sstevel@tonic-gate goto bad;
10687c478bd9Sstevel@tonic-gate }
10697c478bd9Sstevel@tonic-gate
10707c478bd9Sstevel@tonic-gate /*
10717c478bd9Sstevel@tonic-gate * Everything is cool, put the new proc on the active process list.
10727c478bd9Sstevel@tonic-gate * It is already on the pid list and in /proc.
10737c478bd9Sstevel@tonic-gate * Increment the per uid process count (upcount).
10747c478bd9Sstevel@tonic-gate */
10757c478bd9Sstevel@tonic-gate nproc++;
10767c478bd9Sstevel@tonic-gate upcount_inc(ruid, zoneid);
10777c478bd9Sstevel@tonic-gate
10787c478bd9Sstevel@tonic-gate cp->p_next = practive;
10797c478bd9Sstevel@tonic-gate practive->p_prev = cp;
10807c478bd9Sstevel@tonic-gate practive = cp;
10817c478bd9Sstevel@tonic-gate
10827c478bd9Sstevel@tonic-gate cp->p_ignore = pp->p_ignore;
10837c478bd9Sstevel@tonic-gate cp->p_siginfo = pp->p_siginfo;
10847c478bd9Sstevel@tonic-gate cp->p_flag = pp->p_flag & (SJCTL|SNOWAIT|SNOCD);
10857c478bd9Sstevel@tonic-gate cp->p_sessp = pp->p_sessp;
10869acbbeafSnn sess_hold(pp);
10879acbbeafSnn cp->p_brand = pp->p_brand;
10889acbbeafSnn if (PROC_IS_BRANDED(pp))
10899acbbeafSnn BROP(pp)->b_copy_procdata(cp, pp);
10907c478bd9Sstevel@tonic-gate cp->p_bssbase = pp->p_bssbase;
10917c478bd9Sstevel@tonic-gate cp->p_brkbase = pp->p_brkbase;
10927c478bd9Sstevel@tonic-gate cp->p_brksize = pp->p_brksize;
10937c478bd9Sstevel@tonic-gate cp->p_brkpageszc = pp->p_brkpageszc;
10947c478bd9Sstevel@tonic-gate cp->p_stksize = pp->p_stksize;
10957c478bd9Sstevel@tonic-gate cp->p_stkpageszc = pp->p_stkpageszc;
10967c478bd9Sstevel@tonic-gate cp->p_stkprot = pp->p_stkprot;
10977c478bd9Sstevel@tonic-gate cp->p_datprot = pp->p_datprot;
10987c478bd9Sstevel@tonic-gate cp->p_usrstack = pp->p_usrstack;
10997c478bd9Sstevel@tonic-gate cp->p_model = pp->p_model;
11007c478bd9Sstevel@tonic-gate cp->p_ppid = pp->p_pid;
11017c478bd9Sstevel@tonic-gate cp->p_ancpid = pp->p_pid;
11027c478bd9Sstevel@tonic-gate cp->p_portcnt = pp->p_portcnt;
1103d2a70789SRichard Lowe /*
1104d2a70789SRichard Lowe * Security flags are preserved on fork, the inherited copy come into
1105d2a70789SRichard Lowe * effect on exec
1106d2a70789SRichard Lowe */
1107d2a70789SRichard Lowe cp->p_secflags = pp->p_secflags;
11087c478bd9Sstevel@tonic-gate
11097c478bd9Sstevel@tonic-gate /*
11107c478bd9Sstevel@tonic-gate * Initialize watchpoint structures
11117c478bd9Sstevel@tonic-gate */
11127c478bd9Sstevel@tonic-gate avl_create(&cp->p_warea, wa_compare, sizeof (struct watched_area),
11137c478bd9Sstevel@tonic-gate offsetof(struct watched_area, wa_link));
11147c478bd9Sstevel@tonic-gate
11157c478bd9Sstevel@tonic-gate /*
11167c478bd9Sstevel@tonic-gate * Initialize immediate resource control values.
11177c478bd9Sstevel@tonic-gate */
11187c478bd9Sstevel@tonic-gate cp->p_stk_ctl = pp->p_stk_ctl;
11197c478bd9Sstevel@tonic-gate cp->p_fsz_ctl = pp->p_fsz_ctl;
11207c478bd9Sstevel@tonic-gate cp->p_vmem_ctl = pp->p_vmem_ctl;
11217c478bd9Sstevel@tonic-gate cp->p_fno_ctl = pp->p_fno_ctl;
11227c478bd9Sstevel@tonic-gate
11237c478bd9Sstevel@tonic-gate /*
11247c478bd9Sstevel@tonic-gate * Link up to parent-child-sibling chain. No need to lock
11257c478bd9Sstevel@tonic-gate * in general since only a call to freeproc() (done by the
11267c478bd9Sstevel@tonic-gate * same parent as newproc()) diddles with the child chain.
11277c478bd9Sstevel@tonic-gate */
11287c478bd9Sstevel@tonic-gate cp->p_sibling = pp->p_child;
11297c478bd9Sstevel@tonic-gate if (pp->p_child)
11307c478bd9Sstevel@tonic-gate pp->p_child->p_psibling = cp;
11317c478bd9Sstevel@tonic-gate
11327c478bd9Sstevel@tonic-gate cp->p_parent = pp;
11337c478bd9Sstevel@tonic-gate pp->p_child = cp;
11347c478bd9Sstevel@tonic-gate
11357c478bd9Sstevel@tonic-gate cp->p_child_ns = NULL;
11367c478bd9Sstevel@tonic-gate cp->p_sibling_ns = NULL;
11377c478bd9Sstevel@tonic-gate
11387c478bd9Sstevel@tonic-gate cp->p_nextorph = pp->p_orphan;
11397c478bd9Sstevel@tonic-gate cp->p_nextofkin = pp;
11407c478bd9Sstevel@tonic-gate pp->p_orphan = cp;
11417c478bd9Sstevel@tonic-gate
11427c478bd9Sstevel@tonic-gate /*
11437c478bd9Sstevel@tonic-gate * Inherit profiling state; do not inherit REALPROF profiling state.
11447c478bd9Sstevel@tonic-gate */
11457c478bd9Sstevel@tonic-gate cp->p_prof = pp->p_prof;
11467c478bd9Sstevel@tonic-gate cp->p_rprof_cyclic = CYCLIC_NONE;
11477c478bd9Sstevel@tonic-gate
11487c478bd9Sstevel@tonic-gate /*
11497c478bd9Sstevel@tonic-gate * Inherit pool pointer from the parent. Kernel processes are
11507c478bd9Sstevel@tonic-gate * always bound to the default pool.
11517c478bd9Sstevel@tonic-gate */
11527c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock);
115335a5a358SJonathan Adams if (flags & GETPROC_KERNEL) {
11547c478bd9Sstevel@tonic-gate cp->p_pool = pool_default;
11557c478bd9Sstevel@tonic-gate cp->p_flag |= SSYS;
11567c478bd9Sstevel@tonic-gate } else {
11577c478bd9Sstevel@tonic-gate cp->p_pool = pp->p_pool;
11587c478bd9Sstevel@tonic-gate }
11591a5e258fSJosef 'Jeff' Sipek atomic_inc_32(&cp->p_pool->pool_ref);
11607c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock);
11617c478bd9Sstevel@tonic-gate
11627c478bd9Sstevel@tonic-gate /*
11637c478bd9Sstevel@tonic-gate * Add the child process to the current task. Kernel processes
11647c478bd9Sstevel@tonic-gate * are always attached to task0.
11657c478bd9Sstevel@tonic-gate */
11667c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
116735a5a358SJonathan Adams if (flags & GETPROC_KERNEL)
11687c478bd9Sstevel@tonic-gate task_attach(task0p, cp);
11697c478bd9Sstevel@tonic-gate else
11707c478bd9Sstevel@tonic-gate task_attach(pp->p_task, cp);
11717c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
11727c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
11737c478bd9Sstevel@tonic-gate
11747c478bd9Sstevel@tonic-gate avl_create(&cp->p_ct_held, contract_compar, sizeof (contract_t),
11757c478bd9Sstevel@tonic-gate offsetof(contract_t, ct_ctlist));
11767c478bd9Sstevel@tonic-gate
11777c478bd9Sstevel@tonic-gate /*
11787c478bd9Sstevel@tonic-gate * Duplicate any audit information kept in the process table
11797c478bd9Sstevel@tonic-gate */
11807c478bd9Sstevel@tonic-gate if (audit_active) /* copy audit data to cp */
11817c478bd9Sstevel@tonic-gate audit_newproc(cp);
11827c478bd9Sstevel@tonic-gate
11837c478bd9Sstevel@tonic-gate crhold(cp->p_cred = cr);
11847c478bd9Sstevel@tonic-gate
11857c478bd9Sstevel@tonic-gate /*
11867c478bd9Sstevel@tonic-gate * Bump up the counts on the file structures pointed at by the
11877c478bd9Sstevel@tonic-gate * parent's file table since the child will point at them too.
11887c478bd9Sstevel@tonic-gate */
11897c478bd9Sstevel@tonic-gate fcnt_add(P_FINFO(pp), 1);
11907c478bd9Sstevel@tonic-gate
119135a5a358SJonathan Adams if (PTOU(pp)->u_cdir) {
119235a5a358SJonathan Adams VN_HOLD(PTOU(pp)->u_cdir);
119335a5a358SJonathan Adams } else {
119435a5a358SJonathan Adams ASSERT(pp == &p0);
119535a5a358SJonathan Adams /*
119635a5a358SJonathan Adams * We must be at or before vfs_mountroot(); it will take care of
119735a5a358SJonathan Adams * assigning our current directory.
119835a5a358SJonathan Adams */
119935a5a358SJonathan Adams }
1200ae115bc7Smrj if (PTOU(pp)->u_rdir)
1201ae115bc7Smrj VN_HOLD(PTOU(pp)->u_rdir);
1202ae115bc7Smrj if (PTOU(pp)->u_cwd)
1203ae115bc7Smrj refstr_hold(PTOU(pp)->u_cwd);
12047c478bd9Sstevel@tonic-gate
12057c478bd9Sstevel@tonic-gate /*
12067c478bd9Sstevel@tonic-gate * copy the parent's uarea.
12077c478bd9Sstevel@tonic-gate */
12087c478bd9Sstevel@tonic-gate uarea = PTOU(cp);
1209ae115bc7Smrj bcopy(PTOU(pp), uarea, sizeof (*uarea));
12107c478bd9Sstevel@tonic-gate flist_fork(P_FINFO(pp), P_FINFO(cp));
12117c478bd9Sstevel@tonic-gate
12127c478bd9Sstevel@tonic-gate gethrestime(&uarea->u_start);
1213d3d50737SRafael Vanoni uarea->u_ticks = ddi_get_lbolt();
12147c478bd9Sstevel@tonic-gate uarea->u_mem = rm_asrss(pp->p_as);
12157c478bd9Sstevel@tonic-gate uarea->u_acflag = AFORK;
12167c478bd9Sstevel@tonic-gate
12177c478bd9Sstevel@tonic-gate /*
12187c478bd9Sstevel@tonic-gate * If inherit-on-fork, copy /proc tracing flags to child.
12197c478bd9Sstevel@tonic-gate */
12207c478bd9Sstevel@tonic-gate if ((pp->p_proc_flag & P_PR_FORK) != 0) {
12217c478bd9Sstevel@tonic-gate cp->p_proc_flag |= pp->p_proc_flag & (P_PR_TRACE|P_PR_FORK);
12227c478bd9Sstevel@tonic-gate cp->p_sigmask = pp->p_sigmask;
12237c478bd9Sstevel@tonic-gate cp->p_fltmask = pp->p_fltmask;
12247c478bd9Sstevel@tonic-gate } else {
12257c478bd9Sstevel@tonic-gate sigemptyset(&cp->p_sigmask);
12267c478bd9Sstevel@tonic-gate premptyset(&cp->p_fltmask);
12277c478bd9Sstevel@tonic-gate uarea->u_systrap = 0;
12287c478bd9Sstevel@tonic-gate premptyset(&uarea->u_entrymask);
12297c478bd9Sstevel@tonic-gate premptyset(&uarea->u_exitmask);
12307c478bd9Sstevel@tonic-gate }
12317c478bd9Sstevel@tonic-gate /*
12327c478bd9Sstevel@tonic-gate * If microstate accounting is being inherited, mark child
12337c478bd9Sstevel@tonic-gate */
12347c478bd9Sstevel@tonic-gate if ((pp->p_flag & SMSFORK) != 0)
12357c478bd9Sstevel@tonic-gate cp->p_flag |= pp->p_flag & (SMSFORK|SMSACCT);
12367c478bd9Sstevel@tonic-gate
12377c478bd9Sstevel@tonic-gate /*
12387c478bd9Sstevel@tonic-gate * Inherit fixalignment flag from the parent
12397c478bd9Sstevel@tonic-gate */
12407c478bd9Sstevel@tonic-gate cp->p_fixalignment = pp->p_fixalignment;
12417c478bd9Sstevel@tonic-gate
12427c478bd9Sstevel@tonic-gate *cpp = cp;
12437c478bd9Sstevel@tonic-gate return (0);
12447c478bd9Sstevel@tonic-gate
12457c478bd9Sstevel@tonic-gate bad:
12467c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&pidlock));
12477c478bd9Sstevel@tonic-gate
12487c478bd9Sstevel@tonic-gate mutex_destroy(&cp->p_crlock);
12497c478bd9Sstevel@tonic-gate mutex_destroy(&cp->p_pflock);
12507c478bd9Sstevel@tonic-gate #if defined(__x86)
12517c478bd9Sstevel@tonic-gate mutex_destroy(&cp->p_ldtlock);
12527c478bd9Sstevel@tonic-gate #endif
12537c478bd9Sstevel@tonic-gate if (newpid != -1) {
12547c478bd9Sstevel@tonic-gate proc_entry_free(cp->p_pidp);
12557c478bd9Sstevel@tonic-gate (void) pid_rele(cp->p_pidp);
12567c478bd9Sstevel@tonic-gate }
12577c478bd9Sstevel@tonic-gate kmem_cache_free(process_cache, cp);
12587c478bd9Sstevel@tonic-gate
1259ff19e029SMenno Lageman mutex_enter(&zone->zone_nlwps_lock);
1260ff19e029SMenno Lageman task->tk_nprocs--;
1261ff19e029SMenno Lageman proj->kpj_nprocs--;
1262ff19e029SMenno Lageman zone->zone_nprocs--;
1263ff19e029SMenno Lageman mutex_exit(&zone->zone_nlwps_lock);
12642dc692e0SJerry Jelinek atomic_inc_32(&zone->zone_ffnoproc);
1265ff19e029SMenno Lageman
1266ff19e029SMenno Lageman punish:
12677c478bd9Sstevel@tonic-gate /*
12687c478bd9Sstevel@tonic-gate * We most likely got into this situation because some process is
12697c478bd9Sstevel@tonic-gate * forking out of control. As punishment, put it to sleep for a
12707c478bd9Sstevel@tonic-gate * bit so it can't eat the machine alive. Sleep interval is chosen
12717c478bd9Sstevel@tonic-gate * to allow no more than one fork failure per cpu per clock tick
12727c478bd9Sstevel@tonic-gate * on average (yes, I just made this up). This has two desirable
12737c478bd9Sstevel@tonic-gate * properties: (1) it sets a constant limit on the fork failure
12747c478bd9Sstevel@tonic-gate * rate, and (2) the busier the system is, the harsher the penalty
12757c478bd9Sstevel@tonic-gate * for abusing it becomes.
12767c478bd9Sstevel@tonic-gate */
12777c478bd9Sstevel@tonic-gate INCR_COUNT(&fork_fail_pending, &pidlock);
12787c478bd9Sstevel@tonic-gate delay(fork_fail_pending / ncpus + 1);
12797c478bd9Sstevel@tonic-gate DECR_COUNT(&fork_fail_pending, &pidlock);
12807c478bd9Sstevel@tonic-gate
12817c478bd9Sstevel@tonic-gate return (-1); /* out of memory or proc slots */
12827c478bd9Sstevel@tonic-gate }
12837c478bd9Sstevel@tonic-gate
12847c478bd9Sstevel@tonic-gate /*
12857c478bd9Sstevel@tonic-gate * Release virtual memory.
12867c478bd9Sstevel@tonic-gate * In the case of vfork(), the child was given exclusive access to its
12877c478bd9Sstevel@tonic-gate * parent's address space. The parent is waiting in vfwait() for the
12887c478bd9Sstevel@tonic-gate * child to release its exclusive claim via relvm().
12897c478bd9Sstevel@tonic-gate */
12907c478bd9Sstevel@tonic-gate void
relvm()12917c478bd9Sstevel@tonic-gate relvm()
12927c478bd9Sstevel@tonic-gate {
12937c478bd9Sstevel@tonic-gate proc_t *p = curproc;
12947c478bd9Sstevel@tonic-gate
12957c478bd9Sstevel@tonic-gate ASSERT((unsigned)p->p_lwpcnt <= 1);
12967c478bd9Sstevel@tonic-gate
12977c478bd9Sstevel@tonic-gate prrelvm(); /* inform /proc */
12987c478bd9Sstevel@tonic-gate
12997c478bd9Sstevel@tonic-gate if (p->p_flag & SVFORK) {
13007c478bd9Sstevel@tonic-gate proc_t *pp = p->p_parent;
13017c478bd9Sstevel@tonic-gate /*
13027c478bd9Sstevel@tonic-gate * The child process is either exec'ing or exit'ing.
13037c478bd9Sstevel@tonic-gate * The child is now separated from the parent's address
13047c478bd9Sstevel@tonic-gate * space. The parent process is made dispatchable.
13057c478bd9Sstevel@tonic-gate *
13067c478bd9Sstevel@tonic-gate * This is a delicate locking maneuver, involving
13077c478bd9Sstevel@tonic-gate * both the parent's p_lock and the child's p_lock.
13087c478bd9Sstevel@tonic-gate * As soon as the SVFORK flag is turned off, the
13097c478bd9Sstevel@tonic-gate * parent is free to run, but it must not run until
13107c478bd9Sstevel@tonic-gate * we wake it up using its p_cv because it might
13117c478bd9Sstevel@tonic-gate * exit and we would be referencing invalid memory.
13127c478bd9Sstevel@tonic-gate * Therefore, we hold the parent with its p_lock
13137c478bd9Sstevel@tonic-gate * while protecting our p_flags with our own p_lock.
13147c478bd9Sstevel@tonic-gate */
13157c478bd9Sstevel@tonic-gate try_again:
13167c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock); /* grab child's lock first */
13177c478bd9Sstevel@tonic-gate prbarrier(p); /* make sure /proc is blocked out */
13187c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock);
13197c478bd9Sstevel@tonic-gate
13207c478bd9Sstevel@tonic-gate /*
13217c478bd9Sstevel@tonic-gate * Check if parent is locked by /proc.
13227c478bd9Sstevel@tonic-gate */
13237c478bd9Sstevel@tonic-gate if (pp->p_proc_flag & P_PR_LOCK) {
13247c478bd9Sstevel@tonic-gate /*
13257c478bd9Sstevel@tonic-gate * Delay until /proc is done with the parent.
13267c478bd9Sstevel@tonic-gate * We must drop our (the child's) p->p_lock, wait
13277c478bd9Sstevel@tonic-gate * via prbarrier() on the parent, then start over.
13287c478bd9Sstevel@tonic-gate */
13297c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
13307c478bd9Sstevel@tonic-gate prbarrier(pp);
13317c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock);
13327c478bd9Sstevel@tonic-gate goto try_again;
13337c478bd9Sstevel@tonic-gate }
13347c478bd9Sstevel@tonic-gate p->p_flag &= ~SVFORK;
13357c478bd9Sstevel@tonic-gate kpreempt_disable();
13367c478bd9Sstevel@tonic-gate p->p_as = &kas;
13377c478bd9Sstevel@tonic-gate
13387c478bd9Sstevel@tonic-gate /*
13397c478bd9Sstevel@tonic-gate * notify hat of change in thread's address space
13407c478bd9Sstevel@tonic-gate */
13417c478bd9Sstevel@tonic-gate hat_thread_exit(curthread);
13427c478bd9Sstevel@tonic-gate kpreempt_enable();
13437c478bd9Sstevel@tonic-gate
13447c478bd9Sstevel@tonic-gate /*
13457c478bd9Sstevel@tonic-gate * child sizes are copied back to parent because
13467c478bd9Sstevel@tonic-gate * child may have grown.
13477c478bd9Sstevel@tonic-gate */
13487c478bd9Sstevel@tonic-gate pp->p_brkbase = p->p_brkbase;
13497c478bd9Sstevel@tonic-gate pp->p_brksize = p->p_brksize;
13507c478bd9Sstevel@tonic-gate pp->p_stksize = p->p_stksize;
1351bb637ba7SVamsi Nagineni
1352bb637ba7SVamsi Nagineni /*
1353bb637ba7SVamsi Nagineni * Copy back the shm accounting information
1354bb637ba7SVamsi Nagineni * to the parent process.
1355bb637ba7SVamsi Nagineni */
1356bb637ba7SVamsi Nagineni pp->p_segacct = p->p_segacct;
1357bb637ba7SVamsi Nagineni p->p_segacct = NULL;
1358bb637ba7SVamsi Nagineni
13597c478bd9Sstevel@tonic-gate /*
13607c478bd9Sstevel@tonic-gate * The parent is no longer waiting for the vfork()d child.
13617c478bd9Sstevel@tonic-gate * Restore the parent's watched pages, if any. This is
13627c478bd9Sstevel@tonic-gate * safe because we know the parent is not locked by /proc
13637c478bd9Sstevel@tonic-gate */
13647c478bd9Sstevel@tonic-gate pp->p_flag &= ~SVFWAIT;
13657c478bd9Sstevel@tonic-gate if (avl_numnodes(&pp->p_wpage) != 0) {
13667c478bd9Sstevel@tonic-gate pp->p_as->a_wpage = pp->p_wpage;
13677c478bd9Sstevel@tonic-gate avl_create(&pp->p_wpage, wp_compare,
13687c478bd9Sstevel@tonic-gate sizeof (struct watched_page),
13697c478bd9Sstevel@tonic-gate offsetof(struct watched_page, wp_link));
13707c478bd9Sstevel@tonic-gate }
13717c478bd9Sstevel@tonic-gate cv_signal(&pp->p_cv);
13727c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock);
13737c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
13747c478bd9Sstevel@tonic-gate } else {
13757c478bd9Sstevel@tonic-gate if (p->p_as != &kas) {
13767c478bd9Sstevel@tonic-gate struct as *as;
13777c478bd9Sstevel@tonic-gate
13787c478bd9Sstevel@tonic-gate if (p->p_segacct)
13797c478bd9Sstevel@tonic-gate shmexit(p);
13809acbbeafSnn
13817c478bd9Sstevel@tonic-gate /*
13827c478bd9Sstevel@tonic-gate * We grab p_lock for the benefit of /proc
13837c478bd9Sstevel@tonic-gate */
13847c478bd9Sstevel@tonic-gate kpreempt_disable();
13857c478bd9Sstevel@tonic-gate mutex_enter(&p->p_lock);
13867c478bd9Sstevel@tonic-gate prbarrier(p); /* make sure /proc is blocked out */
13877c478bd9Sstevel@tonic-gate as = p->p_as;
13887c478bd9Sstevel@tonic-gate p->p_as = &kas;
13897c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock);
13907c478bd9Sstevel@tonic-gate
13917c478bd9Sstevel@tonic-gate /*
13927c478bd9Sstevel@tonic-gate * notify hat of change in thread's address space
13937c478bd9Sstevel@tonic-gate */
13947c478bd9Sstevel@tonic-gate hat_thread_exit(curthread);
13957c478bd9Sstevel@tonic-gate kpreempt_enable();
13967c478bd9Sstevel@tonic-gate
13977c478bd9Sstevel@tonic-gate as_free(as);
13982cb27123Saguzovsk p->p_tr_lgrpid = LGRP_NONE;
13997c478bd9Sstevel@tonic-gate }
14007c478bd9Sstevel@tonic-gate }
14017c478bd9Sstevel@tonic-gate }
14027c478bd9Sstevel@tonic-gate
14037c478bd9Sstevel@tonic-gate /*
14047c478bd9Sstevel@tonic-gate * Wait for child to exec or exit.
14057c478bd9Sstevel@tonic-gate * Called by parent of vfork'ed process.
14067c478bd9Sstevel@tonic-gate * See important comments in relvm(), above.
14077c478bd9Sstevel@tonic-gate */
14087c478bd9Sstevel@tonic-gate void
vfwait(pid_t pid)14097c478bd9Sstevel@tonic-gate vfwait(pid_t pid)
14107c478bd9Sstevel@tonic-gate {
14117c478bd9Sstevel@tonic-gate int signalled = 0;
14127c478bd9Sstevel@tonic-gate proc_t *pp = ttoproc(curthread);
14137c478bd9Sstevel@tonic-gate proc_t *cp;
14147c478bd9Sstevel@tonic-gate
14157c478bd9Sstevel@tonic-gate /*
14167c478bd9Sstevel@tonic-gate * Wait for child to exec or exit.
14177c478bd9Sstevel@tonic-gate */
14187c478bd9Sstevel@tonic-gate for (;;) {
14197c478bd9Sstevel@tonic-gate mutex_enter(&pidlock);
14207c478bd9Sstevel@tonic-gate cp = prfind(pid);
14217c478bd9Sstevel@tonic-gate if (cp == NULL || cp->p_parent != pp) {
14227c478bd9Sstevel@tonic-gate /*
14237c478bd9Sstevel@tonic-gate * Child has exit()ed.
14247c478bd9Sstevel@tonic-gate */
14257c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
14267c478bd9Sstevel@tonic-gate break;
14277c478bd9Sstevel@tonic-gate }
14287c478bd9Sstevel@tonic-gate /*
14297c478bd9Sstevel@tonic-gate * Grab the child's p_lock before releasing pidlock.
14307c478bd9Sstevel@tonic-gate * Otherwise, the child could exit and we would be
14317c478bd9Sstevel@tonic-gate * referencing invalid memory.
14327c478bd9Sstevel@tonic-gate */
14337c478bd9Sstevel@tonic-gate mutex_enter(&cp->p_lock);
14347c478bd9Sstevel@tonic-gate mutex_exit(&pidlock);
14357c478bd9Sstevel@tonic-gate if (!(cp->p_flag & SVFORK)) {
14367c478bd9Sstevel@tonic-gate /*
14377c478bd9Sstevel@tonic-gate * Child has exec()ed or is exit()ing.
14387c478bd9Sstevel@tonic-gate */
14397c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
14407c478bd9Sstevel@tonic-gate break;
14417c478bd9Sstevel@tonic-gate }
14427c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock);
14437c478bd9Sstevel@tonic-gate mutex_exit(&cp->p_lock);
14447c478bd9Sstevel@tonic-gate /*
14457c478bd9Sstevel@tonic-gate * We might be waked up spuriously from the cv_wait().
14467c478bd9Sstevel@tonic-gate * We have to do the whole operation over again to be
14477c478bd9Sstevel@tonic-gate * sure the child's SVFORK flag really is turned off.
14487c478bd9Sstevel@tonic-gate * We cannot make reference to the child because it can
14497c478bd9Sstevel@tonic-gate * exit before we return and we would be referencing
14507c478bd9Sstevel@tonic-gate * invalid memory.
14517c478bd9Sstevel@tonic-gate *
14527c478bd9Sstevel@tonic-gate * Because this is potentially a very long-term wait,
14537c478bd9Sstevel@tonic-gate * we call cv_wait_sig() (for its jobcontrol and /proc
14547c478bd9Sstevel@tonic-gate * side-effects) unless there is a current signal, in
14557c478bd9Sstevel@tonic-gate * which case we use cv_wait() because we cannot return
14567c478bd9Sstevel@tonic-gate * from this function until the child has released the
14577c478bd9Sstevel@tonic-gate * address space. Calling cv_wait_sig() with a current
14587c478bd9Sstevel@tonic-gate * signal would lead to an indefinite loop here because
14597c478bd9Sstevel@tonic-gate * cv_wait_sig() returns immediately in this case.
14607c478bd9Sstevel@tonic-gate */
14617c478bd9Sstevel@tonic-gate if (signalled)
14627c478bd9Sstevel@tonic-gate cv_wait(&pp->p_cv, &pp->p_lock);
14637c478bd9Sstevel@tonic-gate else
14647c478bd9Sstevel@tonic-gate signalled = !cv_wait_sig(&pp->p_cv, &pp->p_lock);
14657c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock);
14667c478bd9Sstevel@tonic-gate }
14677c478bd9Sstevel@tonic-gate
14687c478bd9Sstevel@tonic-gate /* restore watchpoints to parent */
14697c478bd9Sstevel@tonic-gate if (pr_watch_active(pp)) {
14707c478bd9Sstevel@tonic-gate struct as *as = pp->p_as;
1471dc32d872SJosef 'Jeff' Sipek AS_LOCK_ENTER(as, RW_WRITER);
14727c478bd9Sstevel@tonic-gate as_setwatch(as);
1473dc32d872SJosef 'Jeff' Sipek AS_LOCK_EXIT(as);
14747c478bd9Sstevel@tonic-gate }
14757c478bd9Sstevel@tonic-gate
14767c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock);
14777c478bd9Sstevel@tonic-gate prbarrier(pp); /* barrier against /proc locking */
14787c478bd9Sstevel@tonic-gate continuelwps(pp);
14797c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock);
14807c478bd9Sstevel@tonic-gate }
1481