xref: /illumos-gate/usr/src/uts/common/fs/proc/prioctl.c (revision e14d4b22a4af406b3202d81ab8a3a197b796bcd2)
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
5870619e9Sfrankho  * Common Development and Distribution License (the "License").
6870619e9Sfrankho  * 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  */
21eb9dbf0cSRoger A. Faulkner 
227c478bd9Sstevel@tonic-gate /*
238fd04b83SRoger A. Faulkner  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
25284ce987SPatrick Mooney  * Copyright 2017 Joyent, Inc.
267c478bd9Sstevel@tonic-gate  */
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
29*e14d4b22SToomas Soome /*	  All rights reserved.	*/
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate #include <sys/types.h>
327c478bd9Sstevel@tonic-gate #include <sys/param.h>
337c478bd9Sstevel@tonic-gate #include <sys/vmparam.h>
347c478bd9Sstevel@tonic-gate #include <sys/var.h>
357c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
367c478bd9Sstevel@tonic-gate #include <sys/cred.h>
377c478bd9Sstevel@tonic-gate #include <sys/debug.h>
387c478bd9Sstevel@tonic-gate #include <sys/errno.h>
397c478bd9Sstevel@tonic-gate #include <sys/file.h>
407c478bd9Sstevel@tonic-gate #include <sys/inline.h>
417c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
427c478bd9Sstevel@tonic-gate #include <sys/proc.h>
43eb9dbf0cSRoger A. Faulkner #include <sys/brand.h>
447c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
457c478bd9Sstevel@tonic-gate #include <sys/systm.h>
467c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
477c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
487c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
497c478bd9Sstevel@tonic-gate #include <sys/session.h>
507c478bd9Sstevel@tonic-gate #include <sys/signal.h>
517c478bd9Sstevel@tonic-gate #include <sys/auxv.h>
527c478bd9Sstevel@tonic-gate #include <sys/user.h>
537c478bd9Sstevel@tonic-gate #include <sys/disp.h>
547c478bd9Sstevel@tonic-gate #include <sys/class.h>
557c478bd9Sstevel@tonic-gate #include <sys/ts.h>
567c478bd9Sstevel@tonic-gate #include <sys/mman.h>
577c478bd9Sstevel@tonic-gate #include <sys/fault.h>
587c478bd9Sstevel@tonic-gate #include <sys/syscall.h>
597c478bd9Sstevel@tonic-gate #include <sys/schedctl.h>
607c478bd9Sstevel@tonic-gate #include <sys/pset.h>
617c478bd9Sstevel@tonic-gate #include <sys/old_procfs.h>
627c478bd9Sstevel@tonic-gate #include <sys/zone.h>
637c478bd9Sstevel@tonic-gate #include <sys/time.h>
647c478bd9Sstevel@tonic-gate #include <sys/msacct.h>
657c478bd9Sstevel@tonic-gate #include <vm/rm.h>
667c478bd9Sstevel@tonic-gate #include <vm/as.h>
677c478bd9Sstevel@tonic-gate #include <vm/rm.h>
687c478bd9Sstevel@tonic-gate #include <vm/seg.h>
697c478bd9Sstevel@tonic-gate #include <vm/seg_vn.h>
707c478bd9Sstevel@tonic-gate #include <sys/contract_impl.h>
717c478bd9Sstevel@tonic-gate #include <sys/ctfs_impl.h>
727c478bd9Sstevel@tonic-gate #include <sys/ctfs.h>
737c478bd9Sstevel@tonic-gate 
747c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__i386_COMPAT)
757c478bd9Sstevel@tonic-gate #include <sys/sysi86.h>
767c478bd9Sstevel@tonic-gate #endif
777c478bd9Sstevel@tonic-gate 
787c478bd9Sstevel@tonic-gate #include <fs/proc/prdata.h>
797c478bd9Sstevel@tonic-gate 
807c478bd9Sstevel@tonic-gate static	int	isprwrioctl(int);
817c478bd9Sstevel@tonic-gate static	ulong_t	prmaprunflags(long);
827c478bd9Sstevel@tonic-gate static	long	prmapsetflags(long);
837c478bd9Sstevel@tonic-gate static	void	prsetrun(kthread_t *, prrun_t *);
847c478bd9Sstevel@tonic-gate static	int	propenm(prnode_t *, caddr_t, caddr_t, int *, cred_t *);
857c478bd9Sstevel@tonic-gate extern	void	oprgetstatus(kthread_t *, prstatus_t *, zone_t *);
867c478bd9Sstevel@tonic-gate extern	void	oprgetpsinfo(proc_t *, prpsinfo_t *, kthread_t *);
87870619e9Sfrankho static	int	oprgetmap(proc_t *, list_t *);
887c478bd9Sstevel@tonic-gate 
897c478bd9Sstevel@tonic-gate static int
907c478bd9Sstevel@tonic-gate prctioctl(prnode_t *pnp, int cmd, intptr_t arg, int flag, cred_t *cr)
917c478bd9Sstevel@tonic-gate {
927c478bd9Sstevel@tonic-gate 	int error = 0;
93c5a9a4fcSAntonello Cruz 	ct_kparam_t kparam;
94c5a9a4fcSAntonello Cruz 	ct_param_t *param = &kparam.param;
957c478bd9Sstevel@tonic-gate 	ct_template_t *tmpl;
967c478bd9Sstevel@tonic-gate 
977c478bd9Sstevel@tonic-gate 	if (cmd != CT_TSET && cmd != CT_TGET)
987c478bd9Sstevel@tonic-gate 		return (EINVAL);
997c478bd9Sstevel@tonic-gate 
100c5a9a4fcSAntonello Cruz 	error = ctparam_copyin((void *)arg, &kparam, flag, cmd);
101c5a9a4fcSAntonello Cruz 	if (error != 0)
102c5a9a4fcSAntonello Cruz 		return (error);
1037c478bd9Sstevel@tonic-gate 
104c5a9a4fcSAntonello Cruz 	if ((error = prlock(pnp, ZNO)) != 0) {
105c5a9a4fcSAntonello Cruz 		kmem_free(kparam.ctpm_kbuf, param->ctpm_size);
1067c478bd9Sstevel@tonic-gate 		return (error);
107c5a9a4fcSAntonello Cruz 	}
1087c478bd9Sstevel@tonic-gate 
1097c478bd9Sstevel@tonic-gate 	tmpl = pnp->pr_common->prc_thread->t_lwp->lwp_ct_active[pnp->pr_cttype];
1107c478bd9Sstevel@tonic-gate 	if (tmpl == NULL) {
1117c478bd9Sstevel@tonic-gate 		prunlock(pnp);
112c5a9a4fcSAntonello Cruz 		kmem_free(kparam.ctpm_kbuf, param->ctpm_size);
1137c478bd9Sstevel@tonic-gate 		return (ESTALE);
1147c478bd9Sstevel@tonic-gate 	}
1157c478bd9Sstevel@tonic-gate 
1167c478bd9Sstevel@tonic-gate 	if (cmd == CT_TSET)
117c5a9a4fcSAntonello Cruz 		error = ctmpl_set(tmpl, &kparam, cr);
1187c478bd9Sstevel@tonic-gate 	else
119c5a9a4fcSAntonello Cruz 		error = ctmpl_get(tmpl, &kparam);
1207c478bd9Sstevel@tonic-gate 
1217c478bd9Sstevel@tonic-gate 	prunlock(pnp);
1227c478bd9Sstevel@tonic-gate 
123c5a9a4fcSAntonello Cruz 	if (cmd == CT_TGET && error == 0) {
124c5a9a4fcSAntonello Cruz 		error = ctparam_copyout(&kparam, (void *)arg, flag);
125c5a9a4fcSAntonello Cruz 	} else {
126c5a9a4fcSAntonello Cruz 		kmem_free(kparam.ctpm_kbuf, param->ctpm_size);
127c5a9a4fcSAntonello Cruz 	}
1287c478bd9Sstevel@tonic-gate 
1297c478bd9Sstevel@tonic-gate 	return (error);
1307c478bd9Sstevel@tonic-gate }
1317c478bd9Sstevel@tonic-gate 
1327c478bd9Sstevel@tonic-gate 
1337c478bd9Sstevel@tonic-gate /*
1347c478bd9Sstevel@tonic-gate  * Control operations (lots).
1357c478bd9Sstevel@tonic-gate  */
136da6c28aaSamw /*ARGSUSED*/
1377c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
1387c478bd9Sstevel@tonic-gate static int
139*e14d4b22SToomas Soome prioctl64(struct vnode *vp, int cmd, intptr_t arg, int flag, cred_t *cr,
140*e14d4b22SToomas Soome     int *rvalp, caller_context_t *ct)
1417c478bd9Sstevel@tonic-gate #else
1427c478bd9Sstevel@tonic-gate int
143*e14d4b22SToomas Soome prioctl(struct vnode *vp, int cmd, intptr_t arg, int flag, cred_t *cr,
144*e14d4b22SToomas Soome     int *rvalp, caller_context_t *ct)
1457c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
1467c478bd9Sstevel@tonic-gate {
147eb9dbf0cSRoger A. Faulkner 	int nsig = PROC_IS_BRANDED(curproc)? BROP(curproc)->b_nsig : NSIG;
1487c478bd9Sstevel@tonic-gate 	caddr_t cmaddr = (caddr_t)arg;
1497c478bd9Sstevel@tonic-gate 	proc_t *p;
1507c478bd9Sstevel@tonic-gate 	user_t *up;
1517c478bd9Sstevel@tonic-gate 	kthread_t *t;
1527c478bd9Sstevel@tonic-gate 	klwp_t *lwp;
1537c478bd9Sstevel@tonic-gate 	prnode_t *pnp = VTOP(vp);
1547c478bd9Sstevel@tonic-gate 	prcommon_t *pcp;
1557c478bd9Sstevel@tonic-gate 	prnode_t *xpnp = NULL;
1567c478bd9Sstevel@tonic-gate 	int error;
1577c478bd9Sstevel@tonic-gate 	int zdisp;
1587c478bd9Sstevel@tonic-gate 	void *thing = NULL;
1597c478bd9Sstevel@tonic-gate 	size_t thingsize = 0;
1607c478bd9Sstevel@tonic-gate 
1617c478bd9Sstevel@tonic-gate 	/*
1627c478bd9Sstevel@tonic-gate 	 * For copyin()/copyout().
1637c478bd9Sstevel@tonic-gate 	 */
1647c478bd9Sstevel@tonic-gate 	union {
1657c478bd9Sstevel@tonic-gate 		caddr_t		va;
1667c478bd9Sstevel@tonic-gate 		int		signo;
1677c478bd9Sstevel@tonic-gate 		int		nice;
1687c478bd9Sstevel@tonic-gate 		uint_t		lwpid;
1697c478bd9Sstevel@tonic-gate 		long		flags;
1707c478bd9Sstevel@tonic-gate 		prstatus_t	prstat;
1717c478bd9Sstevel@tonic-gate 		prrun_t		prrun;
1727c478bd9Sstevel@tonic-gate 		sigset_t	smask;
1737c478bd9Sstevel@tonic-gate 		siginfo_t	info;
1747c478bd9Sstevel@tonic-gate 		sysset_t	prmask;
1757c478bd9Sstevel@tonic-gate 		prgregset_t	regs;
1767c478bd9Sstevel@tonic-gate 		prfpregset_t	fpregs;
1777c478bd9Sstevel@tonic-gate 		prpsinfo_t	prps;
1787c478bd9Sstevel@tonic-gate 		sigset_t	holdmask;
1797c478bd9Sstevel@tonic-gate 		fltset_t	fltmask;
1807c478bd9Sstevel@tonic-gate 		prcred_t	prcred;
1817c478bd9Sstevel@tonic-gate 		prhusage_t	prhusage;
1827c478bd9Sstevel@tonic-gate 		prmap_t		prmap;
1837c478bd9Sstevel@tonic-gate 		auxv_t		auxv[__KERN_NAUXV_IMPL];
1847c478bd9Sstevel@tonic-gate 	} un;
1857c478bd9Sstevel@tonic-gate 
1867c478bd9Sstevel@tonic-gate 	if (pnp->pr_type == PR_TMPL)
1877c478bd9Sstevel@tonic-gate 		return (prctioctl(pnp, cmd, arg, flag, cr));
1887c478bd9Sstevel@tonic-gate 
1897c478bd9Sstevel@tonic-gate 	/*
1907c478bd9Sstevel@tonic-gate 	 * Support for old /proc interface.
1917c478bd9Sstevel@tonic-gate 	 */
1927c478bd9Sstevel@tonic-gate 	if (pnp->pr_pidfile != NULL) {
1937c478bd9Sstevel@tonic-gate 		ASSERT(pnp->pr_type == PR_PIDDIR);
1947c478bd9Sstevel@tonic-gate 		vp = pnp->pr_pidfile;
1957c478bd9Sstevel@tonic-gate 		pnp = VTOP(vp);
1967c478bd9Sstevel@tonic-gate 		ASSERT(pnp->pr_type == PR_PIDFILE);
1977c478bd9Sstevel@tonic-gate 	}
1987c478bd9Sstevel@tonic-gate 
1997c478bd9Sstevel@tonic-gate 	if (pnp->pr_type != PR_PIDFILE && pnp->pr_type != PR_LWPIDFILE)
2007c478bd9Sstevel@tonic-gate 		return (ENOTTY);
2017c478bd9Sstevel@tonic-gate 
2027c478bd9Sstevel@tonic-gate 	/*
2037c478bd9Sstevel@tonic-gate 	 * Fail ioctls which are logically "write" requests unless
2047c478bd9Sstevel@tonic-gate 	 * the user has write permission.
2057c478bd9Sstevel@tonic-gate 	 */
2067c478bd9Sstevel@tonic-gate 	if ((flag & FWRITE) == 0 && isprwrioctl(cmd))
2077c478bd9Sstevel@tonic-gate 		return (EBADF);
2087c478bd9Sstevel@tonic-gate 
2097c478bd9Sstevel@tonic-gate 	/*
2107c478bd9Sstevel@tonic-gate 	 * Perform any necessary copyin() operations before
2117c478bd9Sstevel@tonic-gate 	 * locking the process.  Helps avoid deadlocks and
2127c478bd9Sstevel@tonic-gate 	 * improves performance.
2137c478bd9Sstevel@tonic-gate 	 *
2147c478bd9Sstevel@tonic-gate 	 * Also, detect invalid ioctl codes here to avoid
2157c478bd9Sstevel@tonic-gate 	 * locking a process unnnecessarily.
2167c478bd9Sstevel@tonic-gate 	 *
2177c478bd9Sstevel@tonic-gate 	 * Also, prepare to allocate space that will be needed below,
2187c478bd9Sstevel@tonic-gate 	 * case by case.
2197c478bd9Sstevel@tonic-gate 	 */
2207c478bd9Sstevel@tonic-gate 	error = 0;
2217c478bd9Sstevel@tonic-gate 	switch (cmd) {
2227c478bd9Sstevel@tonic-gate 	case PIOCGETPR:
2237c478bd9Sstevel@tonic-gate 		thingsize = sizeof (proc_t);
2247c478bd9Sstevel@tonic-gate 		break;
2257c478bd9Sstevel@tonic-gate 	case PIOCGETU:
2267c478bd9Sstevel@tonic-gate 		thingsize = sizeof (user_t);
2277c478bd9Sstevel@tonic-gate 		break;
2287c478bd9Sstevel@tonic-gate 	case PIOCSTOP:
2297c478bd9Sstevel@tonic-gate 	case PIOCWSTOP:
2307c478bd9Sstevel@tonic-gate 	case PIOCLWPIDS:
2317c478bd9Sstevel@tonic-gate 	case PIOCGTRACE:
2327c478bd9Sstevel@tonic-gate 	case PIOCGENTRY:
2337c478bd9Sstevel@tonic-gate 	case PIOCGEXIT:
2347c478bd9Sstevel@tonic-gate 	case PIOCSRLC:
2357c478bd9Sstevel@tonic-gate 	case PIOCRRLC:
2367c478bd9Sstevel@tonic-gate 	case PIOCSFORK:
2377c478bd9Sstevel@tonic-gate 	case PIOCRFORK:
2387c478bd9Sstevel@tonic-gate 	case PIOCGREG:
2397c478bd9Sstevel@tonic-gate 	case PIOCGFPREG:
2407c478bd9Sstevel@tonic-gate 	case PIOCSTATUS:
2417c478bd9Sstevel@tonic-gate 	case PIOCLSTATUS:
2427c478bd9Sstevel@tonic-gate 	case PIOCPSINFO:
2437c478bd9Sstevel@tonic-gate 	case PIOCMAXSIG:
2447c478bd9Sstevel@tonic-gate 	case PIOCGXREGSIZE:
2457c478bd9Sstevel@tonic-gate 		break;
2467c478bd9Sstevel@tonic-gate 	case PIOCSXREG:		/* set extra registers */
2477c478bd9Sstevel@tonic-gate 	case PIOCGXREG:		/* get extra registers */
2487c478bd9Sstevel@tonic-gate #if defined(__sparc)
2497c478bd9Sstevel@tonic-gate 		thingsize = sizeof (prxregset_t);
2507c478bd9Sstevel@tonic-gate #else
2517c478bd9Sstevel@tonic-gate 		thingsize = 0;
2527c478bd9Sstevel@tonic-gate #endif
2537c478bd9Sstevel@tonic-gate 		break;
2547c478bd9Sstevel@tonic-gate 	case PIOCACTION:
255eb9dbf0cSRoger A. Faulkner 		thingsize = (nsig-1) * sizeof (struct sigaction);
2567c478bd9Sstevel@tonic-gate 		break;
2577c478bd9Sstevel@tonic-gate 	case PIOCGHOLD:
2587c478bd9Sstevel@tonic-gate 	case PIOCNMAP:
2597c478bd9Sstevel@tonic-gate 	case PIOCMAP:
2607c478bd9Sstevel@tonic-gate 	case PIOCGFAULT:
2617c478bd9Sstevel@tonic-gate 	case PIOCCFAULT:
2627c478bd9Sstevel@tonic-gate 	case PIOCCRED:
2637c478bd9Sstevel@tonic-gate 	case PIOCGROUPS:
2647c478bd9Sstevel@tonic-gate 	case PIOCUSAGE:
2657c478bd9Sstevel@tonic-gate 	case PIOCLUSAGE:
2667c478bd9Sstevel@tonic-gate 		break;
2677c478bd9Sstevel@tonic-gate 	case PIOCOPENPD:
2687c478bd9Sstevel@tonic-gate 		/*
2697c478bd9Sstevel@tonic-gate 		 * We will need this below.
2707c478bd9Sstevel@tonic-gate 		 * Allocate it now, before locking the process.
2717c478bd9Sstevel@tonic-gate 		 */
2727c478bd9Sstevel@tonic-gate 		xpnp = prgetnode(vp, PR_OPAGEDATA);
2737c478bd9Sstevel@tonic-gate 		break;
2747c478bd9Sstevel@tonic-gate 	case PIOCNAUXV:
2757c478bd9Sstevel@tonic-gate 	case PIOCAUXV:
2767c478bd9Sstevel@tonic-gate 		break;
2777c478bd9Sstevel@tonic-gate 
2787c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__amd64)
2797c478bd9Sstevel@tonic-gate 	case PIOCNLDT:
2807c478bd9Sstevel@tonic-gate 	case PIOCLDT:
2817c478bd9Sstevel@tonic-gate 		break;
2827c478bd9Sstevel@tonic-gate #endif	/* __i386 || __amd64 */
2837c478bd9Sstevel@tonic-gate 
2847c478bd9Sstevel@tonic-gate #if defined(__sparc)
2857c478bd9Sstevel@tonic-gate 	case PIOCGWIN:
2867c478bd9Sstevel@tonic-gate 		thingsize = sizeof (gwindows_t);
2877c478bd9Sstevel@tonic-gate 		break;
2887c478bd9Sstevel@tonic-gate #endif	/* __sparc */
2897c478bd9Sstevel@tonic-gate 
2907c478bd9Sstevel@tonic-gate 	case PIOCOPENM:		/* open mapped object for reading */
2917c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
2927c478bd9Sstevel@tonic-gate 			un.va = NULL;
2937c478bd9Sstevel@tonic-gate 		else if (copyin(cmaddr, &un.va, sizeof (un.va)))
2947c478bd9Sstevel@tonic-gate 			error = EFAULT;
2957c478bd9Sstevel@tonic-gate 		break;
2967c478bd9Sstevel@tonic-gate 
2977c478bd9Sstevel@tonic-gate 	case PIOCRUN:		/* make lwp or process runnable */
2987c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
2997c478bd9Sstevel@tonic-gate 			un.prrun.pr_flags = 0;
3007c478bd9Sstevel@tonic-gate 		else if (copyin(cmaddr, &un.prrun, sizeof (un.prrun)))
3017c478bd9Sstevel@tonic-gate 			error = EFAULT;
3027c478bd9Sstevel@tonic-gate 		break;
3037c478bd9Sstevel@tonic-gate 
3047c478bd9Sstevel@tonic-gate 	case PIOCOPENLWP:	/* return /proc lwp file descriptor */
3057c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.lwpid, sizeof (un.lwpid)))
3067c478bd9Sstevel@tonic-gate 			error = EFAULT;
3077c478bd9Sstevel@tonic-gate 		break;
3087c478bd9Sstevel@tonic-gate 
3097c478bd9Sstevel@tonic-gate 	case PIOCSTRACE:	/* set signal trace mask */
3107c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.smask, sizeof (un.smask)))
3117c478bd9Sstevel@tonic-gate 			error = EFAULT;
3127c478bd9Sstevel@tonic-gate 		break;
3137c478bd9Sstevel@tonic-gate 
3147c478bd9Sstevel@tonic-gate 	case PIOCSSIG:		/* set current signal */
3157c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
3167c478bd9Sstevel@tonic-gate 			un.info.si_signo = 0;
3177c478bd9Sstevel@tonic-gate 		else if (copyin(cmaddr, &un.info, sizeof (un.info)))
3187c478bd9Sstevel@tonic-gate 			error = EFAULT;
3197c478bd9Sstevel@tonic-gate 		break;
3207c478bd9Sstevel@tonic-gate 
3217c478bd9Sstevel@tonic-gate 	case PIOCKILL:		/* send signal */
3227c478bd9Sstevel@tonic-gate 	case PIOCUNKILL:	/* delete a signal */
3237c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.signo, sizeof (un.signo)))
3247c478bd9Sstevel@tonic-gate 			error = EFAULT;
3257c478bd9Sstevel@tonic-gate 		break;
3267c478bd9Sstevel@tonic-gate 
3277c478bd9Sstevel@tonic-gate 	case PIOCNICE:		/* set nice priority */
3287c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.nice, sizeof (un.nice)))
3297c478bd9Sstevel@tonic-gate 			error = EFAULT;
3307c478bd9Sstevel@tonic-gate 		break;
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate 	case PIOCSENTRY:	/* set syscall entry bit mask */
3337c478bd9Sstevel@tonic-gate 	case PIOCSEXIT:		/* set syscall exit bit mask */
3347c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.prmask, sizeof (un.prmask)))
3357c478bd9Sstevel@tonic-gate 			error = EFAULT;
3367c478bd9Sstevel@tonic-gate 		break;
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 	case PIOCSET:		/* set process flags */
3397c478bd9Sstevel@tonic-gate 	case PIOCRESET:		/* reset process flags */
3407c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.flags, sizeof (un.flags)))
3417c478bd9Sstevel@tonic-gate 			error = EFAULT;
3427c478bd9Sstevel@tonic-gate 		break;
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate 	case PIOCSREG:		/* set general registers */
3457c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, un.regs, sizeof (un.regs)))
3467c478bd9Sstevel@tonic-gate 			error = EFAULT;
3477c478bd9Sstevel@tonic-gate 		break;
3487c478bd9Sstevel@tonic-gate 
3497c478bd9Sstevel@tonic-gate 	case PIOCSFPREG:	/* set floating-point registers */
3507c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.fpregs, sizeof (un.fpregs)))
3517c478bd9Sstevel@tonic-gate 			error = EFAULT;
3527c478bd9Sstevel@tonic-gate 		break;
3537c478bd9Sstevel@tonic-gate 
3547c478bd9Sstevel@tonic-gate 	case PIOCSHOLD:		/* set signal-hold mask */
3557c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.holdmask, sizeof (un.holdmask)))
3567c478bd9Sstevel@tonic-gate 			error = EFAULT;
3577c478bd9Sstevel@tonic-gate 		break;
3587c478bd9Sstevel@tonic-gate 
3597c478bd9Sstevel@tonic-gate 	case PIOCSFAULT:	/* set mask of traced faults */
3607c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un.fltmask, sizeof (un.fltmask)))
3617c478bd9Sstevel@tonic-gate 			error = EFAULT;
3627c478bd9Sstevel@tonic-gate 		break;
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 	default:
3657c478bd9Sstevel@tonic-gate 		error = EINVAL;
3667c478bd9Sstevel@tonic-gate 		break;
3677c478bd9Sstevel@tonic-gate 	}
3687c478bd9Sstevel@tonic-gate 
3697c478bd9Sstevel@tonic-gate 	if (error)
3707c478bd9Sstevel@tonic-gate 		return (error);
3717c478bd9Sstevel@tonic-gate 
3727c478bd9Sstevel@tonic-gate startover:
3737c478bd9Sstevel@tonic-gate 	/*
3747c478bd9Sstevel@tonic-gate 	 * If we need kmem_alloc()d space then we allocate it now, before
3757c478bd9Sstevel@tonic-gate 	 * grabbing the process lock.  Using kmem_alloc(KM_SLEEP) while
3767c478bd9Sstevel@tonic-gate 	 * holding the process lock leads to deadlock with the clock thread.
3777c478bd9Sstevel@tonic-gate 	 * (The clock thread wakes up the pageout daemon to free up space.
3787c478bd9Sstevel@tonic-gate 	 * If the clock thread blocks behind us and we are sleeping waiting
3797c478bd9Sstevel@tonic-gate 	 * for space, then space may never become available.)
3807c478bd9Sstevel@tonic-gate 	 */
3817c478bd9Sstevel@tonic-gate 	if (thingsize) {
3827c478bd9Sstevel@tonic-gate 		ASSERT(thing == NULL);
3837c478bd9Sstevel@tonic-gate 		thing = kmem_alloc(thingsize, KM_SLEEP);
3847c478bd9Sstevel@tonic-gate 	}
3857c478bd9Sstevel@tonic-gate 
3867c478bd9Sstevel@tonic-gate 	switch (cmd) {
3877c478bd9Sstevel@tonic-gate 	case PIOCPSINFO:
3887c478bd9Sstevel@tonic-gate 	case PIOCGETPR:
3897c478bd9Sstevel@tonic-gate 	case PIOCUSAGE:
3907c478bd9Sstevel@tonic-gate 	case PIOCLUSAGE:
3917c478bd9Sstevel@tonic-gate 		zdisp = ZYES;
3927c478bd9Sstevel@tonic-gate 		break;
3937c478bd9Sstevel@tonic-gate 	case PIOCSXREG:		/* set extra registers */
3947c478bd9Sstevel@tonic-gate 		/*
3957c478bd9Sstevel@tonic-gate 		 * perform copyin before grabbing the process lock
3967c478bd9Sstevel@tonic-gate 		 */
3977c478bd9Sstevel@tonic-gate 		if (thing) {
3987c478bd9Sstevel@tonic-gate 			if (copyin(cmaddr, thing, thingsize)) {
3997c478bd9Sstevel@tonic-gate 				kmem_free(thing, thingsize);
4007c478bd9Sstevel@tonic-gate 				return (EFAULT);
4017c478bd9Sstevel@tonic-gate 			}
4027c478bd9Sstevel@tonic-gate 		}
4037c478bd9Sstevel@tonic-gate 		/* fall through... */
4047c478bd9Sstevel@tonic-gate 	default:
4057c478bd9Sstevel@tonic-gate 		zdisp = ZNO;
4067c478bd9Sstevel@tonic-gate 		break;
4077c478bd9Sstevel@tonic-gate 	}
4087c478bd9Sstevel@tonic-gate 
4097c478bd9Sstevel@tonic-gate 	if ((error = prlock(pnp, zdisp)) != 0) {
4107c478bd9Sstevel@tonic-gate 		if (thing != NULL)
4117c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
4127c478bd9Sstevel@tonic-gate 		if (xpnp)
4137c478bd9Sstevel@tonic-gate 			prfreenode(xpnp);
4147c478bd9Sstevel@tonic-gate 		return (error);
4157c478bd9Sstevel@tonic-gate 	}
4167c478bd9Sstevel@tonic-gate 
4177c478bd9Sstevel@tonic-gate 	pcp = pnp->pr_common;
4187c478bd9Sstevel@tonic-gate 	p = pcp->prc_proc;
4197c478bd9Sstevel@tonic-gate 	ASSERT(p != NULL);
4207c478bd9Sstevel@tonic-gate 
4217c478bd9Sstevel@tonic-gate 	/*
4227c478bd9Sstevel@tonic-gate 	 * Choose a thread/lwp for the operation.
4237c478bd9Sstevel@tonic-gate 	 */
4247c478bd9Sstevel@tonic-gate 	if (zdisp == ZNO && cmd != PIOCSTOP && cmd != PIOCWSTOP) {
4257c478bd9Sstevel@tonic-gate 		if (pnp->pr_type == PR_LWPIDFILE && cmd != PIOCLSTATUS) {
4267c478bd9Sstevel@tonic-gate 			t = pcp->prc_thread;
4277c478bd9Sstevel@tonic-gate 			ASSERT(t != NULL);
4287c478bd9Sstevel@tonic-gate 		} else {
4297c478bd9Sstevel@tonic-gate 			t = prchoose(p);	/* returns locked thread */
4307c478bd9Sstevel@tonic-gate 			ASSERT(t != NULL);
4317c478bd9Sstevel@tonic-gate 			thread_unlock(t);
4327c478bd9Sstevel@tonic-gate 		}
4337c478bd9Sstevel@tonic-gate 		lwp = ttolwp(t);
4347c478bd9Sstevel@tonic-gate 	}
4357c478bd9Sstevel@tonic-gate 
4367c478bd9Sstevel@tonic-gate 	error = 0;
4377c478bd9Sstevel@tonic-gate 	switch (cmd) {
4387c478bd9Sstevel@tonic-gate 
4397c478bd9Sstevel@tonic-gate 	case PIOCGETPR:		/* read struct proc */
4407c478bd9Sstevel@tonic-gate 	{
4417c478bd9Sstevel@tonic-gate 		proc_t *prp = thing;
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate 		*prp = *p;
4447c478bd9Sstevel@tonic-gate 		prunlock(pnp);
4457c478bd9Sstevel@tonic-gate 		if (copyout(prp, cmaddr, sizeof (proc_t)))
4467c478bd9Sstevel@tonic-gate 			error = EFAULT;
4477c478bd9Sstevel@tonic-gate 		kmem_free(prp, sizeof (proc_t));
4487c478bd9Sstevel@tonic-gate 		thing = NULL;
4497c478bd9Sstevel@tonic-gate 		break;
4507c478bd9Sstevel@tonic-gate 	}
4517c478bd9Sstevel@tonic-gate 
4527c478bd9Sstevel@tonic-gate 	case PIOCGETU:		/* read u-area */
4537c478bd9Sstevel@tonic-gate 	{
4547c478bd9Sstevel@tonic-gate 		user_t *userp = thing;
4557c478bd9Sstevel@tonic-gate 
4567c478bd9Sstevel@tonic-gate 		up = PTOU(p);
4577c478bd9Sstevel@tonic-gate 		*userp = *up;
4587c478bd9Sstevel@tonic-gate 		prunlock(pnp);
4597c478bd9Sstevel@tonic-gate 		if (copyout(userp, cmaddr, sizeof (user_t)))
4607c478bd9Sstevel@tonic-gate 			error = EFAULT;
4617c478bd9Sstevel@tonic-gate 		kmem_free(userp, sizeof (user_t));
4627c478bd9Sstevel@tonic-gate 		thing = NULL;
4637c478bd9Sstevel@tonic-gate 		break;
4647c478bd9Sstevel@tonic-gate 	}
4657c478bd9Sstevel@tonic-gate 
4667c478bd9Sstevel@tonic-gate 	case PIOCOPENM:		/* open mapped object for reading */
4677c478bd9Sstevel@tonic-gate 		error = propenm(pnp, cmaddr, un.va, rvalp, cr);
4687c478bd9Sstevel@tonic-gate 		/* propenm() called prunlock(pnp) */
4697c478bd9Sstevel@tonic-gate 		break;
4707c478bd9Sstevel@tonic-gate 
4717c478bd9Sstevel@tonic-gate 	case PIOCSTOP:		/* stop process or lwp from running */
4727c478bd9Sstevel@tonic-gate 	case PIOCWSTOP:		/* wait for process or lwp to stop */
4737c478bd9Sstevel@tonic-gate 		/*
4747c478bd9Sstevel@tonic-gate 		 * Can't apply to a system process.
4757c478bd9Sstevel@tonic-gate 		 */
4767c478bd9Sstevel@tonic-gate 		if ((p->p_flag & SSYS) || p->p_as == &kas) {
4777c478bd9Sstevel@tonic-gate 			prunlock(pnp);
4787c478bd9Sstevel@tonic-gate 			error = EBUSY;
4797c478bd9Sstevel@tonic-gate 			break;
4807c478bd9Sstevel@tonic-gate 		}
4817c478bd9Sstevel@tonic-gate 
4827c478bd9Sstevel@tonic-gate 		if (cmd == PIOCSTOP)
4837c478bd9Sstevel@tonic-gate 			pr_stop(pnp);
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate 		/*
4867c478bd9Sstevel@tonic-gate 		 * If an lwp is waiting for itself or its process, don't wait.
4877c478bd9Sstevel@tonic-gate 		 * The stopped lwp would never see the fact that it is stopped.
4887c478bd9Sstevel@tonic-gate 		 */
4897c478bd9Sstevel@tonic-gate 		if ((pnp->pr_type == PR_LWPIDFILE)?
4907c478bd9Sstevel@tonic-gate 		    (pcp->prc_thread == curthread) : (p == curproc)) {
4917c478bd9Sstevel@tonic-gate 			if (cmd == PIOCWSTOP)
4927c478bd9Sstevel@tonic-gate 				error = EBUSY;
4937c478bd9Sstevel@tonic-gate 			prunlock(pnp);
4947c478bd9Sstevel@tonic-gate 			break;
4957c478bd9Sstevel@tonic-gate 		}
4967c478bd9Sstevel@tonic-gate 
4977c478bd9Sstevel@tonic-gate 		if ((error = pr_wait_stop(pnp, (time_t)0)) != 0)
4987c478bd9Sstevel@tonic-gate 			break;	/* pr_wait_stop() unlocked the process */
4997c478bd9Sstevel@tonic-gate 
5007c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
5017c478bd9Sstevel@tonic-gate 			prunlock(pnp);
5027c478bd9Sstevel@tonic-gate 		else {
5037c478bd9Sstevel@tonic-gate 			/*
5047c478bd9Sstevel@tonic-gate 			 * Return process/lwp status information.
5057c478bd9Sstevel@tonic-gate 			 */
5067c478bd9Sstevel@tonic-gate 			t = pr_thread(pnp);	/* returns locked thread */
5077c478bd9Sstevel@tonic-gate 			thread_unlock(t);
508fa9e4066Sahrens 			oprgetstatus(t, &un.prstat, VTOZONE(vp));
5097c478bd9Sstevel@tonic-gate 			prunlock(pnp);
5107c478bd9Sstevel@tonic-gate 			if (copyout(&un.prstat, cmaddr, sizeof (un.prstat)))
5117c478bd9Sstevel@tonic-gate 				error = EFAULT;
5127c478bd9Sstevel@tonic-gate 		}
5137c478bd9Sstevel@tonic-gate 		break;
5147c478bd9Sstevel@tonic-gate 
5157c478bd9Sstevel@tonic-gate 	case PIOCRUN:		/* make lwp or process runnable */
5167c478bd9Sstevel@tonic-gate 	{
5177c478bd9Sstevel@tonic-gate 		long flags = un.prrun.pr_flags;
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate 		/*
5207c478bd9Sstevel@tonic-gate 		 * Cannot set an lwp running is it is not stopped.
5217c478bd9Sstevel@tonic-gate 		 * Also, no lwp other than the /proc agent lwp can
5227c478bd9Sstevel@tonic-gate 		 * be set running so long as the /proc agent lwp exists.
5237c478bd9Sstevel@tonic-gate 		 */
5247c478bd9Sstevel@tonic-gate 		if ((!ISTOPPED(t) && !VSTOPPED(t) &&
5257c478bd9Sstevel@tonic-gate 		    !(t->t_proc_flag & TP_PRSTOP)) ||
5267c478bd9Sstevel@tonic-gate 		    (p->p_agenttp != NULL &&
5277c478bd9Sstevel@tonic-gate 		    (t != p->p_agenttp || pnp->pr_type != PR_LWPIDFILE))) {
5287c478bd9Sstevel@tonic-gate 			prunlock(pnp);
5297c478bd9Sstevel@tonic-gate 			error = EBUSY;
5307c478bd9Sstevel@tonic-gate 			break;
5317c478bd9Sstevel@tonic-gate 		}
5327c478bd9Sstevel@tonic-gate 
5337c478bd9Sstevel@tonic-gate 		if (flags & (PRSHOLD|PRSTRACE|PRSFAULT|PRSVADDR))
5347c478bd9Sstevel@tonic-gate 			prsetrun(t, &un.prrun);
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate 		error = pr_setrun(pnp, prmaprunflags(flags));
5377c478bd9Sstevel@tonic-gate 
5387c478bd9Sstevel@tonic-gate 		prunlock(pnp);
5397c478bd9Sstevel@tonic-gate 		break;
5407c478bd9Sstevel@tonic-gate 	}
5417c478bd9Sstevel@tonic-gate 
5427c478bd9Sstevel@tonic-gate 	case PIOCLWPIDS:	/* get array of lwp identifiers */
5437c478bd9Sstevel@tonic-gate 	{
5447c478bd9Sstevel@tonic-gate 		int nlwp;
5457c478bd9Sstevel@tonic-gate 		int Nlwp;
5467c478bd9Sstevel@tonic-gate 		id_t *idp;
5477c478bd9Sstevel@tonic-gate 		id_t *Bidp;
5487c478bd9Sstevel@tonic-gate 
5497c478bd9Sstevel@tonic-gate 		Nlwp = nlwp = p->p_lwpcnt;
5507c478bd9Sstevel@tonic-gate 
5517c478bd9Sstevel@tonic-gate 		if (thing && thingsize != (Nlwp+1) * sizeof (id_t)) {
5527c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
5537c478bd9Sstevel@tonic-gate 			thing = NULL;
5547c478bd9Sstevel@tonic-gate 		}
5557c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
5567c478bd9Sstevel@tonic-gate 			thingsize = (Nlwp+1) * sizeof (id_t);
5577c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
5587c478bd9Sstevel@tonic-gate 		}
5597c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
5607c478bd9Sstevel@tonic-gate 			prunlock(pnp);
5617c478bd9Sstevel@tonic-gate 			goto startover;
5627c478bd9Sstevel@tonic-gate 		}
5637c478bd9Sstevel@tonic-gate 
5647c478bd9Sstevel@tonic-gate 		idp = thing;
5657c478bd9Sstevel@tonic-gate 		thing = NULL;
5667c478bd9Sstevel@tonic-gate 		Bidp = idp;
5677c478bd9Sstevel@tonic-gate 		if ((t = p->p_tlist) != NULL) {
5687c478bd9Sstevel@tonic-gate 			do {
5697c478bd9Sstevel@tonic-gate 				ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
5707c478bd9Sstevel@tonic-gate 				ASSERT(nlwp > 0);
5717c478bd9Sstevel@tonic-gate 				--nlwp;
5727c478bd9Sstevel@tonic-gate 				*idp++ = t->t_tid;
5737c478bd9Sstevel@tonic-gate 			} while ((t = t->t_forw) != p->p_tlist);
5747c478bd9Sstevel@tonic-gate 		}
5757c478bd9Sstevel@tonic-gate 		*idp = 0;
5767c478bd9Sstevel@tonic-gate 		ASSERT(nlwp == 0);
5777c478bd9Sstevel@tonic-gate 		prunlock(pnp);
5787c478bd9Sstevel@tonic-gate 		if (copyout(Bidp, cmaddr, (Nlwp+1) * sizeof (id_t)))
5797c478bd9Sstevel@tonic-gate 			error = EFAULT;
5807c478bd9Sstevel@tonic-gate 		kmem_free(Bidp, (Nlwp+1) * sizeof (id_t));
5817c478bd9Sstevel@tonic-gate 		break;
5827c478bd9Sstevel@tonic-gate 	}
5837c478bd9Sstevel@tonic-gate 
5847c478bd9Sstevel@tonic-gate 	case PIOCOPENLWP:	/* return /proc lwp file descriptor */
5857c478bd9Sstevel@tonic-gate 	{
5867c478bd9Sstevel@tonic-gate 		vnode_t *xvp;
5877c478bd9Sstevel@tonic-gate 		int n;
5887c478bd9Sstevel@tonic-gate 
5897c478bd9Sstevel@tonic-gate 		prunlock(pnp);
5907c478bd9Sstevel@tonic-gate 		if ((xvp = prlwpnode(pnp, un.lwpid)) == NULL)
5917c478bd9Sstevel@tonic-gate 			error = ENOENT;
5927c478bd9Sstevel@tonic-gate 		else if (error = fassign(&xvp, flag & (FREAD|FWRITE), &n)) {
5937c478bd9Sstevel@tonic-gate 			VN_RELE(xvp);
5947c478bd9Sstevel@tonic-gate 		} else
5957c478bd9Sstevel@tonic-gate 			*rvalp = n;
5967c478bd9Sstevel@tonic-gate 		break;
5977c478bd9Sstevel@tonic-gate 	}
5987c478bd9Sstevel@tonic-gate 
5997c478bd9Sstevel@tonic-gate 	case PIOCOPENPD:	/* return /proc page data file descriptor */
6007c478bd9Sstevel@tonic-gate 	{
6017c478bd9Sstevel@tonic-gate 		vnode_t *xvp = PTOV(xpnp);
6027c478bd9Sstevel@tonic-gate 		vnode_t *dp = pnp->pr_parent;
6037c478bd9Sstevel@tonic-gate 		int n;
6047c478bd9Sstevel@tonic-gate 
6057c478bd9Sstevel@tonic-gate 		if (pnp->pr_type == PR_LWPIDFILE) {
6067c478bd9Sstevel@tonic-gate 			dp = VTOP(dp)->pr_parent;
6077c478bd9Sstevel@tonic-gate 			dp = VTOP(dp)->pr_parent;
6087c478bd9Sstevel@tonic-gate 		}
6097c478bd9Sstevel@tonic-gate 		ASSERT(VTOP(dp)->pr_type == PR_PIDDIR);
6107c478bd9Sstevel@tonic-gate 
6117c478bd9Sstevel@tonic-gate 		VN_HOLD(dp);
6127c478bd9Sstevel@tonic-gate 		pcp = pnp->pr_pcommon;
6137c478bd9Sstevel@tonic-gate 		xpnp->pr_ino = ptoi(pcp->prc_pid);
6147c478bd9Sstevel@tonic-gate 		xpnp->pr_common = pcp;
6157c478bd9Sstevel@tonic-gate 		xpnp->pr_pcommon = pcp;
6167c478bd9Sstevel@tonic-gate 		xpnp->pr_parent = dp;
6177c478bd9Sstevel@tonic-gate 
6187c478bd9Sstevel@tonic-gate 		xpnp->pr_next = p->p_plist;
6197c478bd9Sstevel@tonic-gate 		p->p_plist = xvp;
6207c478bd9Sstevel@tonic-gate 
6217c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6227c478bd9Sstevel@tonic-gate 		if (error = fassign(&xvp, FREAD, &n)) {
6237c478bd9Sstevel@tonic-gate 			VN_RELE(xvp);
6247c478bd9Sstevel@tonic-gate 		} else
6257c478bd9Sstevel@tonic-gate 			*rvalp = n;
6267c478bd9Sstevel@tonic-gate 
6277c478bd9Sstevel@tonic-gate 		xpnp = NULL;
6287c478bd9Sstevel@tonic-gate 		break;
6297c478bd9Sstevel@tonic-gate 	}
6307c478bd9Sstevel@tonic-gate 
6317c478bd9Sstevel@tonic-gate 	case PIOCGTRACE:	/* get signal trace mask */
6327c478bd9Sstevel@tonic-gate 		prassignset(&un.smask, &p->p_sigmask);
6337c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6347c478bd9Sstevel@tonic-gate 		if (copyout(&un.smask, cmaddr, sizeof (un.smask)))
6357c478bd9Sstevel@tonic-gate 			error = EFAULT;
6367c478bd9Sstevel@tonic-gate 		break;
6377c478bd9Sstevel@tonic-gate 
6387c478bd9Sstevel@tonic-gate 	case PIOCSTRACE:	/* set signal trace mask */
6397c478bd9Sstevel@tonic-gate 		prdelset(&un.smask, SIGKILL);
6407c478bd9Sstevel@tonic-gate 		prassignset(&p->p_sigmask, &un.smask);
6417c478bd9Sstevel@tonic-gate 		if (!sigisempty(&p->p_sigmask))
6427c478bd9Sstevel@tonic-gate 			p->p_proc_flag |= P_PR_TRACE;
6437c478bd9Sstevel@tonic-gate 		else if (prisempty(&p->p_fltmask)) {
6447c478bd9Sstevel@tonic-gate 			up = PTOU(p);
6457c478bd9Sstevel@tonic-gate 			if (up->u_systrap == 0)
6467c478bd9Sstevel@tonic-gate 				p->p_proc_flag &= ~P_PR_TRACE;
6477c478bd9Sstevel@tonic-gate 		}
6487c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6497c478bd9Sstevel@tonic-gate 		break;
6507c478bd9Sstevel@tonic-gate 
6517c478bd9Sstevel@tonic-gate 	case PIOCSSIG:		/* set current signal */
6527c478bd9Sstevel@tonic-gate 		error = pr_setsig(pnp, &un.info);
6537c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6547c478bd9Sstevel@tonic-gate 		if (un.info.si_signo == SIGKILL && error == 0)
6557c478bd9Sstevel@tonic-gate 			pr_wait_die(pnp);
6567c478bd9Sstevel@tonic-gate 		break;
6577c478bd9Sstevel@tonic-gate 
6587c478bd9Sstevel@tonic-gate 	case PIOCKILL:		/* send signal */
6597c478bd9Sstevel@tonic-gate 	{
6607c478bd9Sstevel@tonic-gate 		int sig = (int)un.signo;
6617c478bd9Sstevel@tonic-gate 
6627c478bd9Sstevel@tonic-gate 		error = pr_kill(pnp, sig, cr);
6637c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6647c478bd9Sstevel@tonic-gate 		if (sig == SIGKILL && error == 0)
6657c478bd9Sstevel@tonic-gate 			pr_wait_die(pnp);
6667c478bd9Sstevel@tonic-gate 		break;
6677c478bd9Sstevel@tonic-gate 	}
6687c478bd9Sstevel@tonic-gate 
6697c478bd9Sstevel@tonic-gate 	case PIOCUNKILL:	/* delete a signal */
6707c478bd9Sstevel@tonic-gate 		error = pr_unkill(pnp, (int)un.signo);
6717c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6727c478bd9Sstevel@tonic-gate 		break;
6737c478bd9Sstevel@tonic-gate 
6747c478bd9Sstevel@tonic-gate 	case PIOCNICE:		/* set nice priority */
6757c478bd9Sstevel@tonic-gate 		error = pr_nice(p, (int)un.nice, cr);
6767c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6777c478bd9Sstevel@tonic-gate 		break;
6787c478bd9Sstevel@tonic-gate 
6797c478bd9Sstevel@tonic-gate 	case PIOCGENTRY:	/* get syscall entry bit mask */
6807c478bd9Sstevel@tonic-gate 	case PIOCGEXIT:		/* get syscall exit bit mask */
6817c478bd9Sstevel@tonic-gate 		up = PTOU(p);
6827c478bd9Sstevel@tonic-gate 		if (cmd == PIOCGENTRY) {
6837c478bd9Sstevel@tonic-gate 			prassignset(&un.prmask, &up->u_entrymask);
6847c478bd9Sstevel@tonic-gate 		} else {
6857c478bd9Sstevel@tonic-gate 			prassignset(&un.prmask, &up->u_exitmask);
6867c478bd9Sstevel@tonic-gate 		}
6877c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6887c478bd9Sstevel@tonic-gate 		if (copyout(&un.prmask, cmaddr, sizeof (un.prmask)))
6897c478bd9Sstevel@tonic-gate 			error = EFAULT;
6907c478bd9Sstevel@tonic-gate 		break;
6917c478bd9Sstevel@tonic-gate 
6927c478bd9Sstevel@tonic-gate 	case PIOCSENTRY:	/* set syscall entry bit mask */
6937c478bd9Sstevel@tonic-gate 	case PIOCSEXIT:		/* set syscall exit bit mask */
6947c478bd9Sstevel@tonic-gate 		pr_setentryexit(p, &un.prmask, cmd == PIOCSENTRY);
6957c478bd9Sstevel@tonic-gate 		prunlock(pnp);
6967c478bd9Sstevel@tonic-gate 		break;
6977c478bd9Sstevel@tonic-gate 
6987c478bd9Sstevel@tonic-gate 	case PIOCSRLC:		/* obsolete: set running on last /proc close */
6997c478bd9Sstevel@tonic-gate 		error = pr_set(p, prmapsetflags(PR_RLC));
7007c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7017c478bd9Sstevel@tonic-gate 		break;
7027c478bd9Sstevel@tonic-gate 
7037c478bd9Sstevel@tonic-gate 	case PIOCRRLC:		/* obsolete: reset run-on-last-close flag */
7047c478bd9Sstevel@tonic-gate 		error = pr_unset(p, prmapsetflags(PR_RLC));
7057c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7067c478bd9Sstevel@tonic-gate 		break;
7077c478bd9Sstevel@tonic-gate 
7087c478bd9Sstevel@tonic-gate 	case PIOCSFORK:		/* obsolete: set inherit-on-fork flag */
7097c478bd9Sstevel@tonic-gate 		error = pr_set(p, prmapsetflags(PR_FORK));
7107c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7117c478bd9Sstevel@tonic-gate 		break;
7127c478bd9Sstevel@tonic-gate 
7137c478bd9Sstevel@tonic-gate 	case PIOCRFORK:		/* obsolete: reset inherit-on-fork flag */
7147c478bd9Sstevel@tonic-gate 		error = pr_unset(p, prmapsetflags(PR_FORK));
7157c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7167c478bd9Sstevel@tonic-gate 		break;
7177c478bd9Sstevel@tonic-gate 
7187c478bd9Sstevel@tonic-gate 	case PIOCSET:		/* set process flags */
7197c478bd9Sstevel@tonic-gate 		error = pr_set(p, prmapsetflags(un.flags));
7207c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7217c478bd9Sstevel@tonic-gate 		break;
7227c478bd9Sstevel@tonic-gate 
7237c478bd9Sstevel@tonic-gate 	case PIOCRESET:		/* reset process flags */
7247c478bd9Sstevel@tonic-gate 		error = pr_unset(p, prmapsetflags(un.flags));
7257c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7267c478bd9Sstevel@tonic-gate 		break;
7277c478bd9Sstevel@tonic-gate 
7287c478bd9Sstevel@tonic-gate 	case PIOCGREG:		/* get general registers */
7297c478bd9Sstevel@tonic-gate 		if (t->t_state != TS_STOPPED && !VSTOPPED(t))
7307c478bd9Sstevel@tonic-gate 			bzero(un.regs, sizeof (un.regs));
7317c478bd9Sstevel@tonic-gate 		else {
7327c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
7337c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
7347c478bd9Sstevel@tonic-gate 			prgetprregs(lwp, un.regs);
7357c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
7367c478bd9Sstevel@tonic-gate 		}
7377c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7387c478bd9Sstevel@tonic-gate 		if (copyout(un.regs, cmaddr, sizeof (un.regs)))
7397c478bd9Sstevel@tonic-gate 			error = EFAULT;
7407c478bd9Sstevel@tonic-gate 		break;
7417c478bd9Sstevel@tonic-gate 
7427c478bd9Sstevel@tonic-gate 	case PIOCSREG:		/* set general registers */
7437c478bd9Sstevel@tonic-gate 		if (!ISTOPPED(t) && !VSTOPPED(t) && !DSTOPPED(t))
7447c478bd9Sstevel@tonic-gate 			error = EBUSY;
7457c478bd9Sstevel@tonic-gate 		else {
7467c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
7477c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
7487c478bd9Sstevel@tonic-gate 			prsetprregs(lwp, un.regs, 0);
7497c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
7507c478bd9Sstevel@tonic-gate 		}
7517c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7527c478bd9Sstevel@tonic-gate 		break;
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 	case PIOCGFPREG:	/* get floating-point registers */
7557c478bd9Sstevel@tonic-gate 		if (!prhasfp()) {
7567c478bd9Sstevel@tonic-gate 			prunlock(pnp);
7577c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No FP support */
7587c478bd9Sstevel@tonic-gate 			break;
7597c478bd9Sstevel@tonic-gate 		}
7607c478bd9Sstevel@tonic-gate 
7617c478bd9Sstevel@tonic-gate 		if (t->t_state != TS_STOPPED && !VSTOPPED(t))
7627c478bd9Sstevel@tonic-gate 			bzero(&un.fpregs, sizeof (un.fpregs));
7637c478bd9Sstevel@tonic-gate 		else {
7647c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
7657c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
7667c478bd9Sstevel@tonic-gate 			prgetprfpregs(lwp, &un.fpregs);
7677c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
7687c478bd9Sstevel@tonic-gate 		}
7697c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7707c478bd9Sstevel@tonic-gate 		if (copyout(&un.fpregs, cmaddr, sizeof (un.fpregs)))
7717c478bd9Sstevel@tonic-gate 			error = EFAULT;
7727c478bd9Sstevel@tonic-gate 		break;
7737c478bd9Sstevel@tonic-gate 
7747c478bd9Sstevel@tonic-gate 	case PIOCSFPREG:	/* set floating-point registers */
7757c478bd9Sstevel@tonic-gate 		if (!prhasfp())
7767c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No FP support */
7777c478bd9Sstevel@tonic-gate 		else if (!ISTOPPED(t) && !VSTOPPED(t) && !DSTOPPED(t))
7787c478bd9Sstevel@tonic-gate 			error = EBUSY;
7797c478bd9Sstevel@tonic-gate 		else {
7807c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
7817c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
7827c478bd9Sstevel@tonic-gate 			prsetprfpregs(lwp, &un.fpregs);
7837c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
7847c478bd9Sstevel@tonic-gate 		}
7857c478bd9Sstevel@tonic-gate 		prunlock(pnp);
7867c478bd9Sstevel@tonic-gate 		break;
7877c478bd9Sstevel@tonic-gate 
7887c478bd9Sstevel@tonic-gate 	case PIOCGXREGSIZE:	/* get the size of the extra registers */
7897c478bd9Sstevel@tonic-gate 	{
7907c478bd9Sstevel@tonic-gate 		int xregsize;
7917c478bd9Sstevel@tonic-gate 
7927c478bd9Sstevel@tonic-gate 		if (prhasx(p)) {
7937c478bd9Sstevel@tonic-gate 			xregsize = prgetprxregsize(p);
7947c478bd9Sstevel@tonic-gate 			prunlock(pnp);
7957c478bd9Sstevel@tonic-gate 			if (copyout(&xregsize, cmaddr, sizeof (xregsize)))
7967c478bd9Sstevel@tonic-gate 				error = EFAULT;
7977c478bd9Sstevel@tonic-gate 		} else {
7987c478bd9Sstevel@tonic-gate 			prunlock(pnp);
7997c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No extra register support */
8007c478bd9Sstevel@tonic-gate 		}
8017c478bd9Sstevel@tonic-gate 		break;
8027c478bd9Sstevel@tonic-gate 	}
8037c478bd9Sstevel@tonic-gate 
8047c478bd9Sstevel@tonic-gate 	case PIOCGXREG:		/* get extra registers */
8057c478bd9Sstevel@tonic-gate 		if (prhasx(p)) {
8067c478bd9Sstevel@tonic-gate 			bzero(thing, thingsize);
8077c478bd9Sstevel@tonic-gate 			if (t->t_state == TS_STOPPED || VSTOPPED(t)) {
8087c478bd9Sstevel@tonic-gate 				/* drop p_lock to touch the stack */
8097c478bd9Sstevel@tonic-gate 				mutex_exit(&p->p_lock);
8107c478bd9Sstevel@tonic-gate 				prgetprxregs(lwp, thing);
8117c478bd9Sstevel@tonic-gate 				mutex_enter(&p->p_lock);
8127c478bd9Sstevel@tonic-gate 			}
8137c478bd9Sstevel@tonic-gate 			prunlock(pnp);
8147c478bd9Sstevel@tonic-gate 			if (copyout(thing, cmaddr, thingsize))
8157c478bd9Sstevel@tonic-gate 				error = EFAULT;
8167c478bd9Sstevel@tonic-gate 		} else {
8177c478bd9Sstevel@tonic-gate 			prunlock(pnp);
8187c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No extra register support */
8197c478bd9Sstevel@tonic-gate 		}
8207c478bd9Sstevel@tonic-gate 		if (thing) {
8217c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
8227c478bd9Sstevel@tonic-gate 			thing = NULL;
8237c478bd9Sstevel@tonic-gate 		}
8247c478bd9Sstevel@tonic-gate 		break;
8257c478bd9Sstevel@tonic-gate 
8267c478bd9Sstevel@tonic-gate 	case PIOCSXREG:		/* set extra registers */
8277c478bd9Sstevel@tonic-gate 		if (!ISTOPPED(t) && !VSTOPPED(t) && !DSTOPPED(t))
8287c478bd9Sstevel@tonic-gate 			error = EBUSY;
8297c478bd9Sstevel@tonic-gate 		else if (!prhasx(p))
8307c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No extra register support */
8317c478bd9Sstevel@tonic-gate 		else if (thing) {
8327c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
8337c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
8347c478bd9Sstevel@tonic-gate 			prsetprxregs(lwp, thing);
8357c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
8367c478bd9Sstevel@tonic-gate 		}
8377c478bd9Sstevel@tonic-gate 		prunlock(pnp);
8387c478bd9Sstevel@tonic-gate 		if (thing) {
8397c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
8407c478bd9Sstevel@tonic-gate 			thing = NULL;
8417c478bd9Sstevel@tonic-gate 		}
8427c478bd9Sstevel@tonic-gate 		break;
8437c478bd9Sstevel@tonic-gate 
8447c478bd9Sstevel@tonic-gate 	case PIOCSTATUS:	/* get process/lwp status */
845fa9e4066Sahrens 		oprgetstatus(t, &un.prstat, VTOZONE(vp));
8467c478bd9Sstevel@tonic-gate 		prunlock(pnp);
8477c478bd9Sstevel@tonic-gate 		if (copyout(&un.prstat, cmaddr, sizeof (un.prstat)))
8487c478bd9Sstevel@tonic-gate 			error = EFAULT;
8497c478bd9Sstevel@tonic-gate 		break;
8507c478bd9Sstevel@tonic-gate 
8517c478bd9Sstevel@tonic-gate 	case PIOCLSTATUS:	/* get status for process & all lwps */
8527c478bd9Sstevel@tonic-gate 	{
8537c478bd9Sstevel@tonic-gate 		int Nlwp;
8547c478bd9Sstevel@tonic-gate 		int nlwp;
8557c478bd9Sstevel@tonic-gate 		prstatus_t *Bprsp;
8567c478bd9Sstevel@tonic-gate 		prstatus_t *prsp;
8577c478bd9Sstevel@tonic-gate 
8587c478bd9Sstevel@tonic-gate 		nlwp = Nlwp = p->p_lwpcnt;
8597c478bd9Sstevel@tonic-gate 
8607c478bd9Sstevel@tonic-gate 		if (thing && thingsize != (Nlwp+1) * sizeof (prstatus_t)) {
8617c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
8627c478bd9Sstevel@tonic-gate 			thing = NULL;
8637c478bd9Sstevel@tonic-gate 		}
8647c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
8657c478bd9Sstevel@tonic-gate 			thingsize = (Nlwp+1) * sizeof (prstatus_t);
8667c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
8677c478bd9Sstevel@tonic-gate 		}
8687c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
8697c478bd9Sstevel@tonic-gate 			prunlock(pnp);
8707c478bd9Sstevel@tonic-gate 			goto startover;
8717c478bd9Sstevel@tonic-gate 		}
8727c478bd9Sstevel@tonic-gate 
8737c478bd9Sstevel@tonic-gate 		Bprsp = thing;
8747c478bd9Sstevel@tonic-gate 		thing = NULL;
8757c478bd9Sstevel@tonic-gate 		prsp = Bprsp;
876fa9e4066Sahrens 		oprgetstatus(t, prsp, VTOZONE(vp));
8777c478bd9Sstevel@tonic-gate 		t = p->p_tlist;
8787c478bd9Sstevel@tonic-gate 		do {
8797c478bd9Sstevel@tonic-gate 			ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
8807c478bd9Sstevel@tonic-gate 			ASSERT(nlwp > 0);
8817c478bd9Sstevel@tonic-gate 			--nlwp;
882fa9e4066Sahrens 			oprgetstatus(t, ++prsp, VTOZONE(vp));
8837c478bd9Sstevel@tonic-gate 		} while ((t = t->t_forw) != p->p_tlist);
8847c478bd9Sstevel@tonic-gate 		ASSERT(nlwp == 0);
8857c478bd9Sstevel@tonic-gate 		prunlock(pnp);
8867c478bd9Sstevel@tonic-gate 		if (copyout(Bprsp, cmaddr, (Nlwp+1) * sizeof (prstatus_t)))
8877c478bd9Sstevel@tonic-gate 			error = EFAULT;
8887c478bd9Sstevel@tonic-gate 
8897c478bd9Sstevel@tonic-gate 		kmem_free(Bprsp, (Nlwp+1) * sizeof (prstatus_t));
8907c478bd9Sstevel@tonic-gate 		break;
8917c478bd9Sstevel@tonic-gate 	}
8927c478bd9Sstevel@tonic-gate 
8937c478bd9Sstevel@tonic-gate 	case PIOCPSINFO:	/* get ps(1) information */
8947c478bd9Sstevel@tonic-gate 	{
8957c478bd9Sstevel@tonic-gate 		prpsinfo_t *psp = &un.prps;
8967c478bd9Sstevel@tonic-gate 
8977c478bd9Sstevel@tonic-gate 		oprgetpsinfo(p, psp,
8987c478bd9Sstevel@tonic-gate 		    (pnp->pr_type == PR_LWPIDFILE)? pcp->prc_thread : NULL);
8997c478bd9Sstevel@tonic-gate 
9007c478bd9Sstevel@tonic-gate 		prunlock(pnp);
9017c478bd9Sstevel@tonic-gate 		if (copyout(&un.prps, cmaddr, sizeof (un.prps)))
9027c478bd9Sstevel@tonic-gate 			error = EFAULT;
9037c478bd9Sstevel@tonic-gate 		break;
9047c478bd9Sstevel@tonic-gate 	}
9057c478bd9Sstevel@tonic-gate 
9067c478bd9Sstevel@tonic-gate 	case PIOCMAXSIG:	/* get maximum signal number */
9077c478bd9Sstevel@tonic-gate 	{
908eb9dbf0cSRoger A. Faulkner 		int n = nsig-1;
9097c478bd9Sstevel@tonic-gate 
9107c478bd9Sstevel@tonic-gate 		prunlock(pnp);
9117c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (n)))
9127c478bd9Sstevel@tonic-gate 			error = EFAULT;
9137c478bd9Sstevel@tonic-gate 		break;
9147c478bd9Sstevel@tonic-gate 	}
9157c478bd9Sstevel@tonic-gate 
9167c478bd9Sstevel@tonic-gate 	case PIOCACTION:	/* get signal action structures */
9177c478bd9Sstevel@tonic-gate 	{
9187c478bd9Sstevel@tonic-gate 		uint_t sig;
9197c478bd9Sstevel@tonic-gate 		struct sigaction *sap = thing;
9207c478bd9Sstevel@tonic-gate 
9217c478bd9Sstevel@tonic-gate 		up = PTOU(p);
922eb9dbf0cSRoger A. Faulkner 		for (sig = 1; sig < nsig; sig++)
9237c478bd9Sstevel@tonic-gate 			prgetaction(p, up, sig, &sap[sig-1]);
9247c478bd9Sstevel@tonic-gate 		prunlock(pnp);
925eb9dbf0cSRoger A. Faulkner 		if (copyout(sap, cmaddr, (nsig-1) * sizeof (struct sigaction)))
9267c478bd9Sstevel@tonic-gate 			error = EFAULT;
927eb9dbf0cSRoger A. Faulkner 		kmem_free(sap, (nsig-1) * sizeof (struct sigaction));
9287c478bd9Sstevel@tonic-gate 		thing = NULL;
9297c478bd9Sstevel@tonic-gate 		break;
9307c478bd9Sstevel@tonic-gate 	}
9317c478bd9Sstevel@tonic-gate 
9327c478bd9Sstevel@tonic-gate 	case PIOCGHOLD:		/* get signal-hold mask */
9337c478bd9Sstevel@tonic-gate 		schedctl_finish_sigblock(t);
9347c478bd9Sstevel@tonic-gate 		sigktou(&t->t_hold, &un.holdmask);
9357c478bd9Sstevel@tonic-gate 		prunlock(pnp);
9367c478bd9Sstevel@tonic-gate 		if (copyout(&un.holdmask, cmaddr, sizeof (un.holdmask)))
9377c478bd9Sstevel@tonic-gate 			error = EFAULT;
9387c478bd9Sstevel@tonic-gate 		break;
9397c478bd9Sstevel@tonic-gate 
9407c478bd9Sstevel@tonic-gate 	case PIOCSHOLD:		/* set signal-hold mask */
9417c478bd9Sstevel@tonic-gate 		pr_sethold(pnp, &un.holdmask);
9427c478bd9Sstevel@tonic-gate 		prunlock(pnp);
9437c478bd9Sstevel@tonic-gate 		break;
9447c478bd9Sstevel@tonic-gate 
9457c478bd9Sstevel@tonic-gate 	case PIOCNMAP:		/* get number of memory mappings */
9467c478bd9Sstevel@tonic-gate 	{
9477c478bd9Sstevel@tonic-gate 		int n;
9487c478bd9Sstevel@tonic-gate 		struct as *as = p->p_as;
9497c478bd9Sstevel@tonic-gate 
9507c478bd9Sstevel@tonic-gate 		if ((p->p_flag & SSYS) || as == &kas)
9517c478bd9Sstevel@tonic-gate 			n = 0;
9527c478bd9Sstevel@tonic-gate 		else {
9537c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
954dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_ENTER(as, RW_WRITER);
9557c478bd9Sstevel@tonic-gate 			n = prnsegs(as, 0);
956dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_EXIT(as);
9577c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
9587c478bd9Sstevel@tonic-gate 		}
9597c478bd9Sstevel@tonic-gate 		prunlock(pnp);
9607c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (int)))
9617c478bd9Sstevel@tonic-gate 			error = EFAULT;
9627c478bd9Sstevel@tonic-gate 		break;
9637c478bd9Sstevel@tonic-gate 	}
9647c478bd9Sstevel@tonic-gate 
9657c478bd9Sstevel@tonic-gate 	case PIOCMAP:		/* get memory map information */
9667c478bd9Sstevel@tonic-gate 	{
967870619e9Sfrankho 		list_t iolhead;
9687c478bd9Sstevel@tonic-gate 		struct as *as = p->p_as;
9697c478bd9Sstevel@tonic-gate 
970870619e9Sfrankho 		if ((p->p_flag & SSYS) || as == &kas) {
971870619e9Sfrankho 			error = 0;
972870619e9Sfrankho 			prunlock(pnp);
9737c478bd9Sstevel@tonic-gate 		} else {
9747c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
975dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_ENTER(as, RW_WRITER);
976870619e9Sfrankho 			error = oprgetmap(p, &iolhead);
977dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_EXIT(as);
9787c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
979870619e9Sfrankho 			prunlock(pnp);
9807c478bd9Sstevel@tonic-gate 
981870619e9Sfrankho 			error = pr_iol_copyout_and_free(&iolhead,
982870619e9Sfrankho 			    &cmaddr, error);
983870619e9Sfrankho 		}
984870619e9Sfrankho 		/*
985870619e9Sfrankho 		 * The procfs PIOCMAP ioctl returns an all-zero buffer
986870619e9Sfrankho 		 * to indicate the end of the prmap[] array.
987870619e9Sfrankho 		 * Append it to whatever has already been copied out.
988870619e9Sfrankho 		 */
989870619e9Sfrankho 		bzero(&un.prmap, sizeof (un.prmap));
990870619e9Sfrankho 		if (!error && copyout(&un.prmap, cmaddr, sizeof (un.prmap)))
9917c478bd9Sstevel@tonic-gate 			error = EFAULT;
992870619e9Sfrankho 
9937c478bd9Sstevel@tonic-gate 		break;
9947c478bd9Sstevel@tonic-gate 	}
9957c478bd9Sstevel@tonic-gate 
9967c478bd9Sstevel@tonic-gate 	case PIOCGFAULT:	/* get mask of traced faults */
9977c478bd9Sstevel@tonic-gate 		prassignset(&un.fltmask, &p->p_fltmask);
9987c478bd9Sstevel@tonic-gate 		prunlock(pnp);
9997c478bd9Sstevel@tonic-gate 		if (copyout(&un.fltmask, cmaddr, sizeof (un.fltmask)))
10007c478bd9Sstevel@tonic-gate 			error = EFAULT;
10017c478bd9Sstevel@tonic-gate 		break;
10027c478bd9Sstevel@tonic-gate 
10037c478bd9Sstevel@tonic-gate 	case PIOCSFAULT:	/* set mask of traced faults */
10047c478bd9Sstevel@tonic-gate 		pr_setfault(p, &un.fltmask);
10057c478bd9Sstevel@tonic-gate 		prunlock(pnp);
10067c478bd9Sstevel@tonic-gate 		break;
10077c478bd9Sstevel@tonic-gate 
10087c478bd9Sstevel@tonic-gate 	case PIOCCFAULT:	/* clear current fault */
10097c478bd9Sstevel@tonic-gate 		lwp->lwp_curflt = 0;
10107c478bd9Sstevel@tonic-gate 		prunlock(pnp);
10117c478bd9Sstevel@tonic-gate 		break;
10127c478bd9Sstevel@tonic-gate 
10137c478bd9Sstevel@tonic-gate 	case PIOCCRED:		/* get process credentials */
10147c478bd9Sstevel@tonic-gate 	{
10157c478bd9Sstevel@tonic-gate 		cred_t *cp;
10167c478bd9Sstevel@tonic-gate 
10177c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_crlock);
10187c478bd9Sstevel@tonic-gate 		cp = p->p_cred;
10197c478bd9Sstevel@tonic-gate 		un.prcred.pr_euid = crgetuid(cp);
10207c478bd9Sstevel@tonic-gate 		un.prcred.pr_ruid = crgetruid(cp);
10217c478bd9Sstevel@tonic-gate 		un.prcred.pr_suid = crgetsuid(cp);
10227c478bd9Sstevel@tonic-gate 		un.prcred.pr_egid = crgetgid(cp);
10237c478bd9Sstevel@tonic-gate 		un.prcred.pr_rgid = crgetrgid(cp);
10247c478bd9Sstevel@tonic-gate 		un.prcred.pr_sgid = crgetsgid(cp);
10257c478bd9Sstevel@tonic-gate 		un.prcred.pr_ngroups = crgetngroups(cp);
10267c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_crlock);
10277c478bd9Sstevel@tonic-gate 
10287c478bd9Sstevel@tonic-gate 		prunlock(pnp);
10297c478bd9Sstevel@tonic-gate 		if (copyout(&un.prcred, cmaddr, sizeof (un.prcred)))
10307c478bd9Sstevel@tonic-gate 			error = EFAULT;
10317c478bd9Sstevel@tonic-gate 		break;
10327c478bd9Sstevel@tonic-gate 	}
10337c478bd9Sstevel@tonic-gate 
10347c478bd9Sstevel@tonic-gate 	case PIOCGROUPS:	/* get supplementary groups */
10357c478bd9Sstevel@tonic-gate 	{
10367c478bd9Sstevel@tonic-gate 		cred_t *cp;
10377c478bd9Sstevel@tonic-gate 
10387c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_crlock);
10397c478bd9Sstevel@tonic-gate 		cp = p->p_cred;
10407c478bd9Sstevel@tonic-gate 		crhold(cp);
10417c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_crlock);
10427c478bd9Sstevel@tonic-gate 
10437c478bd9Sstevel@tonic-gate 		prunlock(pnp);
10447c478bd9Sstevel@tonic-gate 		if (copyout(crgetgroups(cp), cmaddr,
10457c478bd9Sstevel@tonic-gate 		    MAX(crgetngroups(cp), 1) * sizeof (gid_t)))
10467c478bd9Sstevel@tonic-gate 			error = EFAULT;
10477c478bd9Sstevel@tonic-gate 		crfree(cp);
10487c478bd9Sstevel@tonic-gate 		break;
10497c478bd9Sstevel@tonic-gate 	}
10507c478bd9Sstevel@tonic-gate 
10517c478bd9Sstevel@tonic-gate 	case PIOCUSAGE:		/* get usage info */
10527c478bd9Sstevel@tonic-gate 	{
10537c478bd9Sstevel@tonic-gate 		/*
10547c478bd9Sstevel@tonic-gate 		 * For an lwp file descriptor, return just the lwp usage.
10557c478bd9Sstevel@tonic-gate 		 * For a process file descriptor, return total usage,
10567c478bd9Sstevel@tonic-gate 		 * all current lwps plus all defunct lwps.
10577c478bd9Sstevel@tonic-gate 		 */
10587c478bd9Sstevel@tonic-gate 		prhusage_t *pup = &un.prhusage;
10597c478bd9Sstevel@tonic-gate 		prusage_t *upup;
10607c478bd9Sstevel@tonic-gate 
10617c478bd9Sstevel@tonic-gate 		bzero(pup, sizeof (*pup));
10627c478bd9Sstevel@tonic-gate 		pup->pr_tstamp = gethrtime();
10637c478bd9Sstevel@tonic-gate 
10647c478bd9Sstevel@tonic-gate 		if (pnp->pr_type == PR_LWPIDFILE) {
10657c478bd9Sstevel@tonic-gate 			t = pcp->prc_thread;
10667c478bd9Sstevel@tonic-gate 			if (t != NULL)
10677c478bd9Sstevel@tonic-gate 				prgetusage(t, pup);
10687c478bd9Sstevel@tonic-gate 			else
10697c478bd9Sstevel@tonic-gate 				error = ENOENT;
10707c478bd9Sstevel@tonic-gate 		} else {
10717c478bd9Sstevel@tonic-gate 			pup->pr_count  = p->p_defunct;
10727c478bd9Sstevel@tonic-gate 			pup->pr_create = p->p_mstart;
10737c478bd9Sstevel@tonic-gate 			pup->pr_term   = p->p_mterm;
10747c478bd9Sstevel@tonic-gate 
10757c478bd9Sstevel@tonic-gate 			pup->pr_rtime    = p->p_mlreal;
10767c478bd9Sstevel@tonic-gate 			pup->pr_utime    = p->p_acct[LMS_USER];
10777c478bd9Sstevel@tonic-gate 			pup->pr_stime    = p->p_acct[LMS_SYSTEM];
10787c478bd9Sstevel@tonic-gate 			pup->pr_ttime    = p->p_acct[LMS_TRAP];
10797c478bd9Sstevel@tonic-gate 			pup->pr_tftime   = p->p_acct[LMS_TFAULT];
10807c478bd9Sstevel@tonic-gate 			pup->pr_dftime   = p->p_acct[LMS_DFAULT];
10817c478bd9Sstevel@tonic-gate 			pup->pr_kftime   = p->p_acct[LMS_KFAULT];
10827c478bd9Sstevel@tonic-gate 			pup->pr_ltime    = p->p_acct[LMS_USER_LOCK];
10837c478bd9Sstevel@tonic-gate 			pup->pr_slptime  = p->p_acct[LMS_SLEEP];
10847c478bd9Sstevel@tonic-gate 			pup->pr_wtime    = p->p_acct[LMS_WAIT_CPU];
10857c478bd9Sstevel@tonic-gate 			pup->pr_stoptime = p->p_acct[LMS_STOPPED];
10867c478bd9Sstevel@tonic-gate 
10877c478bd9Sstevel@tonic-gate 			pup->pr_minf  = p->p_ru.minflt;
10887c478bd9Sstevel@tonic-gate 			pup->pr_majf  = p->p_ru.majflt;
10897c478bd9Sstevel@tonic-gate 			pup->pr_nswap = p->p_ru.nswap;
10907c478bd9Sstevel@tonic-gate 			pup->pr_inblk = p->p_ru.inblock;
10917c478bd9Sstevel@tonic-gate 			pup->pr_oublk = p->p_ru.oublock;
10927c478bd9Sstevel@tonic-gate 			pup->pr_msnd  = p->p_ru.msgsnd;
10937c478bd9Sstevel@tonic-gate 			pup->pr_mrcv  = p->p_ru.msgrcv;
10947c478bd9Sstevel@tonic-gate 			pup->pr_sigs  = p->p_ru.nsignals;
10957c478bd9Sstevel@tonic-gate 			pup->pr_vctx  = p->p_ru.nvcsw;
10967c478bd9Sstevel@tonic-gate 			pup->pr_ictx  = p->p_ru.nivcsw;
10977c478bd9Sstevel@tonic-gate 			pup->pr_sysc  = p->p_ru.sysc;
10987c478bd9Sstevel@tonic-gate 			pup->pr_ioch  = p->p_ru.ioch;
10997c478bd9Sstevel@tonic-gate 
11007c478bd9Sstevel@tonic-gate 			/*
11017c478bd9Sstevel@tonic-gate 			 * Add the usage information for each active lwp.
11027c478bd9Sstevel@tonic-gate 			 */
11037c478bd9Sstevel@tonic-gate 			if ((t = p->p_tlist) != NULL &&
11047c478bd9Sstevel@tonic-gate 			    !(pcp->prc_flags & PRC_DESTROY)) {
11057c478bd9Sstevel@tonic-gate 				do {
11067c478bd9Sstevel@tonic-gate 					ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
11077c478bd9Sstevel@tonic-gate 					pup->pr_count++;
11087c478bd9Sstevel@tonic-gate 					praddusage(t, pup);
11097c478bd9Sstevel@tonic-gate 				} while ((t = t->t_forw) != p->p_tlist);
11107c478bd9Sstevel@tonic-gate 			}
11117c478bd9Sstevel@tonic-gate 		}
11127c478bd9Sstevel@tonic-gate 
11137c478bd9Sstevel@tonic-gate 		prunlock(pnp);
11147c478bd9Sstevel@tonic-gate 
11157c478bd9Sstevel@tonic-gate 		upup = kmem_zalloc(sizeof (*upup), KM_SLEEP);
11167c478bd9Sstevel@tonic-gate 		prcvtusage(&un.prhusage, upup);
11177c478bd9Sstevel@tonic-gate 		if (copyout(upup, cmaddr, sizeof (*upup)))
11187c478bd9Sstevel@tonic-gate 			error = EFAULT;
11197c478bd9Sstevel@tonic-gate 		kmem_free(upup, sizeof (*upup));
11207c478bd9Sstevel@tonic-gate 
11217c478bd9Sstevel@tonic-gate 		break;
11227c478bd9Sstevel@tonic-gate 	}
11237c478bd9Sstevel@tonic-gate 
11247c478bd9Sstevel@tonic-gate 	case PIOCLUSAGE:	/* get detailed usage info */
11257c478bd9Sstevel@tonic-gate 	{
11267c478bd9Sstevel@tonic-gate 		int Nlwp;
11277c478bd9Sstevel@tonic-gate 		int nlwp;
11287c478bd9Sstevel@tonic-gate 		prusage_t *upup;
11297c478bd9Sstevel@tonic-gate 		prusage_t *Bupup;
11307c478bd9Sstevel@tonic-gate 		prhusage_t *pup;
11317c478bd9Sstevel@tonic-gate 		hrtime_t curtime;
11327c478bd9Sstevel@tonic-gate 
11337c478bd9Sstevel@tonic-gate 		nlwp = Nlwp = (pcp->prc_flags & PRC_DESTROY)? 0 : p->p_lwpcnt;
11347c478bd9Sstevel@tonic-gate 
11357c478bd9Sstevel@tonic-gate 		if (thing && thingsize !=
11367c478bd9Sstevel@tonic-gate 		    sizeof (prhusage_t) + (Nlwp+1) * sizeof (prusage_t)) {
11377c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
11387c478bd9Sstevel@tonic-gate 			thing = NULL;
11397c478bd9Sstevel@tonic-gate 		}
11407c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
11417c478bd9Sstevel@tonic-gate 			thingsize = sizeof (prhusage_t) +
11427c478bd9Sstevel@tonic-gate 			    (Nlwp+1) * sizeof (prusage_t);
11437c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
11447c478bd9Sstevel@tonic-gate 		}
11457c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
11467c478bd9Sstevel@tonic-gate 			prunlock(pnp);
11477c478bd9Sstevel@tonic-gate 			goto startover;
11487c478bd9Sstevel@tonic-gate 		}
11497c478bd9Sstevel@tonic-gate 
11507c478bd9Sstevel@tonic-gate 		pup = thing;
11517c478bd9Sstevel@tonic-gate 		upup = Bupup = (prusage_t *)(pup + 1);
11527c478bd9Sstevel@tonic-gate 
11537c478bd9Sstevel@tonic-gate 		ASSERT(p == pcp->prc_proc);
11547c478bd9Sstevel@tonic-gate 
11557c478bd9Sstevel@tonic-gate 		curtime = gethrtime();
11567c478bd9Sstevel@tonic-gate 
11577c478bd9Sstevel@tonic-gate 		/*
11587c478bd9Sstevel@tonic-gate 		 * First the summation over defunct lwps.
11597c478bd9Sstevel@tonic-gate 		 */
11607c478bd9Sstevel@tonic-gate 		bzero(pup, sizeof (*pup));
11617c478bd9Sstevel@tonic-gate 		pup->pr_count  = p->p_defunct;
11627c478bd9Sstevel@tonic-gate 		pup->pr_tstamp = curtime;
11637c478bd9Sstevel@tonic-gate 		pup->pr_create = p->p_mstart;
11647c478bd9Sstevel@tonic-gate 		pup->pr_term   = p->p_mterm;
11657c478bd9Sstevel@tonic-gate 
11667c478bd9Sstevel@tonic-gate 		pup->pr_rtime    = p->p_mlreal;
11677c478bd9Sstevel@tonic-gate 		pup->pr_utime    = p->p_acct[LMS_USER];
11687c478bd9Sstevel@tonic-gate 		pup->pr_stime    = p->p_acct[LMS_SYSTEM];
11697c478bd9Sstevel@tonic-gate 		pup->pr_ttime    = p->p_acct[LMS_TRAP];
11707c478bd9Sstevel@tonic-gate 		pup->pr_tftime   = p->p_acct[LMS_TFAULT];
11717c478bd9Sstevel@tonic-gate 		pup->pr_dftime   = p->p_acct[LMS_DFAULT];
11727c478bd9Sstevel@tonic-gate 		pup->pr_kftime   = p->p_acct[LMS_KFAULT];
11737c478bd9Sstevel@tonic-gate 		pup->pr_ltime    = p->p_acct[LMS_USER_LOCK];
11747c478bd9Sstevel@tonic-gate 		pup->pr_slptime  = p->p_acct[LMS_SLEEP];
11757c478bd9Sstevel@tonic-gate 		pup->pr_wtime    = p->p_acct[LMS_WAIT_CPU];
11767c478bd9Sstevel@tonic-gate 		pup->pr_stoptime = p->p_acct[LMS_STOPPED];
11777c478bd9Sstevel@tonic-gate 
11787c478bd9Sstevel@tonic-gate 		pup->pr_minf  = p->p_ru.minflt;
11797c478bd9Sstevel@tonic-gate 		pup->pr_majf  = p->p_ru.majflt;
11807c478bd9Sstevel@tonic-gate 		pup->pr_nswap = p->p_ru.nswap;
11817c478bd9Sstevel@tonic-gate 		pup->pr_inblk = p->p_ru.inblock;
11827c478bd9Sstevel@tonic-gate 		pup->pr_oublk = p->p_ru.oublock;
11837c478bd9Sstevel@tonic-gate 		pup->pr_msnd  = p->p_ru.msgsnd;
11847c478bd9Sstevel@tonic-gate 		pup->pr_mrcv  = p->p_ru.msgrcv;
11857c478bd9Sstevel@tonic-gate 		pup->pr_sigs  = p->p_ru.nsignals;
11867c478bd9Sstevel@tonic-gate 		pup->pr_vctx  = p->p_ru.nvcsw;
11877c478bd9Sstevel@tonic-gate 		pup->pr_ictx  = p->p_ru.nivcsw;
11887c478bd9Sstevel@tonic-gate 		pup->pr_sysc  = p->p_ru.sysc;
11897c478bd9Sstevel@tonic-gate 		pup->pr_ioch  = p->p_ru.ioch;
11907c478bd9Sstevel@tonic-gate 
11917c478bd9Sstevel@tonic-gate 		prcvtusage(pup, upup);
11927c478bd9Sstevel@tonic-gate 
11937c478bd9Sstevel@tonic-gate 		/*
11947c478bd9Sstevel@tonic-gate 		 * Fill one prusage struct for each active lwp.
11957c478bd9Sstevel@tonic-gate 		 */
11967c478bd9Sstevel@tonic-gate 		if ((t = p->p_tlist) != NULL &&
11977c478bd9Sstevel@tonic-gate 		    !(pcp->prc_flags & PRC_DESTROY)) {
11987c478bd9Sstevel@tonic-gate 			do {
11997c478bd9Sstevel@tonic-gate 				ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
12007c478bd9Sstevel@tonic-gate 				ASSERT(nlwp > 0);
12017c478bd9Sstevel@tonic-gate 				--nlwp;
12027c478bd9Sstevel@tonic-gate 				upup++;
12037c478bd9Sstevel@tonic-gate 				prgetusage(t, pup);
12047c478bd9Sstevel@tonic-gate 				prcvtusage(pup, upup);
12057c478bd9Sstevel@tonic-gate 			} while ((t = t->t_forw) != p->p_tlist);
12067c478bd9Sstevel@tonic-gate 		}
12077c478bd9Sstevel@tonic-gate 		ASSERT(nlwp == 0);
12087c478bd9Sstevel@tonic-gate 
12097c478bd9Sstevel@tonic-gate 		prunlock(pnp);
12107c478bd9Sstevel@tonic-gate 		if (copyout(Bupup, cmaddr, (Nlwp+1) * sizeof (prusage_t)))
12117c478bd9Sstevel@tonic-gate 			error = EFAULT;
12127c478bd9Sstevel@tonic-gate 		kmem_free(thing, thingsize);
12137c478bd9Sstevel@tonic-gate 		thing = NULL;
12147c478bd9Sstevel@tonic-gate 		break;
12157c478bd9Sstevel@tonic-gate 	}
12167c478bd9Sstevel@tonic-gate 
12177c478bd9Sstevel@tonic-gate 	case PIOCNAUXV:		/* get number of aux vector entries */
12187c478bd9Sstevel@tonic-gate 	{
12197c478bd9Sstevel@tonic-gate 		int n = __KERN_NAUXV_IMPL;
12207c478bd9Sstevel@tonic-gate 
12217c478bd9Sstevel@tonic-gate 		prunlock(pnp);
12227c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (int)))
12237c478bd9Sstevel@tonic-gate 			error = EFAULT;
12247c478bd9Sstevel@tonic-gate 		break;
12257c478bd9Sstevel@tonic-gate 	}
12267c478bd9Sstevel@tonic-gate 
12277c478bd9Sstevel@tonic-gate 	case PIOCAUXV:		/* get aux vector (see sys/auxv.h) */
12287c478bd9Sstevel@tonic-gate 	{
12297c478bd9Sstevel@tonic-gate 		up = PTOU(p);
12307c478bd9Sstevel@tonic-gate 		bcopy(up->u_auxv, un.auxv,
12317c478bd9Sstevel@tonic-gate 		    __KERN_NAUXV_IMPL * sizeof (auxv_t));
12327c478bd9Sstevel@tonic-gate 		prunlock(pnp);
12337c478bd9Sstevel@tonic-gate 		if (copyout(un.auxv, cmaddr,
12347c478bd9Sstevel@tonic-gate 		    __KERN_NAUXV_IMPL * sizeof (auxv_t)))
12357c478bd9Sstevel@tonic-gate 			error = EFAULT;
12367c478bd9Sstevel@tonic-gate 		break;
12377c478bd9Sstevel@tonic-gate 	}
12387c478bd9Sstevel@tonic-gate 
12397c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__amd64)
12407c478bd9Sstevel@tonic-gate 	case PIOCNLDT:		/* get number of LDT entries */
12417c478bd9Sstevel@tonic-gate 	{
12427c478bd9Sstevel@tonic-gate 		int n;
12437c478bd9Sstevel@tonic-gate 
12446e092be7SVamsi Nagineni 		mutex_exit(&p->p_lock);
12457c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_ldtlock);
12467c478bd9Sstevel@tonic-gate 		n = prnldt(p);
12477c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_ldtlock);
12486e092be7SVamsi Nagineni 		mutex_enter(&p->p_lock);
12497c478bd9Sstevel@tonic-gate 		prunlock(pnp);
12507c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (n)))
12517c478bd9Sstevel@tonic-gate 			error = EFAULT;
12527c478bd9Sstevel@tonic-gate 		break;
12537c478bd9Sstevel@tonic-gate 	}
12547c478bd9Sstevel@tonic-gate 
12557c478bd9Sstevel@tonic-gate 	case PIOCLDT:		/* get LDT entries */
12567c478bd9Sstevel@tonic-gate 	{
12577c478bd9Sstevel@tonic-gate 		struct ssd *ssd;
12587c478bd9Sstevel@tonic-gate 		int n;
12597c478bd9Sstevel@tonic-gate 
12606e092be7SVamsi Nagineni 		mutex_exit(&p->p_lock);
12617c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_ldtlock);
12627c478bd9Sstevel@tonic-gate 		n = prnldt(p);
12637c478bd9Sstevel@tonic-gate 
12647c478bd9Sstevel@tonic-gate 		if (thing && thingsize != (n+1) * sizeof (*ssd)) {
12657c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
12667c478bd9Sstevel@tonic-gate 			thing = NULL;
12677c478bd9Sstevel@tonic-gate 		}
12687c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
12697c478bd9Sstevel@tonic-gate 			thingsize = (n+1) * sizeof (*ssd);
12707c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
12717c478bd9Sstevel@tonic-gate 		}
12727c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
12737c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_ldtlock);
12746e092be7SVamsi Nagineni 			mutex_enter(&p->p_lock);
12757c478bd9Sstevel@tonic-gate 			prunlock(pnp);
12767c478bd9Sstevel@tonic-gate 			goto startover;
12777c478bd9Sstevel@tonic-gate 		}
12787c478bd9Sstevel@tonic-gate 
12797c478bd9Sstevel@tonic-gate 		ssd = thing;
12807c478bd9Sstevel@tonic-gate 		thing = NULL;
12817c478bd9Sstevel@tonic-gate 		if (n != 0)
12827c478bd9Sstevel@tonic-gate 			prgetldt(p, ssd);
12837c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_ldtlock);
12846e092be7SVamsi Nagineni 		mutex_enter(&p->p_lock);
12857c478bd9Sstevel@tonic-gate 		prunlock(pnp);
12867c478bd9Sstevel@tonic-gate 
12877c478bd9Sstevel@tonic-gate 		/* mark the end of the list with a null entry */
12887c478bd9Sstevel@tonic-gate 		bzero(&ssd[n], sizeof (*ssd));
12897c478bd9Sstevel@tonic-gate 		if (copyout(ssd, cmaddr, (n+1) * sizeof (*ssd)))
12907c478bd9Sstevel@tonic-gate 			error = EFAULT;
12917c478bd9Sstevel@tonic-gate 		kmem_free(ssd, (n+1) * sizeof (*ssd));
12927c478bd9Sstevel@tonic-gate 		break;
12937c478bd9Sstevel@tonic-gate 	}
12947c478bd9Sstevel@tonic-gate #endif	/* __i386 || __amd64 */
12957c478bd9Sstevel@tonic-gate 
12967c478bd9Sstevel@tonic-gate #if defined(__sparc)
12977c478bd9Sstevel@tonic-gate 	case PIOCGWIN:		/* get gwindows_t (see sys/reg.h) */
12987c478bd9Sstevel@tonic-gate 	{
12997c478bd9Sstevel@tonic-gate 		gwindows_t *gwp = thing;
13007c478bd9Sstevel@tonic-gate 
13017c478bd9Sstevel@tonic-gate 		/* drop p->p_lock while touching the stack */
13027c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
13037c478bd9Sstevel@tonic-gate 		bzero(gwp, sizeof (*gwp));
13047c478bd9Sstevel@tonic-gate 		prgetwindows(lwp, gwp);
13057c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_lock);
13067c478bd9Sstevel@tonic-gate 		prunlock(pnp);
13077c478bd9Sstevel@tonic-gate 		if (copyout(gwp, cmaddr, sizeof (*gwp)))
13087c478bd9Sstevel@tonic-gate 			error = EFAULT;
13097c478bd9Sstevel@tonic-gate 		kmem_free(gwp, sizeof (gwindows_t));
13107c478bd9Sstevel@tonic-gate 		thing = NULL;
13117c478bd9Sstevel@tonic-gate 		break;
13127c478bd9Sstevel@tonic-gate 	}
13137c478bd9Sstevel@tonic-gate #endif	/* __sparc */
13147c478bd9Sstevel@tonic-gate 
13157c478bd9Sstevel@tonic-gate 	default:
13167c478bd9Sstevel@tonic-gate 		prunlock(pnp);
13177c478bd9Sstevel@tonic-gate 		error = EINVAL;
13187c478bd9Sstevel@tonic-gate 		break;
13197c478bd9Sstevel@tonic-gate 
13207c478bd9Sstevel@tonic-gate 	}
13217c478bd9Sstevel@tonic-gate 
13227c478bd9Sstevel@tonic-gate 	ASSERT(thing == NULL);
13237c478bd9Sstevel@tonic-gate 	ASSERT(xpnp == NULL);
13247c478bd9Sstevel@tonic-gate 	return (error);
13257c478bd9Sstevel@tonic-gate }
13267c478bd9Sstevel@tonic-gate 
13277c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
13287c478bd9Sstevel@tonic-gate 
1329870619e9Sfrankho static int oprgetmap32(proc_t *, list_t *);
13307c478bd9Sstevel@tonic-gate 
13317c478bd9Sstevel@tonic-gate void
13327c478bd9Sstevel@tonic-gate oprgetstatus32(kthread_t *t, prstatus32_t *sp, zone_t *zp)
13337c478bd9Sstevel@tonic-gate {
13347c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
13357c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
13367c478bd9Sstevel@tonic-gate 	int32_t flags;
13377c478bd9Sstevel@tonic-gate 	user_t *up;
13387c478bd9Sstevel@tonic-gate 	ulong_t instr;
13397c478bd9Sstevel@tonic-gate 
13407c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
13417c478bd9Sstevel@tonic-gate 
13427c478bd9Sstevel@tonic-gate 	up = PTOU(p);
13437c478bd9Sstevel@tonic-gate 	bzero(sp, sizeof (*sp));
13447c478bd9Sstevel@tonic-gate 	flags = 0L;
13457c478bd9Sstevel@tonic-gate 	if (t->t_state == TS_STOPPED) {
13467c478bd9Sstevel@tonic-gate 		flags |= PR_STOPPED;
13477c478bd9Sstevel@tonic-gate 		if ((t->t_schedflag & TS_PSTART) == 0)
13487c478bd9Sstevel@tonic-gate 			flags |= PR_ISTOP;
13497c478bd9Sstevel@tonic-gate 	} else if (VSTOPPED(t)) {
13507c478bd9Sstevel@tonic-gate 		flags |= PR_STOPPED|PR_ISTOP;
13517c478bd9Sstevel@tonic-gate 	}
13527c478bd9Sstevel@tonic-gate 	if (!(flags & PR_ISTOP) && (t->t_proc_flag & TP_PRSTOP))
13537c478bd9Sstevel@tonic-gate 		flags |= PR_DSTOP;
13547c478bd9Sstevel@tonic-gate 	if (lwp->lwp_asleep)
13557c478bd9Sstevel@tonic-gate 		flags |= PR_ASLEEP;
13567c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_FORK)
13577c478bd9Sstevel@tonic-gate 		flags |= PR_FORK;
13587c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_RUNLCL)
13597c478bd9Sstevel@tonic-gate 		flags |= PR_RLC;
13607c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_KILLCL)
13617c478bd9Sstevel@tonic-gate 		flags |= PR_KLC;
13627c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_ASYNC)
13637c478bd9Sstevel@tonic-gate 		flags |= PR_ASYNC;
13647c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_BPTADJ)
13657c478bd9Sstevel@tonic-gate 		flags |= PR_BPTADJ;
13667c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_PTRACE)
13677c478bd9Sstevel@tonic-gate 		flags |= PR_PCOMPAT;
13687c478bd9Sstevel@tonic-gate 	if (t->t_proc_flag & TP_MSACCT)
13697c478bd9Sstevel@tonic-gate 		flags |= PR_MSACCT;
13707c478bd9Sstevel@tonic-gate 	sp->pr_flags = flags;
13717c478bd9Sstevel@tonic-gate 	if (VSTOPPED(t)) {
13727c478bd9Sstevel@tonic-gate 		sp->pr_why   = PR_REQUESTED;
13737c478bd9Sstevel@tonic-gate 		sp->pr_what  = 0;
13747c478bd9Sstevel@tonic-gate 	} else {
13757c478bd9Sstevel@tonic-gate 		sp->pr_why   = t->t_whystop;
13767c478bd9Sstevel@tonic-gate 		sp->pr_what  = t->t_whatstop;
13777c478bd9Sstevel@tonic-gate 	}
13787c478bd9Sstevel@tonic-gate 
13797c478bd9Sstevel@tonic-gate 	if (t->t_whystop == PR_FAULTED) {
13807c478bd9Sstevel@tonic-gate 		siginfo_kto32(&lwp->lwp_siginfo, &sp->pr_info);
13817c478bd9Sstevel@tonic-gate 		if (t->t_whatstop == FLTPAGE)
13827c478bd9Sstevel@tonic-gate 			sp->pr_info.si_addr =
13837c478bd9Sstevel@tonic-gate 			    (caddr32_t)(uintptr_t)lwp->lwp_siginfo.si_addr;
13847c478bd9Sstevel@tonic-gate 	} else if (lwp->lwp_curinfo)
13857c478bd9Sstevel@tonic-gate 		siginfo_kto32(&lwp->lwp_curinfo->sq_info, &sp->pr_info);
13867c478bd9Sstevel@tonic-gate 
13877c478bd9Sstevel@tonic-gate 	if (SI_FROMUSER(&lwp->lwp_siginfo) && zp->zone_id != GLOBAL_ZONEID &&
13887c478bd9Sstevel@tonic-gate 	    sp->pr_info.si_zoneid != zp->zone_id) {
13897c478bd9Sstevel@tonic-gate 		sp->pr_info.si_pid = zp->zone_zsched->p_pid;
13907c478bd9Sstevel@tonic-gate 		sp->pr_info.si_uid = 0;
13917c478bd9Sstevel@tonic-gate 		sp->pr_info.si_ctid = -1;
13927c478bd9Sstevel@tonic-gate 		sp->pr_info.si_zoneid = zp->zone_id;
13937c478bd9Sstevel@tonic-gate 	}
13947c478bd9Sstevel@tonic-gate 
13957c478bd9Sstevel@tonic-gate 	sp->pr_cursig  = lwp->lwp_cursig;
13967c478bd9Sstevel@tonic-gate 	prassignset(&sp->pr_sigpend, &p->p_sig);
13977c478bd9Sstevel@tonic-gate 	prassignset(&sp->pr_lwppend, &t->t_sig);
13987c478bd9Sstevel@tonic-gate 	schedctl_finish_sigblock(t);
13997c478bd9Sstevel@tonic-gate 	prassignset(&sp->pr_sighold, &t->t_hold);
14007c478bd9Sstevel@tonic-gate 	sp->pr_altstack.ss_sp =
14017c478bd9Sstevel@tonic-gate 	    (caddr32_t)(uintptr_t)lwp->lwp_sigaltstack.ss_sp;
14027c478bd9Sstevel@tonic-gate 	sp->pr_altstack.ss_size = (size32_t)lwp->lwp_sigaltstack.ss_size;
14037c478bd9Sstevel@tonic-gate 	sp->pr_altstack.ss_flags = (int32_t)lwp->lwp_sigaltstack.ss_flags;
14047c478bd9Sstevel@tonic-gate 	prgetaction32(p, up, lwp->lwp_cursig, &sp->pr_action);
14057c478bd9Sstevel@tonic-gate 	sp->pr_pid   = p->p_pid;
14067c478bd9Sstevel@tonic-gate 	if (curproc->p_zone->zone_id != GLOBAL_ZONEID &&
14077c478bd9Sstevel@tonic-gate 	    (p->p_flag & SZONETOP)) {
14087c478bd9Sstevel@tonic-gate 		ASSERT(p->p_zone->zone_id != GLOBAL_ZONEID);
14097c478bd9Sstevel@tonic-gate 		/*
14107c478bd9Sstevel@tonic-gate 		 * Inside local zones, fake zsched's pid as parent pids for
14117c478bd9Sstevel@tonic-gate 		 * processes which reference processes outside of the zone.
14127c478bd9Sstevel@tonic-gate 		 */
14137c478bd9Sstevel@tonic-gate 		sp->pr_ppid = curproc->p_zone->zone_zsched->p_pid;
14147c478bd9Sstevel@tonic-gate 	} else {
14157c478bd9Sstevel@tonic-gate 		sp->pr_ppid = p->p_ppid;
14167c478bd9Sstevel@tonic-gate 	}
14177c478bd9Sstevel@tonic-gate 	sp->pr_pgrp  = p->p_pgrp;
14187c478bd9Sstevel@tonic-gate 	sp->pr_sid   = p->p_sessp->s_sid;
14197c478bd9Sstevel@tonic-gate 	hrt2ts32(mstate_aggr_state(p, LMS_USER), &sp->pr_utime);
14207c478bd9Sstevel@tonic-gate 	hrt2ts32(mstate_aggr_state(p, LMS_SYSTEM), &sp->pr_stime);
14217c478bd9Sstevel@tonic-gate 	TICK_TO_TIMESTRUC32(p->p_cutime, &sp->pr_cutime);
14227c478bd9Sstevel@tonic-gate 	TICK_TO_TIMESTRUC32(p->p_cstime, &sp->pr_cstime);
14237c478bd9Sstevel@tonic-gate 	(void) strncpy(sp->pr_clname, sclass[t->t_cid].cl_name,
142425b463cdSethindra 	    sizeof (sp->pr_clname) - 1);
14257c478bd9Sstevel@tonic-gate 	sp->pr_who = t->t_tid;
14267c478bd9Sstevel@tonic-gate 	sp->pr_nlwp = p->p_lwpcnt;
14277c478bd9Sstevel@tonic-gate 	sp->pr_brkbase = (caddr32_t)(uintptr_t)p->p_brkbase;
14287c478bd9Sstevel@tonic-gate 	sp->pr_brksize = (size32_t)p->p_brksize;
14297c478bd9Sstevel@tonic-gate 	sp->pr_stkbase = (caddr32_t)(uintptr_t)prgetstackbase(p);
14307c478bd9Sstevel@tonic-gate 	sp->pr_stksize = (size32_t)p->p_stksize;
14317c478bd9Sstevel@tonic-gate 	sp->pr_oldcontext = (caddr32_t)lwp->lwp_oldcontext;
14327c478bd9Sstevel@tonic-gate 	sp->pr_processor = t->t_cpu->cpu_id;
14337c478bd9Sstevel@tonic-gate 	sp->pr_bind = t->t_bind_cpu;
14347c478bd9Sstevel@tonic-gate 
14357c478bd9Sstevel@tonic-gate 	/*
14367c478bd9Sstevel@tonic-gate 	 * Fetch the current instruction, if not a system process.
14377c478bd9Sstevel@tonic-gate 	 * We don't attempt this unless the lwp is stopped.
14387c478bd9Sstevel@tonic-gate 	 */
14397c478bd9Sstevel@tonic-gate 	if ((p->p_flag & SSYS) || p->p_as == &kas)
14407c478bd9Sstevel@tonic-gate 		sp->pr_flags |= (PR_ISSYS|PR_PCINVAL);
14417c478bd9Sstevel@tonic-gate 	else if (!(flags & PR_STOPPED))
14427c478bd9Sstevel@tonic-gate 		sp->pr_flags |= PR_PCINVAL;
14437c478bd9Sstevel@tonic-gate 	else if (!prfetchinstr(lwp, &instr))
14447c478bd9Sstevel@tonic-gate 		sp->pr_flags |= PR_PCINVAL;
14457c478bd9Sstevel@tonic-gate 	else
14467c478bd9Sstevel@tonic-gate 		sp->pr_instr = (uint32_t)instr;
14477c478bd9Sstevel@tonic-gate 
14487c478bd9Sstevel@tonic-gate 	/*
14497c478bd9Sstevel@tonic-gate 	 * Drop p_lock while touching the lwp's stack.
14507c478bd9Sstevel@tonic-gate 	 */
14517c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
14527c478bd9Sstevel@tonic-gate 	if (prisstep(lwp))
14537c478bd9Sstevel@tonic-gate 		sp->pr_flags |= PR_STEP;
14547c478bd9Sstevel@tonic-gate 	if ((flags & (PR_STOPPED|PR_ASLEEP)) && t->t_sysnum) {
14557c478bd9Sstevel@tonic-gate 		int i;
14567c478bd9Sstevel@tonic-gate 		auxv_t *auxp;
14577c478bd9Sstevel@tonic-gate 
14587c478bd9Sstevel@tonic-gate 		sp->pr_syscall = get_syscall32_args(lwp,
145925b463cdSethindra 		    (int *)sp->pr_sysarg, &i);
14607c478bd9Sstevel@tonic-gate 		sp->pr_nsysarg = (short)i;
14618fd04b83SRoger A. Faulkner 		if (t->t_whystop == PR_SYSEXIT && t->t_sysnum == SYS_execve) {
14627c478bd9Sstevel@tonic-gate 			sp->pr_sysarg[0] = 0;
14637c478bd9Sstevel@tonic-gate 			sp->pr_sysarg[1] = (caddr32_t)up->u_argv;
14647c478bd9Sstevel@tonic-gate 			sp->pr_sysarg[2] = (caddr32_t)up->u_envp;
14657c478bd9Sstevel@tonic-gate 			for (i = 0, auxp = up->u_auxv;
14667c478bd9Sstevel@tonic-gate 			    i < sizeof (up->u_auxv) / sizeof (up->u_auxv[0]);
14677c478bd9Sstevel@tonic-gate 			    i++, auxp++) {
14687c478bd9Sstevel@tonic-gate 				if (auxp->a_type == AT_SUN_EXECNAME) {
14697c478bd9Sstevel@tonic-gate 					sp->pr_sysarg[0] =
147025b463cdSethindra 					    (caddr32_t)
147125b463cdSethindra 					    (uintptr_t)auxp->a_un.a_ptr;
14727c478bd9Sstevel@tonic-gate 					break;
14737c478bd9Sstevel@tonic-gate 				}
14747c478bd9Sstevel@tonic-gate 			}
14757c478bd9Sstevel@tonic-gate 		}
14767c478bd9Sstevel@tonic-gate 	}
14777c478bd9Sstevel@tonic-gate 	if ((flags & PR_STOPPED) || t == curthread)
14787c478bd9Sstevel@tonic-gate 		prgetprregs32(lwp, sp->pr_reg);
14797c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
14807c478bd9Sstevel@tonic-gate }
14817c478bd9Sstevel@tonic-gate 
14827c478bd9Sstevel@tonic-gate void
14837c478bd9Sstevel@tonic-gate oprgetpsinfo32(proc_t *p, prpsinfo32_t *psp, kthread_t *tp)
14847c478bd9Sstevel@tonic-gate {
14857c478bd9Sstevel@tonic-gate 	kthread_t *t;
14867c478bd9Sstevel@tonic-gate 	char c, state;
14877c478bd9Sstevel@tonic-gate 	user_t *up;
14887c478bd9Sstevel@tonic-gate 	dev_t d;
14897c478bd9Sstevel@tonic-gate 	uint64_t pct;
14907c478bd9Sstevel@tonic-gate 	int retval, niceval;
14917c478bd9Sstevel@tonic-gate 	cred_t *cred;
14927c478bd9Sstevel@tonic-gate 	struct as *as;
14937c478bd9Sstevel@tonic-gate 	hrtime_t hrutime, hrstime, cur_time;
14947c478bd9Sstevel@tonic-gate 
14957c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
14967c478bd9Sstevel@tonic-gate 
14977c478bd9Sstevel@tonic-gate 	bzero(psp, sizeof (*psp));
14987c478bd9Sstevel@tonic-gate 
14997c478bd9Sstevel@tonic-gate 	if ((t = tp) == NULL)
15007c478bd9Sstevel@tonic-gate 		t = prchoose(p);	/* returns locked thread */
15017c478bd9Sstevel@tonic-gate 	else
15027c478bd9Sstevel@tonic-gate 		thread_lock(t);
15037c478bd9Sstevel@tonic-gate 
15047c478bd9Sstevel@tonic-gate 	/* kludge: map thread state enum into process state enum */
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 	if (t == NULL) {
15077c478bd9Sstevel@tonic-gate 		state = TS_ZOMB;
15087c478bd9Sstevel@tonic-gate 	} else {
15097c478bd9Sstevel@tonic-gate 		state = VSTOPPED(t) ? TS_STOPPED : t->t_state;
15107c478bd9Sstevel@tonic-gate 		thread_unlock(t);
15117c478bd9Sstevel@tonic-gate 	}
15127c478bd9Sstevel@tonic-gate 
15137c478bd9Sstevel@tonic-gate 	switch (state) {
15147c478bd9Sstevel@tonic-gate 	case TS_SLEEP:		state = SSLEEP;		break;
15157c478bd9Sstevel@tonic-gate 	case TS_RUN:		state = SRUN;		break;
15167c478bd9Sstevel@tonic-gate 	case TS_ONPROC:		state = SONPROC;	break;
15177c478bd9Sstevel@tonic-gate 	case TS_ZOMB:		state = SZOMB;		break;
15187c478bd9Sstevel@tonic-gate 	case TS_STOPPED:	state = SSTOP;		break;
15197c478bd9Sstevel@tonic-gate 	default:		state = 0;		break;
15207c478bd9Sstevel@tonic-gate 	}
15217c478bd9Sstevel@tonic-gate 	switch (state) {
15227c478bd9Sstevel@tonic-gate 	case SSLEEP:	c = 'S';	break;
15237c478bd9Sstevel@tonic-gate 	case SRUN:	c = 'R';	break;
15247c478bd9Sstevel@tonic-gate 	case SZOMB:	c = 'Z';	break;
15257c478bd9Sstevel@tonic-gate 	case SSTOP:	c = 'T';	break;
15267c478bd9Sstevel@tonic-gate 	case SIDL:	c = 'I';	break;
15277c478bd9Sstevel@tonic-gate 	case SONPROC:	c = 'O';	break;
15287c478bd9Sstevel@tonic-gate #ifdef SXBRK
15297c478bd9Sstevel@tonic-gate 	case SXBRK:	c = 'X';	break;
15307c478bd9Sstevel@tonic-gate #endif
15317c478bd9Sstevel@tonic-gate 	default:	c = '?';	break;
15327c478bd9Sstevel@tonic-gate 	}
15337c478bd9Sstevel@tonic-gate 	psp->pr_state = state;
15347c478bd9Sstevel@tonic-gate 	psp->pr_sname = c;
15357c478bd9Sstevel@tonic-gate 	psp->pr_zomb = (state == SZOMB);
15367c478bd9Sstevel@tonic-gate 	/*
15377c478bd9Sstevel@tonic-gate 	 * only export SSYS and SMSACCT; everything else is off-limits to
15387c478bd9Sstevel@tonic-gate 	 * userland apps.
15397c478bd9Sstevel@tonic-gate 	 */
15407c478bd9Sstevel@tonic-gate 	psp->pr_flag = p->p_flag & (SSYS | SMSACCT);
15417c478bd9Sstevel@tonic-gate 
15427c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_crlock);
15437c478bd9Sstevel@tonic-gate 	cred = p->p_cred;
15447c478bd9Sstevel@tonic-gate 	psp->pr_uid = crgetruid(cred);
15457c478bd9Sstevel@tonic-gate 	psp->pr_gid = crgetrgid(cred);
15467c478bd9Sstevel@tonic-gate 	psp->pr_euid = crgetuid(cred);
15477c478bd9Sstevel@tonic-gate 	psp->pr_egid = crgetgid(cred);
15487c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_crlock);
15497c478bd9Sstevel@tonic-gate 
15507c478bd9Sstevel@tonic-gate 	psp->pr_pid = p->p_pid;
15517c478bd9Sstevel@tonic-gate 	if (curproc->p_zone->zone_id != GLOBAL_ZONEID &&
15527c478bd9Sstevel@tonic-gate 	    (p->p_flag & SZONETOP)) {
15537c478bd9Sstevel@tonic-gate 		ASSERT(p->p_zone->zone_id != GLOBAL_ZONEID);
15547c478bd9Sstevel@tonic-gate 		/*
15557c478bd9Sstevel@tonic-gate 		 * Inside local zones, fake zsched's pid as parent pids for
15567c478bd9Sstevel@tonic-gate 		 * processes which reference processes outside of the zone.
15577c478bd9Sstevel@tonic-gate 		 */
15587c478bd9Sstevel@tonic-gate 		psp->pr_ppid = curproc->p_zone->zone_zsched->p_pid;
15597c478bd9Sstevel@tonic-gate 	} else {
15607c478bd9Sstevel@tonic-gate 		psp->pr_ppid = p->p_ppid;
15617c478bd9Sstevel@tonic-gate 	}
15627c478bd9Sstevel@tonic-gate 	psp->pr_pgrp = p->p_pgrp;
15637c478bd9Sstevel@tonic-gate 	psp->pr_sid = p->p_sessp->s_sid;
15647c478bd9Sstevel@tonic-gate 	psp->pr_addr = 0;	/* cannot represent 64-bit addr in 32 bits */
15657c478bd9Sstevel@tonic-gate 	hrutime = mstate_aggr_state(p, LMS_USER);
15667c478bd9Sstevel@tonic-gate 	hrstime = mstate_aggr_state(p, LMS_SYSTEM);
15677c478bd9Sstevel@tonic-gate 	hrt2ts32(hrutime + hrstime, &psp->pr_time);
15687c478bd9Sstevel@tonic-gate 	TICK_TO_TIMESTRUC32(p->p_cutime + p->p_cstime, &psp->pr_ctime);
15697c478bd9Sstevel@tonic-gate 	switch (p->p_model) {
15707c478bd9Sstevel@tonic-gate 	case DATAMODEL_ILP32:
15717c478bd9Sstevel@tonic-gate 		psp->pr_dmodel = PR_MODEL_ILP32;
15727c478bd9Sstevel@tonic-gate 		break;
15737c478bd9Sstevel@tonic-gate 	case DATAMODEL_LP64:
15747c478bd9Sstevel@tonic-gate 		psp->pr_dmodel = PR_MODEL_LP64;
15757c478bd9Sstevel@tonic-gate 		break;
15767c478bd9Sstevel@tonic-gate 	}
15777c478bd9Sstevel@tonic-gate 	if (state == SZOMB || t == NULL) {
15787c478bd9Sstevel@tonic-gate 		int wcode = p->p_wcode;		/* must be atomic read */
15797c478bd9Sstevel@tonic-gate 
15807c478bd9Sstevel@tonic-gate 		if (wcode)
15817c478bd9Sstevel@tonic-gate 			psp->pr_wstat = wstat(wcode, p->p_wdata);
15827c478bd9Sstevel@tonic-gate 		psp->pr_lttydev = PRNODEV32;
15837c478bd9Sstevel@tonic-gate 		psp->pr_ottydev = (o_dev_t)PRNODEV32;
15847c478bd9Sstevel@tonic-gate 		psp->pr_size = 0;
15857c478bd9Sstevel@tonic-gate 		psp->pr_rssize = 0;
15867c478bd9Sstevel@tonic-gate 		psp->pr_pctmem = 0;
15877c478bd9Sstevel@tonic-gate 	} else {
15887c478bd9Sstevel@tonic-gate 		up = PTOU(p);
15897c478bd9Sstevel@tonic-gate 		psp->pr_wchan = 0;	/* cannot represent in 32 bits */
15907c478bd9Sstevel@tonic-gate 		psp->pr_pri = t->t_pri;
15917c478bd9Sstevel@tonic-gate 		(void) strncpy(psp->pr_clname, sclass[t->t_cid].cl_name,
159225b463cdSethindra 		    sizeof (psp->pr_clname) - 1);
15937c478bd9Sstevel@tonic-gate 		retval = CL_DONICE(t, NULL, 0, &niceval);
15947c478bd9Sstevel@tonic-gate 		if (retval == 0) {
15957c478bd9Sstevel@tonic-gate 			psp->pr_oldpri = v.v_maxsyspri - psp->pr_pri;
15967c478bd9Sstevel@tonic-gate 			psp->pr_nice = niceval + NZERO;
15977c478bd9Sstevel@tonic-gate 		} else {
15987c478bd9Sstevel@tonic-gate 			psp->pr_oldpri = 0;
15997c478bd9Sstevel@tonic-gate 			psp->pr_nice = 0;
16007c478bd9Sstevel@tonic-gate 		}
16017c478bd9Sstevel@tonic-gate 		d = cttydev(p);
16027c478bd9Sstevel@tonic-gate #ifdef sun
16037c478bd9Sstevel@tonic-gate 		{
16047c478bd9Sstevel@tonic-gate 			extern dev_t rwsconsdev, rconsdev, uconsdev;
16057c478bd9Sstevel@tonic-gate 			/*
16067c478bd9Sstevel@tonic-gate 			 * If the controlling terminal is the real
16077c478bd9Sstevel@tonic-gate 			 * or workstation console device, map to what the
160825b463cdSethindra 			 * user thinks is the console device. Handle case when
160925b463cdSethindra 			 * rwsconsdev or rconsdev is set to NODEV for Starfire.
16107c478bd9Sstevel@tonic-gate 			 */
161125b463cdSethindra 			if ((d == rwsconsdev || d == rconsdev) && d != NODEV)
16127c478bd9Sstevel@tonic-gate 				d = uconsdev;
16137c478bd9Sstevel@tonic-gate 		}
16147c478bd9Sstevel@tonic-gate #endif
16157c478bd9Sstevel@tonic-gate 		(void) cmpldev(&psp->pr_lttydev, d);
16167c478bd9Sstevel@tonic-gate 		psp->pr_ottydev = cmpdev(d);
16177c478bd9Sstevel@tonic-gate 		TIMESPEC_TO_TIMESPEC32(&psp->pr_start, &up->u_start);
16187c478bd9Sstevel@tonic-gate 		bcopy(up->u_comm, psp->pr_fname,
16197c478bd9Sstevel@tonic-gate 		    MIN(sizeof (up->u_comm), sizeof (psp->pr_fname)-1));
16207c478bd9Sstevel@tonic-gate 		bcopy(up->u_psargs, psp->pr_psargs,
16217c478bd9Sstevel@tonic-gate 		    MIN(PRARGSZ-1, PSARGSZ));
16227c478bd9Sstevel@tonic-gate 		psp->pr_syscall = t->t_sysnum;
16237c478bd9Sstevel@tonic-gate 		psp->pr_argc = up->u_argc;
16247c478bd9Sstevel@tonic-gate 		psp->pr_argv = (caddr32_t)up->u_argv;
16257c478bd9Sstevel@tonic-gate 		psp->pr_envp = (caddr32_t)up->u_envp;
16267c478bd9Sstevel@tonic-gate 
16277c478bd9Sstevel@tonic-gate 		/* compute %cpu for the lwp or process */
16287c478bd9Sstevel@tonic-gate 		pct = 0;
16297c478bd9Sstevel@tonic-gate 		if ((t = tp) == NULL)
16307c478bd9Sstevel@tonic-gate 			t = p->p_tlist;
16317c478bd9Sstevel@tonic-gate 		cur_time = gethrtime_unscaled();
16327c478bd9Sstevel@tonic-gate 		do {
16337c478bd9Sstevel@tonic-gate 			pct += cpu_update_pct(t, cur_time);
16347c478bd9Sstevel@tonic-gate 			if (tp != NULL)		/* just do the one lwp */
16357c478bd9Sstevel@tonic-gate 				break;
16367c478bd9Sstevel@tonic-gate 		} while ((t = t->t_forw) != p->p_tlist);
16377c478bd9Sstevel@tonic-gate 
16387c478bd9Sstevel@tonic-gate 		psp->pr_pctcpu = prgetpctcpu(pct);
16397c478bd9Sstevel@tonic-gate 		psp->pr_cpu = (psp->pr_pctcpu*100 + 0x6000) >> 15; /* [0..99] */
16407c478bd9Sstevel@tonic-gate 		if (psp->pr_cpu > 99)
16417c478bd9Sstevel@tonic-gate 			psp->pr_cpu = 99;
16427c478bd9Sstevel@tonic-gate 
16437c478bd9Sstevel@tonic-gate 		if ((p->p_flag & SSYS) || (as = p->p_as) == &kas) {
16447c478bd9Sstevel@tonic-gate 			psp->pr_size = 0;
16457c478bd9Sstevel@tonic-gate 			psp->pr_rssize = 0;
16467c478bd9Sstevel@tonic-gate 			psp->pr_pctmem = 0;
16477c478bd9Sstevel@tonic-gate 		} else {
16487c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
1649dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_ENTER(as, RW_READER);
165040688216SSudheer A 			psp->pr_size = (size32_t)btopr(as->a_resvsize);
16517c478bd9Sstevel@tonic-gate 			psp->pr_rssize = (size32_t)rm_asrss(as);
16527c478bd9Sstevel@tonic-gate 			psp->pr_pctmem = rm_pctmemory(as);
1653dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_EXIT(as);
16547c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
16557c478bd9Sstevel@tonic-gate 		}
16567c478bd9Sstevel@tonic-gate 	}
16577c478bd9Sstevel@tonic-gate 	psp->pr_bysize = (size32_t)ptob(psp->pr_size);
16587c478bd9Sstevel@tonic-gate 	psp->pr_byrssize = (size32_t)ptob(psp->pr_rssize);
16597c478bd9Sstevel@tonic-gate 
16607c478bd9Sstevel@tonic-gate 	/*
16617c478bd9Sstevel@tonic-gate 	 * If we are looking at an LP64 process, zero out
16627c478bd9Sstevel@tonic-gate 	 * the fields that cannot be represented in ILP32.
16637c478bd9Sstevel@tonic-gate 	 */
16647c478bd9Sstevel@tonic-gate 	if (p->p_model != DATAMODEL_ILP32) {
16657c478bd9Sstevel@tonic-gate 		psp->pr_size = 0;
16667c478bd9Sstevel@tonic-gate 		psp->pr_rssize = 0;
16677c478bd9Sstevel@tonic-gate 		psp->pr_bysize = 0;
16687c478bd9Sstevel@tonic-gate 		psp->pr_byrssize = 0;
16697c478bd9Sstevel@tonic-gate 		psp->pr_argv = 0;
16707c478bd9Sstevel@tonic-gate 		psp->pr_envp = 0;
16717c478bd9Sstevel@tonic-gate 	}
16727c478bd9Sstevel@tonic-gate }
16737c478bd9Sstevel@tonic-gate 
1674da6c28aaSamw /*ARGSUSED*/
16757c478bd9Sstevel@tonic-gate static int
1676da6c28aaSamw prioctl32(
1677da6c28aaSamw 	struct vnode *vp,
1678da6c28aaSamw 	int cmd,
1679da6c28aaSamw 	intptr_t arg,
1680da6c28aaSamw 	int flag,
1681da6c28aaSamw 	cred_t *cr,
1682da6c28aaSamw 	int *rvalp,
1683da6c28aaSamw 	caller_context_t *ct)
16847c478bd9Sstevel@tonic-gate {
1685eb9dbf0cSRoger A. Faulkner 	int nsig = PROC_IS_BRANDED(curproc)? BROP(curproc)->b_nsig : NSIG;
16867c478bd9Sstevel@tonic-gate 	caddr_t cmaddr = (caddr_t)arg;
16877c478bd9Sstevel@tonic-gate 	proc_t *p;
16887c478bd9Sstevel@tonic-gate 	user_t *up;
16897c478bd9Sstevel@tonic-gate 	kthread_t *t;
16907c478bd9Sstevel@tonic-gate 	klwp_t *lwp;
16917c478bd9Sstevel@tonic-gate 	prnode_t *pnp = VTOP(vp);
16927c478bd9Sstevel@tonic-gate 	prcommon_t *pcp;
16937c478bd9Sstevel@tonic-gate 	prnode_t *xpnp = NULL;
16947c478bd9Sstevel@tonic-gate 	int error;
16957c478bd9Sstevel@tonic-gate 	int zdisp;
16967c478bd9Sstevel@tonic-gate 	void *thing = NULL;
16977c478bd9Sstevel@tonic-gate 	size_t thingsize = 0;
16987c478bd9Sstevel@tonic-gate 
16997c478bd9Sstevel@tonic-gate 	/*
17007c478bd9Sstevel@tonic-gate 	 * For copyin()/copyout().
17017c478bd9Sstevel@tonic-gate 	 */
17027c478bd9Sstevel@tonic-gate 	union {
17037c478bd9Sstevel@tonic-gate 		caddr32_t	va;
17047c478bd9Sstevel@tonic-gate 		int		signo;
17057c478bd9Sstevel@tonic-gate 		int		nice;
17067c478bd9Sstevel@tonic-gate 		uint_t		lwpid;
17077c478bd9Sstevel@tonic-gate 		int32_t		flags;
17087c478bd9Sstevel@tonic-gate 		prstatus32_t	prstat;
17097c478bd9Sstevel@tonic-gate 		prrun32_t	prrun;
17107c478bd9Sstevel@tonic-gate 		sigset_t	smask;
17117c478bd9Sstevel@tonic-gate 		siginfo32_t	info;
17127c478bd9Sstevel@tonic-gate 		sysset_t	prmask;
17137c478bd9Sstevel@tonic-gate 		prgregset32_t	regs;
17147c478bd9Sstevel@tonic-gate 		prfpregset32_t	fpregs;
17157c478bd9Sstevel@tonic-gate 		prpsinfo32_t	prps;
17167c478bd9Sstevel@tonic-gate 		sigset_t	holdmask;
17177c478bd9Sstevel@tonic-gate 		fltset_t	fltmask;
17187c478bd9Sstevel@tonic-gate 		prcred_t	prcred;
17197c478bd9Sstevel@tonic-gate 		prusage32_t	prusage;
17207c478bd9Sstevel@tonic-gate 		prhusage_t	prhusage;
17217c478bd9Sstevel@tonic-gate 		ioc_prmap32_t	prmap;
17227c478bd9Sstevel@tonic-gate 		auxv32_t	auxv[__KERN_NAUXV_IMPL];
17237c478bd9Sstevel@tonic-gate 	} un32;
17247c478bd9Sstevel@tonic-gate 
17257c478bd9Sstevel@tonic-gate 	/*
17267c478bd9Sstevel@tonic-gate 	 * Native objects for internal use.
17277c478bd9Sstevel@tonic-gate 	 */
17287c478bd9Sstevel@tonic-gate 	union {
17297c478bd9Sstevel@tonic-gate 		caddr_t		va;
17307c478bd9Sstevel@tonic-gate 		int		signo;
17317c478bd9Sstevel@tonic-gate 		int		nice;
17327c478bd9Sstevel@tonic-gate 		uint_t		lwpid;
17337c478bd9Sstevel@tonic-gate 		long		flags;
17347c478bd9Sstevel@tonic-gate 		prstatus_t	prstat;
17357c478bd9Sstevel@tonic-gate 		prrun_t		prrun;
17367c478bd9Sstevel@tonic-gate 		sigset_t	smask;
17377c478bd9Sstevel@tonic-gate 		siginfo_t	info;
17387c478bd9Sstevel@tonic-gate 		sysset_t	prmask;
17397c478bd9Sstevel@tonic-gate 		prgregset_t	regs;
17407c478bd9Sstevel@tonic-gate 		prpsinfo_t	prps;
17417c478bd9Sstevel@tonic-gate 		sigset_t	holdmask;
17427c478bd9Sstevel@tonic-gate 		fltset_t	fltmask;
17437c478bd9Sstevel@tonic-gate 		prcred_t	prcred;
17447c478bd9Sstevel@tonic-gate 		prusage_t	prusage;
17457c478bd9Sstevel@tonic-gate 		prhusage_t	prhusage;
17467c478bd9Sstevel@tonic-gate 		auxv_t		auxv[__KERN_NAUXV_IMPL];
17477c478bd9Sstevel@tonic-gate 	} un;
17487c478bd9Sstevel@tonic-gate 
17497c478bd9Sstevel@tonic-gate 	if (pnp->pr_type == PR_TMPL)
17507c478bd9Sstevel@tonic-gate 		return (prctioctl(pnp, cmd, arg, flag, cr));
17517c478bd9Sstevel@tonic-gate 
17527c478bd9Sstevel@tonic-gate 	/*
17537c478bd9Sstevel@tonic-gate 	 * Support for old /proc interface.
17547c478bd9Sstevel@tonic-gate 	 */
17557c478bd9Sstevel@tonic-gate 	if (pnp->pr_pidfile != NULL) {
17567c478bd9Sstevel@tonic-gate 		ASSERT(pnp->pr_type == PR_PIDDIR);
17577c478bd9Sstevel@tonic-gate 		vp = pnp->pr_pidfile;
17587c478bd9Sstevel@tonic-gate 		pnp = VTOP(vp);
17597c478bd9Sstevel@tonic-gate 		ASSERT(pnp->pr_type == PR_PIDFILE);
17607c478bd9Sstevel@tonic-gate 	}
17617c478bd9Sstevel@tonic-gate 
17627c478bd9Sstevel@tonic-gate 	if (pnp->pr_type != PR_PIDFILE && pnp->pr_type != PR_LWPIDFILE)
17637c478bd9Sstevel@tonic-gate 		return (ENOTTY);
17647c478bd9Sstevel@tonic-gate 
17657c478bd9Sstevel@tonic-gate 	/*
17667c478bd9Sstevel@tonic-gate 	 * Fail ioctls which are logically "write" requests unless
17677c478bd9Sstevel@tonic-gate 	 * the user has write permission.
17687c478bd9Sstevel@tonic-gate 	 */
17697c478bd9Sstevel@tonic-gate 	if ((flag & FWRITE) == 0 && isprwrioctl(cmd))
17707c478bd9Sstevel@tonic-gate 		return (EBADF);
17717c478bd9Sstevel@tonic-gate 
17727c478bd9Sstevel@tonic-gate 	/*
17737c478bd9Sstevel@tonic-gate 	 * Perform any necessary copyin() operations before
17747c478bd9Sstevel@tonic-gate 	 * locking the process.  Helps avoid deadlocks and
17757c478bd9Sstevel@tonic-gate 	 * improves performance.
17767c478bd9Sstevel@tonic-gate 	 *
17777c478bd9Sstevel@tonic-gate 	 * Also, detect invalid ioctl codes here to avoid
17787c478bd9Sstevel@tonic-gate 	 * locking a process unnnecessarily.
17797c478bd9Sstevel@tonic-gate 	 *
17807c478bd9Sstevel@tonic-gate 	 * Also, prepare to allocate space that will be needed below,
17817c478bd9Sstevel@tonic-gate 	 * case by case.
17827c478bd9Sstevel@tonic-gate 	 */
17837c478bd9Sstevel@tonic-gate 	error = 0;
17847c478bd9Sstevel@tonic-gate 	switch (cmd) {
17857c478bd9Sstevel@tonic-gate 	case PIOCGETPR:
17867c478bd9Sstevel@tonic-gate 		thingsize = sizeof (proc_t);
17877c478bd9Sstevel@tonic-gate 		break;
17887c478bd9Sstevel@tonic-gate 	case PIOCGETU:
17897c478bd9Sstevel@tonic-gate 		thingsize = sizeof (user_t);
17907c478bd9Sstevel@tonic-gate 		break;
17917c478bd9Sstevel@tonic-gate 	case PIOCSTOP:
17927c478bd9Sstevel@tonic-gate 	case PIOCWSTOP:
17937c478bd9Sstevel@tonic-gate 	case PIOCLWPIDS:
17947c478bd9Sstevel@tonic-gate 	case PIOCGTRACE:
17957c478bd9Sstevel@tonic-gate 	case PIOCGENTRY:
17967c478bd9Sstevel@tonic-gate 	case PIOCGEXIT:
17977c478bd9Sstevel@tonic-gate 	case PIOCSRLC:
17987c478bd9Sstevel@tonic-gate 	case PIOCRRLC:
17997c478bd9Sstevel@tonic-gate 	case PIOCSFORK:
18007c478bd9Sstevel@tonic-gate 	case PIOCRFORK:
18017c478bd9Sstevel@tonic-gate 	case PIOCGREG:
18027c478bd9Sstevel@tonic-gate 	case PIOCGFPREG:
18037c478bd9Sstevel@tonic-gate 	case PIOCSTATUS:
18047c478bd9Sstevel@tonic-gate 	case PIOCLSTATUS:
18057c478bd9Sstevel@tonic-gate 	case PIOCPSINFO:
18067c478bd9Sstevel@tonic-gate 	case PIOCMAXSIG:
18077c478bd9Sstevel@tonic-gate 	case PIOCGXREGSIZE:
18087c478bd9Sstevel@tonic-gate 		break;
18097c478bd9Sstevel@tonic-gate 	case PIOCSXREG:		/* set extra registers */
18107c478bd9Sstevel@tonic-gate 	case PIOCGXREG:		/* get extra registers */
18117c478bd9Sstevel@tonic-gate #if defined(__sparc)
18127c478bd9Sstevel@tonic-gate 		thingsize = sizeof (prxregset_t);
18137c478bd9Sstevel@tonic-gate #else
18147c478bd9Sstevel@tonic-gate 		thingsize = 0;
18157c478bd9Sstevel@tonic-gate #endif
18167c478bd9Sstevel@tonic-gate 		break;
18177c478bd9Sstevel@tonic-gate 	case PIOCACTION:
1818eb9dbf0cSRoger A. Faulkner 		thingsize = (nsig-1) * sizeof (struct sigaction32);
18197c478bd9Sstevel@tonic-gate 		break;
18207c478bd9Sstevel@tonic-gate 	case PIOCGHOLD:
18217c478bd9Sstevel@tonic-gate 	case PIOCNMAP:
18227c478bd9Sstevel@tonic-gate 	case PIOCMAP:
18237c478bd9Sstevel@tonic-gate 	case PIOCGFAULT:
18247c478bd9Sstevel@tonic-gate 	case PIOCCFAULT:
18257c478bd9Sstevel@tonic-gate 	case PIOCCRED:
18267c478bd9Sstevel@tonic-gate 	case PIOCGROUPS:
18277c478bd9Sstevel@tonic-gate 	case PIOCUSAGE:
18287c478bd9Sstevel@tonic-gate 	case PIOCLUSAGE:
18297c478bd9Sstevel@tonic-gate 		break;
18307c478bd9Sstevel@tonic-gate 	case PIOCOPENPD:
18317c478bd9Sstevel@tonic-gate 		/*
18327c478bd9Sstevel@tonic-gate 		 * We will need this below.
18337c478bd9Sstevel@tonic-gate 		 * Allocate it now, before locking the process.
18347c478bd9Sstevel@tonic-gate 		 */
18357c478bd9Sstevel@tonic-gate 		xpnp = prgetnode(vp, PR_OPAGEDATA);
18367c478bd9Sstevel@tonic-gate 		break;
18377c478bd9Sstevel@tonic-gate 	case PIOCNAUXV:
18387c478bd9Sstevel@tonic-gate 	case PIOCAUXV:
18397c478bd9Sstevel@tonic-gate 		break;
18407c478bd9Sstevel@tonic-gate 
18417c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__i386_COMPAT)
18427c478bd9Sstevel@tonic-gate 	case PIOCNLDT:
18437c478bd9Sstevel@tonic-gate 	case PIOCLDT:
18447c478bd9Sstevel@tonic-gate 		break;
18457c478bd9Sstevel@tonic-gate #endif	/* __i386 || __i386_COMPAT */
18467c478bd9Sstevel@tonic-gate 
18477c478bd9Sstevel@tonic-gate #if defined(__sparc)
18487c478bd9Sstevel@tonic-gate 	case PIOCGWIN:
18497c478bd9Sstevel@tonic-gate 		thingsize = sizeof (gwindows32_t);
18507c478bd9Sstevel@tonic-gate 		break;
18517c478bd9Sstevel@tonic-gate #endif	/* __sparc */
18527c478bd9Sstevel@tonic-gate 
18537c478bd9Sstevel@tonic-gate 	case PIOCOPENM:		/* open mapped object for reading */
18547c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
1855*e14d4b22SToomas Soome 			un32.va = (caddr32_t)(uintptr_t)NULL;
18567c478bd9Sstevel@tonic-gate 		else if (copyin(cmaddr, &un32.va, sizeof (un32.va)))
18577c478bd9Sstevel@tonic-gate 			error = EFAULT;
18587c478bd9Sstevel@tonic-gate 		break;
18597c478bd9Sstevel@tonic-gate 
18607c478bd9Sstevel@tonic-gate 	case PIOCRUN:		/* make lwp or process runnable */
18617c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
18627c478bd9Sstevel@tonic-gate 			un32.prrun.pr_flags = 0;
18637c478bd9Sstevel@tonic-gate 		else if (copyin(cmaddr, &un32.prrun, sizeof (un32.prrun)))
18647c478bd9Sstevel@tonic-gate 			error = EFAULT;
18657c478bd9Sstevel@tonic-gate 		break;
18667c478bd9Sstevel@tonic-gate 
18677c478bd9Sstevel@tonic-gate 	case PIOCOPENLWP:	/* return /proc lwp file descriptor */
18687c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.lwpid, sizeof (un32.lwpid)))
18697c478bd9Sstevel@tonic-gate 			error = EFAULT;
18707c478bd9Sstevel@tonic-gate 		break;
18717c478bd9Sstevel@tonic-gate 
18727c478bd9Sstevel@tonic-gate 	case PIOCSTRACE:	/* set signal trace mask */
18737c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.smask, sizeof (un32.smask)))
18747c478bd9Sstevel@tonic-gate 			error = EFAULT;
18757c478bd9Sstevel@tonic-gate 		break;
18767c478bd9Sstevel@tonic-gate 
18777c478bd9Sstevel@tonic-gate 	case PIOCSSIG:		/* set current signal */
18787c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
18797c478bd9Sstevel@tonic-gate 			un32.info.si_signo = 0;
18807c478bd9Sstevel@tonic-gate 		else if (copyin(cmaddr, &un32.info, sizeof (un32.info)))
18817c478bd9Sstevel@tonic-gate 			error = EFAULT;
18827c478bd9Sstevel@tonic-gate 		break;
18837c478bd9Sstevel@tonic-gate 
18847c478bd9Sstevel@tonic-gate 	case PIOCKILL:		/* send signal */
18857c478bd9Sstevel@tonic-gate 	case PIOCUNKILL:	/* delete a signal */
18867c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.signo, sizeof (un32.signo)))
18877c478bd9Sstevel@tonic-gate 			error = EFAULT;
18887c478bd9Sstevel@tonic-gate 		break;
18897c478bd9Sstevel@tonic-gate 
18907c478bd9Sstevel@tonic-gate 	case PIOCNICE:		/* set nice priority */
18917c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.nice, sizeof (un32.nice)))
18927c478bd9Sstevel@tonic-gate 			error = EFAULT;
18937c478bd9Sstevel@tonic-gate 		break;
18947c478bd9Sstevel@tonic-gate 
18957c478bd9Sstevel@tonic-gate 	case PIOCSENTRY:	/* set syscall entry bit mask */
18967c478bd9Sstevel@tonic-gate 	case PIOCSEXIT:		/* set syscall exit bit mask */
18977c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.prmask, sizeof (un32.prmask)))
18987c478bd9Sstevel@tonic-gate 			error = EFAULT;
18997c478bd9Sstevel@tonic-gate 		break;
19007c478bd9Sstevel@tonic-gate 
19017c478bd9Sstevel@tonic-gate 	case PIOCSET:		/* set process flags */
19027c478bd9Sstevel@tonic-gate 	case PIOCRESET:		/* reset process flags */
19037c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.flags, sizeof (un32.flags)))
19047c478bd9Sstevel@tonic-gate 			error = EFAULT;
19057c478bd9Sstevel@tonic-gate 		break;
19067c478bd9Sstevel@tonic-gate 
19077c478bd9Sstevel@tonic-gate 	case PIOCSREG:		/* set general registers */
19087c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, un32.regs, sizeof (un32.regs)))
19097c478bd9Sstevel@tonic-gate 			error = EFAULT;
19107c478bd9Sstevel@tonic-gate 		break;
19117c478bd9Sstevel@tonic-gate 
19127c478bd9Sstevel@tonic-gate 	case PIOCSFPREG:	/* set floating-point registers */
19137c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.fpregs, sizeof (un32.fpregs)))
19147c478bd9Sstevel@tonic-gate 			error = EFAULT;
19157c478bd9Sstevel@tonic-gate 		break;
19167c478bd9Sstevel@tonic-gate 
19177c478bd9Sstevel@tonic-gate 	case PIOCSHOLD:		/* set signal-hold mask */
19187c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.holdmask, sizeof (un32.holdmask)))
19197c478bd9Sstevel@tonic-gate 			error = EFAULT;
19207c478bd9Sstevel@tonic-gate 		break;
19217c478bd9Sstevel@tonic-gate 
19227c478bd9Sstevel@tonic-gate 	case PIOCSFAULT:	/* set mask of traced faults */
19237c478bd9Sstevel@tonic-gate 		if (copyin(cmaddr, &un32.fltmask, sizeof (un32.fltmask)))
19247c478bd9Sstevel@tonic-gate 			error = EFAULT;
19257c478bd9Sstevel@tonic-gate 		break;
19267c478bd9Sstevel@tonic-gate 
19277c478bd9Sstevel@tonic-gate 	default:
19287c478bd9Sstevel@tonic-gate 		error = EINVAL;
19297c478bd9Sstevel@tonic-gate 		break;
19307c478bd9Sstevel@tonic-gate 	}
19317c478bd9Sstevel@tonic-gate 
19327c478bd9Sstevel@tonic-gate 	if (error)
19337c478bd9Sstevel@tonic-gate 		return (error);
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate startover:
19367c478bd9Sstevel@tonic-gate 	/*
19377c478bd9Sstevel@tonic-gate 	 * If we need kmem_alloc()d space then we allocate it now, before
19387c478bd9Sstevel@tonic-gate 	 * grabbing the process lock.  Using kmem_alloc(KM_SLEEP) while
19397c478bd9Sstevel@tonic-gate 	 * holding the process lock leads to deadlock with the clock thread.
19407c478bd9Sstevel@tonic-gate 	 * (The clock thread wakes up the pageout daemon to free up space.
19417c478bd9Sstevel@tonic-gate 	 * If the clock thread blocks behind us and we are sleeping waiting
19427c478bd9Sstevel@tonic-gate 	 * for space, then space may never become available.)
19437c478bd9Sstevel@tonic-gate 	 */
19447c478bd9Sstevel@tonic-gate 	if (thingsize) {
19457c478bd9Sstevel@tonic-gate 		ASSERT(thing == NULL);
19467c478bd9Sstevel@tonic-gate 		thing = kmem_alloc(thingsize, KM_SLEEP);
19477c478bd9Sstevel@tonic-gate 	}
19487c478bd9Sstevel@tonic-gate 
19497c478bd9Sstevel@tonic-gate 	switch (cmd) {
19507c478bd9Sstevel@tonic-gate 	case PIOCPSINFO:
19517c478bd9Sstevel@tonic-gate 	case PIOCGETPR:
19527c478bd9Sstevel@tonic-gate 	case PIOCUSAGE:
19537c478bd9Sstevel@tonic-gate 	case PIOCLUSAGE:
19547c478bd9Sstevel@tonic-gate 		zdisp = ZYES;
19557c478bd9Sstevel@tonic-gate 		break;
19567c478bd9Sstevel@tonic-gate 	case PIOCSXREG:		/* set extra registers */
19577c478bd9Sstevel@tonic-gate 		/*
19587c478bd9Sstevel@tonic-gate 		 * perform copyin before grabbing the process lock
19597c478bd9Sstevel@tonic-gate 		 */
19607c478bd9Sstevel@tonic-gate 		if (thing) {
19617c478bd9Sstevel@tonic-gate 			if (copyin(cmaddr, thing, thingsize)) {
19627c478bd9Sstevel@tonic-gate 				kmem_free(thing, thingsize);
19637c478bd9Sstevel@tonic-gate 				return (EFAULT);
19647c478bd9Sstevel@tonic-gate 			}
19657c478bd9Sstevel@tonic-gate 		}
19667c478bd9Sstevel@tonic-gate 		/* fall through... */
19677c478bd9Sstevel@tonic-gate 	default:
19687c478bd9Sstevel@tonic-gate 		zdisp = ZNO;
19697c478bd9Sstevel@tonic-gate 		break;
19707c478bd9Sstevel@tonic-gate 	}
19717c478bd9Sstevel@tonic-gate 
19727c478bd9Sstevel@tonic-gate 	if ((error = prlock(pnp, zdisp)) != 0) {
19737c478bd9Sstevel@tonic-gate 		if (thing != NULL)
19747c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
19757c478bd9Sstevel@tonic-gate 		if (xpnp)
19767c478bd9Sstevel@tonic-gate 			prfreenode(xpnp);
19777c478bd9Sstevel@tonic-gate 		return (error);
19787c478bd9Sstevel@tonic-gate 	}
19797c478bd9Sstevel@tonic-gate 
19807c478bd9Sstevel@tonic-gate 	pcp = pnp->pr_common;
19817c478bd9Sstevel@tonic-gate 	p = pcp->prc_proc;
19827c478bd9Sstevel@tonic-gate 	ASSERT(p != NULL);
19837c478bd9Sstevel@tonic-gate 
19847c478bd9Sstevel@tonic-gate 	/*
19857c478bd9Sstevel@tonic-gate 	 * Choose a thread/lwp for the operation.
19867c478bd9Sstevel@tonic-gate 	 */
19877c478bd9Sstevel@tonic-gate 	if (zdisp == ZNO && cmd != PIOCSTOP && cmd != PIOCWSTOP) {
19887c478bd9Sstevel@tonic-gate 		if (pnp->pr_type == PR_LWPIDFILE && cmd != PIOCLSTATUS) {
19897c478bd9Sstevel@tonic-gate 			t = pcp->prc_thread;
19907c478bd9Sstevel@tonic-gate 			ASSERT(t != NULL);
19917c478bd9Sstevel@tonic-gate 		} else {
19927c478bd9Sstevel@tonic-gate 			t = prchoose(p);	/* returns locked thread */
19937c478bd9Sstevel@tonic-gate 			ASSERT(t != NULL);
19947c478bd9Sstevel@tonic-gate 			thread_unlock(t);
19957c478bd9Sstevel@tonic-gate 		}
19967c478bd9Sstevel@tonic-gate 		lwp = ttolwp(t);
19977c478bd9Sstevel@tonic-gate 	}
19987c478bd9Sstevel@tonic-gate 
19997c478bd9Sstevel@tonic-gate 	error = 0;
20007c478bd9Sstevel@tonic-gate 	switch (cmd) {
20017c478bd9Sstevel@tonic-gate 
20027c478bd9Sstevel@tonic-gate 	case PIOCGETPR:		/* read struct proc */
20037c478bd9Sstevel@tonic-gate 	{
20047c478bd9Sstevel@tonic-gate 		proc_t *prp = thing;
20057c478bd9Sstevel@tonic-gate 
20067c478bd9Sstevel@tonic-gate 		*prp = *p;
20077c478bd9Sstevel@tonic-gate 		prunlock(pnp);
20087c478bd9Sstevel@tonic-gate 		if (copyout(prp, cmaddr, sizeof (proc_t)))
20097c478bd9Sstevel@tonic-gate 			error = EFAULT;
20107c478bd9Sstevel@tonic-gate 		kmem_free(prp, sizeof (proc_t));
20117c478bd9Sstevel@tonic-gate 		thing = NULL;
20127c478bd9Sstevel@tonic-gate 		break;
20137c478bd9Sstevel@tonic-gate 	}
20147c478bd9Sstevel@tonic-gate 
20157c478bd9Sstevel@tonic-gate 	case PIOCGETU:		/* read u-area */
20167c478bd9Sstevel@tonic-gate 	{
20177c478bd9Sstevel@tonic-gate 		user_t *userp = thing;
20187c478bd9Sstevel@tonic-gate 
20197c478bd9Sstevel@tonic-gate 		up = PTOU(p);
20207c478bd9Sstevel@tonic-gate 		*userp = *up;
20217c478bd9Sstevel@tonic-gate 		prunlock(pnp);
20227c478bd9Sstevel@tonic-gate 		if (copyout(userp, cmaddr, sizeof (user_t)))
20237c478bd9Sstevel@tonic-gate 			error = EFAULT;
20247c478bd9Sstevel@tonic-gate 		kmem_free(userp, sizeof (user_t));
20257c478bd9Sstevel@tonic-gate 		thing = NULL;
20267c478bd9Sstevel@tonic-gate 		break;
20277c478bd9Sstevel@tonic-gate 	}
20287c478bd9Sstevel@tonic-gate 
20297c478bd9Sstevel@tonic-gate 	case PIOCOPENM:		/* open mapped object for reading */
20307c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p) && cmaddr != NULL) {
20317c478bd9Sstevel@tonic-gate 			prunlock(pnp);
20327c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
20337c478bd9Sstevel@tonic-gate 			break;
20347c478bd9Sstevel@tonic-gate 		}
20357c478bd9Sstevel@tonic-gate 		error = propenm(pnp, cmaddr,
20367c478bd9Sstevel@tonic-gate 		    (caddr_t)(uintptr_t)un32.va, rvalp, cr);
20377c478bd9Sstevel@tonic-gate 		/* propenm() called prunlock(pnp) */
20387c478bd9Sstevel@tonic-gate 		break;
20397c478bd9Sstevel@tonic-gate 
20407c478bd9Sstevel@tonic-gate 	case PIOCSTOP:		/* stop process or lwp from running */
20417c478bd9Sstevel@tonic-gate 	case PIOCWSTOP:		/* wait for process or lwp to stop */
20427c478bd9Sstevel@tonic-gate 		/*
20437c478bd9Sstevel@tonic-gate 		 * Can't apply to a system process.
20447c478bd9Sstevel@tonic-gate 		 */
20457c478bd9Sstevel@tonic-gate 		if ((p->p_flag & SSYS) || p->p_as == &kas) {
20467c478bd9Sstevel@tonic-gate 			prunlock(pnp);
20477c478bd9Sstevel@tonic-gate 			error = EBUSY;
20487c478bd9Sstevel@tonic-gate 			break;
20497c478bd9Sstevel@tonic-gate 		}
20507c478bd9Sstevel@tonic-gate 
20517c478bd9Sstevel@tonic-gate 		if (cmd == PIOCSTOP)
20527c478bd9Sstevel@tonic-gate 			pr_stop(pnp);
20537c478bd9Sstevel@tonic-gate 
20547c478bd9Sstevel@tonic-gate 		/*
20557c478bd9Sstevel@tonic-gate 		 * If an lwp is waiting for itself or its process, don't wait.
20567c478bd9Sstevel@tonic-gate 		 * The lwp will never see the fact that itself is stopped.
20577c478bd9Sstevel@tonic-gate 		 */
20587c478bd9Sstevel@tonic-gate 		if ((pnp->pr_type == PR_LWPIDFILE)?
20597c478bd9Sstevel@tonic-gate 		    (pcp->prc_thread == curthread) : (p == curproc)) {
20607c478bd9Sstevel@tonic-gate 			if (cmd == PIOCWSTOP)
20617c478bd9Sstevel@tonic-gate 				error = EBUSY;
20627c478bd9Sstevel@tonic-gate 			prunlock(pnp);
20637c478bd9Sstevel@tonic-gate 			break;
20647c478bd9Sstevel@tonic-gate 		}
20657c478bd9Sstevel@tonic-gate 
20667c478bd9Sstevel@tonic-gate 		if ((error = pr_wait_stop(pnp, (time_t)0)) != 0)
20677c478bd9Sstevel@tonic-gate 			break;	/* pr_wait_stop() unlocked the process */
20687c478bd9Sstevel@tonic-gate 
20697c478bd9Sstevel@tonic-gate 		if (cmaddr == NULL)
20707c478bd9Sstevel@tonic-gate 			prunlock(pnp);
20717c478bd9Sstevel@tonic-gate 		else if (PROCESS_NOT_32BIT(p)) {
20727c478bd9Sstevel@tonic-gate 			prunlock(pnp);
20737c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
20747c478bd9Sstevel@tonic-gate 		} else {
20757c478bd9Sstevel@tonic-gate 			/*
20767c478bd9Sstevel@tonic-gate 			 * Return process/lwp status information.
20777c478bd9Sstevel@tonic-gate 			 */
20787c478bd9Sstevel@tonic-gate 			t = pr_thread(pnp);	/* returns locked thread */
20797c478bd9Sstevel@tonic-gate 			thread_unlock(t);
2080fa9e4066Sahrens 			oprgetstatus32(t, &un32.prstat, VTOZONE(vp));
20817c478bd9Sstevel@tonic-gate 			prunlock(pnp);
20827c478bd9Sstevel@tonic-gate 			if (copyout(&un32.prstat, cmaddr, sizeof (un32.prstat)))
20837c478bd9Sstevel@tonic-gate 				error = EFAULT;
20847c478bd9Sstevel@tonic-gate 		}
20857c478bd9Sstevel@tonic-gate 		break;
20867c478bd9Sstevel@tonic-gate 
20877c478bd9Sstevel@tonic-gate 	case PIOCRUN:		/* make lwp or process runnable */
20887c478bd9Sstevel@tonic-gate 	{
20897c478bd9Sstevel@tonic-gate 		long flags = un32.prrun.pr_flags;
20907c478bd9Sstevel@tonic-gate 
20917c478bd9Sstevel@tonic-gate 		/*
20927c478bd9Sstevel@tonic-gate 		 * Cannot set an lwp running is it is not stopped.
20937c478bd9Sstevel@tonic-gate 		 * Also, no lwp other than the /proc agent lwp can
20947c478bd9Sstevel@tonic-gate 		 * be set running so long as the /proc agent lwp exists.
20957c478bd9Sstevel@tonic-gate 		 */
20967c478bd9Sstevel@tonic-gate 		if ((!ISTOPPED(t) && !VSTOPPED(t) &&
20977c478bd9Sstevel@tonic-gate 		    !(t->t_proc_flag & TP_PRSTOP)) ||
20987c478bd9Sstevel@tonic-gate 		    (p->p_agenttp != NULL &&
20997c478bd9Sstevel@tonic-gate 		    (t != p->p_agenttp || pnp->pr_type != PR_LWPIDFILE))) {
21007c478bd9Sstevel@tonic-gate 			prunlock(pnp);
21017c478bd9Sstevel@tonic-gate 			error = EBUSY;
21027c478bd9Sstevel@tonic-gate 			break;
21037c478bd9Sstevel@tonic-gate 		}
21047c478bd9Sstevel@tonic-gate 
21057c478bd9Sstevel@tonic-gate 		if ((flags & PRSVADDR) && PROCESS_NOT_32BIT(p)) {
21067c478bd9Sstevel@tonic-gate 			prunlock(pnp);
21077c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
21087c478bd9Sstevel@tonic-gate 			break;
21097c478bd9Sstevel@tonic-gate 		}
21107c478bd9Sstevel@tonic-gate 
21117c478bd9Sstevel@tonic-gate 		if (flags & (PRSHOLD|PRSTRACE|PRSFAULT|PRSVADDR)) {
21127c478bd9Sstevel@tonic-gate 			un.prrun.pr_flags = (int)flags;
21137c478bd9Sstevel@tonic-gate 			un.prrun.pr_trace = un32.prrun.pr_trace;
21147c478bd9Sstevel@tonic-gate 			un.prrun.pr_sighold = un32.prrun.pr_sighold;
21157c478bd9Sstevel@tonic-gate 			un.prrun.pr_fault = un32.prrun.pr_fault;
21167c478bd9Sstevel@tonic-gate 			un.prrun.pr_vaddr =
21177c478bd9Sstevel@tonic-gate 			    (caddr_t)(uintptr_t)un32.prrun.pr_vaddr;
21187c478bd9Sstevel@tonic-gate 			prsetrun(t, &un.prrun);
21197c478bd9Sstevel@tonic-gate 		}
21207c478bd9Sstevel@tonic-gate 
21217c478bd9Sstevel@tonic-gate 		error = pr_setrun(pnp, prmaprunflags(flags));
21227c478bd9Sstevel@tonic-gate 
21237c478bd9Sstevel@tonic-gate 		prunlock(pnp);
21247c478bd9Sstevel@tonic-gate 		break;
21257c478bd9Sstevel@tonic-gate 	}
21267c478bd9Sstevel@tonic-gate 
21277c478bd9Sstevel@tonic-gate 	case PIOCLWPIDS:	/* get array of lwp identifiers */
21287c478bd9Sstevel@tonic-gate 	{
21297c478bd9Sstevel@tonic-gate 		int nlwp;
21307c478bd9Sstevel@tonic-gate 		int Nlwp;
21317c478bd9Sstevel@tonic-gate 		id_t *idp;
21327c478bd9Sstevel@tonic-gate 		id_t *Bidp;
21337c478bd9Sstevel@tonic-gate 
21347c478bd9Sstevel@tonic-gate 		Nlwp = nlwp = p->p_lwpcnt;
21357c478bd9Sstevel@tonic-gate 
21367c478bd9Sstevel@tonic-gate 		if (thing && thingsize != (Nlwp+1) * sizeof (id_t)) {
21377c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
21387c478bd9Sstevel@tonic-gate 			thing = NULL;
21397c478bd9Sstevel@tonic-gate 		}
21407c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
21417c478bd9Sstevel@tonic-gate 			thingsize = (Nlwp+1) * sizeof (id_t);
21427c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
21437c478bd9Sstevel@tonic-gate 		}
21447c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
21457c478bd9Sstevel@tonic-gate 			prunlock(pnp);
21467c478bd9Sstevel@tonic-gate 			goto startover;
21477c478bd9Sstevel@tonic-gate 		}
21487c478bd9Sstevel@tonic-gate 
21497c478bd9Sstevel@tonic-gate 		idp = thing;
21507c478bd9Sstevel@tonic-gate 		thing = NULL;
21517c478bd9Sstevel@tonic-gate 		Bidp = idp;
21527c478bd9Sstevel@tonic-gate 		if ((t = p->p_tlist) != NULL) {
21537c478bd9Sstevel@tonic-gate 			do {
21547c478bd9Sstevel@tonic-gate 				ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
21557c478bd9Sstevel@tonic-gate 				ASSERT(nlwp > 0);
21567c478bd9Sstevel@tonic-gate 				--nlwp;
21577c478bd9Sstevel@tonic-gate 				*idp++ = t->t_tid;
21587c478bd9Sstevel@tonic-gate 			} while ((t = t->t_forw) != p->p_tlist);
21597c478bd9Sstevel@tonic-gate 		}
21607c478bd9Sstevel@tonic-gate 		*idp = 0;
21617c478bd9Sstevel@tonic-gate 		ASSERT(nlwp == 0);
21627c478bd9Sstevel@tonic-gate 		prunlock(pnp);
21637c478bd9Sstevel@tonic-gate 		if (copyout(Bidp, cmaddr, (Nlwp+1) * sizeof (id_t)))
21647c478bd9Sstevel@tonic-gate 			error = EFAULT;
21657c478bd9Sstevel@tonic-gate 		kmem_free(Bidp, (Nlwp+1) * sizeof (id_t));
21667c478bd9Sstevel@tonic-gate 		break;
21677c478bd9Sstevel@tonic-gate 	}
21687c478bd9Sstevel@tonic-gate 
21697c478bd9Sstevel@tonic-gate 	case PIOCOPENLWP:	/* return /proc lwp file descriptor */
21707c478bd9Sstevel@tonic-gate 	{
21717c478bd9Sstevel@tonic-gate 		vnode_t *xvp;
21727c478bd9Sstevel@tonic-gate 		int n;
21737c478bd9Sstevel@tonic-gate 
21747c478bd9Sstevel@tonic-gate 		prunlock(pnp);
21757c478bd9Sstevel@tonic-gate 		if ((xvp = prlwpnode(pnp, un32.lwpid)) == NULL)
21767c478bd9Sstevel@tonic-gate 			error = ENOENT;
21777c478bd9Sstevel@tonic-gate 		else if (error = fassign(&xvp, flag & (FREAD|FWRITE), &n)) {
21787c478bd9Sstevel@tonic-gate 			VN_RELE(xvp);
21797c478bd9Sstevel@tonic-gate 		} else
21807c478bd9Sstevel@tonic-gate 			*rvalp = n;
21817c478bd9Sstevel@tonic-gate 		break;
21827c478bd9Sstevel@tonic-gate 	}
21837c478bd9Sstevel@tonic-gate 
21847c478bd9Sstevel@tonic-gate 	case PIOCOPENPD:	/* return /proc page data file descriptor */
21857c478bd9Sstevel@tonic-gate 	{
21867c478bd9Sstevel@tonic-gate 		vnode_t *xvp = PTOV(xpnp);
21877c478bd9Sstevel@tonic-gate 		vnode_t *dp = pnp->pr_parent;
21887c478bd9Sstevel@tonic-gate 		int n;
21897c478bd9Sstevel@tonic-gate 
21907c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p)) {
21917c478bd9Sstevel@tonic-gate 			prunlock(pnp);
21927c478bd9Sstevel@tonic-gate 			prfreenode(xpnp);
21937c478bd9Sstevel@tonic-gate 			xpnp = NULL;
21947c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
21957c478bd9Sstevel@tonic-gate 			break;
21967c478bd9Sstevel@tonic-gate 		}
21977c478bd9Sstevel@tonic-gate 
21987c478bd9Sstevel@tonic-gate 		if (pnp->pr_type == PR_LWPIDFILE) {
21997c478bd9Sstevel@tonic-gate 			dp = VTOP(dp)->pr_parent;
22007c478bd9Sstevel@tonic-gate 			dp = VTOP(dp)->pr_parent;
22017c478bd9Sstevel@tonic-gate 		}
22027c478bd9Sstevel@tonic-gate 		ASSERT(VTOP(dp)->pr_type == PR_PIDDIR);
22037c478bd9Sstevel@tonic-gate 
22047c478bd9Sstevel@tonic-gate 		VN_HOLD(dp);
22057c478bd9Sstevel@tonic-gate 		pcp = pnp->pr_pcommon;
22067c478bd9Sstevel@tonic-gate 		xpnp->pr_ino = ptoi(pcp->prc_pid);
22077c478bd9Sstevel@tonic-gate 		xpnp->pr_common = pcp;
22087c478bd9Sstevel@tonic-gate 		xpnp->pr_pcommon = pcp;
22097c478bd9Sstevel@tonic-gate 		xpnp->pr_parent = dp;
22107c478bd9Sstevel@tonic-gate 
22117c478bd9Sstevel@tonic-gate 		xpnp->pr_next = p->p_plist;
22127c478bd9Sstevel@tonic-gate 		p->p_plist = xvp;
22137c478bd9Sstevel@tonic-gate 
22147c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22157c478bd9Sstevel@tonic-gate 		if (error = fassign(&xvp, FREAD, &n)) {
22167c478bd9Sstevel@tonic-gate 			VN_RELE(xvp);
22177c478bd9Sstevel@tonic-gate 		} else
22187c478bd9Sstevel@tonic-gate 			*rvalp = n;
22197c478bd9Sstevel@tonic-gate 
22207c478bd9Sstevel@tonic-gate 		xpnp = NULL;
22217c478bd9Sstevel@tonic-gate 		break;
22227c478bd9Sstevel@tonic-gate 	}
22237c478bd9Sstevel@tonic-gate 
22247c478bd9Sstevel@tonic-gate 	case PIOCGTRACE:	/* get signal trace mask */
22257c478bd9Sstevel@tonic-gate 		prassignset(&un32.smask, &p->p_sigmask);
22267c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22277c478bd9Sstevel@tonic-gate 		if (copyout(&un32.smask, cmaddr, sizeof (un32.smask)))
22287c478bd9Sstevel@tonic-gate 			error = EFAULT;
22297c478bd9Sstevel@tonic-gate 		break;
22307c478bd9Sstevel@tonic-gate 
22317c478bd9Sstevel@tonic-gate 	case PIOCSTRACE:	/* set signal trace mask */
22327c478bd9Sstevel@tonic-gate 		prdelset(&un32.smask, SIGKILL);
22337c478bd9Sstevel@tonic-gate 		prassignset(&p->p_sigmask, &un32.smask);
22347c478bd9Sstevel@tonic-gate 		if (!sigisempty(&p->p_sigmask))
22357c478bd9Sstevel@tonic-gate 			p->p_proc_flag |= P_PR_TRACE;
22367c478bd9Sstevel@tonic-gate 		else if (prisempty(&p->p_fltmask)) {
22377c478bd9Sstevel@tonic-gate 			up = PTOU(p);
22387c478bd9Sstevel@tonic-gate 			if (up->u_systrap == 0)
22397c478bd9Sstevel@tonic-gate 				p->p_proc_flag &= ~P_PR_TRACE;
22407c478bd9Sstevel@tonic-gate 		}
22417c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22427c478bd9Sstevel@tonic-gate 		break;
22437c478bd9Sstevel@tonic-gate 
22447c478bd9Sstevel@tonic-gate 	case PIOCSSIG:		/* set current signal */
22457c478bd9Sstevel@tonic-gate 		if (un32.info.si_signo != 0 && PROCESS_NOT_32BIT(p)) {
22467c478bd9Sstevel@tonic-gate 			prunlock(pnp);
22477c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
22487c478bd9Sstevel@tonic-gate 		} else {
22497c478bd9Sstevel@tonic-gate 			bzero(&un.info, sizeof (un.info));
22507c478bd9Sstevel@tonic-gate 			siginfo_32tok(&un32.info, (k_siginfo_t *)&un.info);
22517c478bd9Sstevel@tonic-gate 			error = pr_setsig(pnp, &un.info);
22527c478bd9Sstevel@tonic-gate 			prunlock(pnp);
22537c478bd9Sstevel@tonic-gate 			if (un32.info.si_signo == SIGKILL && error == 0)
22547c478bd9Sstevel@tonic-gate 				pr_wait_die(pnp);
22557c478bd9Sstevel@tonic-gate 		}
22567c478bd9Sstevel@tonic-gate 		break;
22577c478bd9Sstevel@tonic-gate 
22587c478bd9Sstevel@tonic-gate 	case PIOCKILL:		/* send signal */
22597c478bd9Sstevel@tonic-gate 		error = pr_kill(pnp, un32.signo, cr);
22607c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22617c478bd9Sstevel@tonic-gate 		if (un32.signo == SIGKILL && error == 0)
22627c478bd9Sstevel@tonic-gate 			pr_wait_die(pnp);
22637c478bd9Sstevel@tonic-gate 		break;
22647c478bd9Sstevel@tonic-gate 
22657c478bd9Sstevel@tonic-gate 	case PIOCUNKILL:	/* delete a signal */
22667c478bd9Sstevel@tonic-gate 		error = pr_unkill(pnp, un32.signo);
22677c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22687c478bd9Sstevel@tonic-gate 		break;
22697c478bd9Sstevel@tonic-gate 
22707c478bd9Sstevel@tonic-gate 	case PIOCNICE:		/* set nice priority */
22717c478bd9Sstevel@tonic-gate 		error = pr_nice(p, un32.nice, cr);
22727c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22737c478bd9Sstevel@tonic-gate 		break;
22747c478bd9Sstevel@tonic-gate 
22757c478bd9Sstevel@tonic-gate 	case PIOCGENTRY:	/* get syscall entry bit mask */
22767c478bd9Sstevel@tonic-gate 	case PIOCGEXIT:		/* get syscall exit bit mask */
22777c478bd9Sstevel@tonic-gate 		up = PTOU(p);
22787c478bd9Sstevel@tonic-gate 		if (cmd == PIOCGENTRY) {
22797c478bd9Sstevel@tonic-gate 			prassignset(&un32.prmask, &up->u_entrymask);
22807c478bd9Sstevel@tonic-gate 		} else {
22817c478bd9Sstevel@tonic-gate 			prassignset(&un32.prmask, &up->u_exitmask);
22827c478bd9Sstevel@tonic-gate 		}
22837c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22847c478bd9Sstevel@tonic-gate 		if (copyout(&un32.prmask, cmaddr, sizeof (un32.prmask)))
22857c478bd9Sstevel@tonic-gate 			error = EFAULT;
22867c478bd9Sstevel@tonic-gate 		break;
22877c478bd9Sstevel@tonic-gate 
22887c478bd9Sstevel@tonic-gate 	case PIOCSENTRY:	/* set syscall entry bit mask */
22897c478bd9Sstevel@tonic-gate 	case PIOCSEXIT:		/* set syscall exit bit mask */
22907c478bd9Sstevel@tonic-gate 		pr_setentryexit(p, &un32.prmask, cmd == PIOCSENTRY);
22917c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22927c478bd9Sstevel@tonic-gate 		break;
22937c478bd9Sstevel@tonic-gate 
22947c478bd9Sstevel@tonic-gate 	case PIOCSRLC:		/* obsolete: set running on last /proc close */
22957c478bd9Sstevel@tonic-gate 		error = pr_set(p, prmapsetflags(PR_RLC));
22967c478bd9Sstevel@tonic-gate 		prunlock(pnp);
22977c478bd9Sstevel@tonic-gate 		break;
22987c478bd9Sstevel@tonic-gate 
22997c478bd9Sstevel@tonic-gate 	case PIOCRRLC:		/* obsolete: reset run-on-last-close flag */
23007c478bd9Sstevel@tonic-gate 		error = pr_unset(p, prmapsetflags(PR_RLC));
23017c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23027c478bd9Sstevel@tonic-gate 		break;
23037c478bd9Sstevel@tonic-gate 
23047c478bd9Sstevel@tonic-gate 	case PIOCSFORK:		/* obsolete: set inherit-on-fork flag */
23057c478bd9Sstevel@tonic-gate 		error = pr_set(p, prmapsetflags(PR_FORK));
23067c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23077c478bd9Sstevel@tonic-gate 		break;
23087c478bd9Sstevel@tonic-gate 
23097c478bd9Sstevel@tonic-gate 	case PIOCRFORK:		/* obsolete: reset inherit-on-fork flag */
23107c478bd9Sstevel@tonic-gate 		error = pr_unset(p, prmapsetflags(PR_FORK));
23117c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23127c478bd9Sstevel@tonic-gate 		break;
23137c478bd9Sstevel@tonic-gate 
23147c478bd9Sstevel@tonic-gate 	case PIOCSET:		/* set process flags */
23157c478bd9Sstevel@tonic-gate 		error = pr_set(p, prmapsetflags((long)un32.flags));
23167c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23177c478bd9Sstevel@tonic-gate 		break;
23187c478bd9Sstevel@tonic-gate 
23197c478bd9Sstevel@tonic-gate 	case PIOCRESET:		/* reset process flags */
23207c478bd9Sstevel@tonic-gate 		error = pr_unset(p, prmapsetflags((long)un32.flags));
23217c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23227c478bd9Sstevel@tonic-gate 		break;
23237c478bd9Sstevel@tonic-gate 
23247c478bd9Sstevel@tonic-gate 	case PIOCGREG:		/* get general registers */
23257c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p))
23267c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
23277c478bd9Sstevel@tonic-gate 		else if (t->t_state != TS_STOPPED && !VSTOPPED(t))
23287c478bd9Sstevel@tonic-gate 			bzero(un32.regs, sizeof (un32.regs));
23297c478bd9Sstevel@tonic-gate 		else {
23307c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
23317c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
23327c478bd9Sstevel@tonic-gate 			prgetprregs32(lwp, un32.regs);
23337c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
23347c478bd9Sstevel@tonic-gate 		}
23357c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23367c478bd9Sstevel@tonic-gate 		if (error == 0 &&
23377c478bd9Sstevel@tonic-gate 		    copyout(un32.regs, cmaddr, sizeof (un32.regs)))
23387c478bd9Sstevel@tonic-gate 			error = EFAULT;
23397c478bd9Sstevel@tonic-gate 		break;
23407c478bd9Sstevel@tonic-gate 
23417c478bd9Sstevel@tonic-gate 	case PIOCSREG:		/* set general registers */
23427c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p))
23437c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
23447c478bd9Sstevel@tonic-gate 		else if (!ISTOPPED(t) && !VSTOPPED(t) && !DSTOPPED(t))
23457c478bd9Sstevel@tonic-gate 			error = EBUSY;
23467c478bd9Sstevel@tonic-gate 		else {
23477c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
23487c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
23497c478bd9Sstevel@tonic-gate 			prgregset_32ton(lwp, un32.regs, un.regs);
23507c478bd9Sstevel@tonic-gate 			prsetprregs(lwp, un.regs, 0);
23517c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
23527c478bd9Sstevel@tonic-gate 		}
23537c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23547c478bd9Sstevel@tonic-gate 		break;
23557c478bd9Sstevel@tonic-gate 
23567c478bd9Sstevel@tonic-gate 	case PIOCGFPREG:	/* get floating-point registers */
23577c478bd9Sstevel@tonic-gate 		if (!prhasfp())
23587c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No FP support */
23597c478bd9Sstevel@tonic-gate 		else if (PROCESS_NOT_32BIT(p))
23607c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
23617c478bd9Sstevel@tonic-gate 		else if (t->t_state != TS_STOPPED && !VSTOPPED(t))
23627c478bd9Sstevel@tonic-gate 			bzero(&un32.fpregs, sizeof (un32.fpregs));
23637c478bd9Sstevel@tonic-gate 		else {
23647c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
23657c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
23667c478bd9Sstevel@tonic-gate 			prgetprfpregs32(lwp, &un32.fpregs);
23677c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
23687c478bd9Sstevel@tonic-gate 		}
23697c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23707c478bd9Sstevel@tonic-gate 		if (error == 0 &&
23717c478bd9Sstevel@tonic-gate 		    copyout(&un32.fpregs, cmaddr, sizeof (un32.fpregs)))
23727c478bd9Sstevel@tonic-gate 			error = EFAULT;
23737c478bd9Sstevel@tonic-gate 		break;
23747c478bd9Sstevel@tonic-gate 
23757c478bd9Sstevel@tonic-gate 	case PIOCSFPREG:	/* set floating-point registers */
23767c478bd9Sstevel@tonic-gate 		if (!prhasfp())
23777c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No FP support */
23787c478bd9Sstevel@tonic-gate 		else if (PROCESS_NOT_32BIT(p))
23797c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
23807c478bd9Sstevel@tonic-gate 		else if (!ISTOPPED(t) && !VSTOPPED(t) && !DSTOPPED(t))
23817c478bd9Sstevel@tonic-gate 			error = EBUSY;
23827c478bd9Sstevel@tonic-gate 		else {
23837c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
23847c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
23857c478bd9Sstevel@tonic-gate 			prsetprfpregs32(lwp, &un32.fpregs);
23867c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
23877c478bd9Sstevel@tonic-gate 		}
23887c478bd9Sstevel@tonic-gate 		prunlock(pnp);
23897c478bd9Sstevel@tonic-gate 		break;
23907c478bd9Sstevel@tonic-gate 
23917c478bd9Sstevel@tonic-gate 	case PIOCGXREGSIZE:	/* get the size of the extra registers */
23927c478bd9Sstevel@tonic-gate 	{
23937c478bd9Sstevel@tonic-gate 		int xregsize;
23947c478bd9Sstevel@tonic-gate 
23957c478bd9Sstevel@tonic-gate 		if (prhasx(p)) {
23967c478bd9Sstevel@tonic-gate 			xregsize = prgetprxregsize(p);
23977c478bd9Sstevel@tonic-gate 			prunlock(pnp);
23987c478bd9Sstevel@tonic-gate 			if (copyout(&xregsize, cmaddr, sizeof (xregsize)))
23997c478bd9Sstevel@tonic-gate 				error = EFAULT;
24007c478bd9Sstevel@tonic-gate 		} else {
24017c478bd9Sstevel@tonic-gate 			prunlock(pnp);
24027c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No extra register support */
24037c478bd9Sstevel@tonic-gate 		}
24047c478bd9Sstevel@tonic-gate 		break;
24057c478bd9Sstevel@tonic-gate 	}
24067c478bd9Sstevel@tonic-gate 
24077c478bd9Sstevel@tonic-gate 	case PIOCGXREG:		/* get extra registers */
24087c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p))
24097c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
24107c478bd9Sstevel@tonic-gate 		else if (!prhasx(p))
24117c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No extra register support */
24127c478bd9Sstevel@tonic-gate 		else {
24137c478bd9Sstevel@tonic-gate 			bzero(thing, thingsize);
24147c478bd9Sstevel@tonic-gate 			if (t->t_state == TS_STOPPED || VSTOPPED(t)) {
24157c478bd9Sstevel@tonic-gate 				/* drop p_lock to touch the stack */
24167c478bd9Sstevel@tonic-gate 				mutex_exit(&p->p_lock);
24177c478bd9Sstevel@tonic-gate 				prgetprxregs(lwp, thing);
24187c478bd9Sstevel@tonic-gate 				mutex_enter(&p->p_lock);
24197c478bd9Sstevel@tonic-gate 			}
24207c478bd9Sstevel@tonic-gate 		}
24217c478bd9Sstevel@tonic-gate 		prunlock(pnp);
24227c478bd9Sstevel@tonic-gate 		if (error == 0 &&
24237c478bd9Sstevel@tonic-gate 		    copyout(thing, cmaddr, thingsize))
24247c478bd9Sstevel@tonic-gate 			error = EFAULT;
24257c478bd9Sstevel@tonic-gate 		if (thing) {
24267c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
24277c478bd9Sstevel@tonic-gate 			thing = NULL;
24287c478bd9Sstevel@tonic-gate 		}
24297c478bd9Sstevel@tonic-gate 		break;
24307c478bd9Sstevel@tonic-gate 
24317c478bd9Sstevel@tonic-gate 	case PIOCSXREG:		/* set extra registers */
24327c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p))
24337c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
24347c478bd9Sstevel@tonic-gate 		else if (!ISTOPPED(t) && !VSTOPPED(t) && !DSTOPPED(t))
24357c478bd9Sstevel@tonic-gate 			error = EBUSY;
24367c478bd9Sstevel@tonic-gate 		else if (!prhasx(p))
24377c478bd9Sstevel@tonic-gate 			error = EINVAL;	/* No extra register support */
24387c478bd9Sstevel@tonic-gate 		else if (thing) {
24397c478bd9Sstevel@tonic-gate 			/* drop p_lock while touching the lwp's stack */
24407c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
24417c478bd9Sstevel@tonic-gate 			prsetprxregs(lwp, thing);
24427c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
24437c478bd9Sstevel@tonic-gate 		}
24447c478bd9Sstevel@tonic-gate 		prunlock(pnp);
24457c478bd9Sstevel@tonic-gate 		if (thing) {
24467c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
24477c478bd9Sstevel@tonic-gate 			thing = NULL;
24487c478bd9Sstevel@tonic-gate 		}
24497c478bd9Sstevel@tonic-gate 		break;
24507c478bd9Sstevel@tonic-gate 
24517c478bd9Sstevel@tonic-gate 	case PIOCSTATUS:	/* get process/lwp status */
24527c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p)) {
24537c478bd9Sstevel@tonic-gate 			prunlock(pnp);
24547c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
24557c478bd9Sstevel@tonic-gate 			break;
24567c478bd9Sstevel@tonic-gate 		}
2457fa9e4066Sahrens 		oprgetstatus32(t, &un32.prstat, VTOZONE(vp));
24587c478bd9Sstevel@tonic-gate 		prunlock(pnp);
24597c478bd9Sstevel@tonic-gate 		if (copyout(&un32.prstat, cmaddr, sizeof (un32.prstat)))
24607c478bd9Sstevel@tonic-gate 			error = EFAULT;
24617c478bd9Sstevel@tonic-gate 		break;
24627c478bd9Sstevel@tonic-gate 
24637c478bd9Sstevel@tonic-gate 	case PIOCLSTATUS:	/* get status for process & all lwps */
24647c478bd9Sstevel@tonic-gate 	{
24657c478bd9Sstevel@tonic-gate 		int Nlwp;
24667c478bd9Sstevel@tonic-gate 		int nlwp;
24677c478bd9Sstevel@tonic-gate 		prstatus32_t *Bprsp;
24687c478bd9Sstevel@tonic-gate 		prstatus32_t *prsp;
24697c478bd9Sstevel@tonic-gate 
24707c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p)) {
24717c478bd9Sstevel@tonic-gate 			prunlock(pnp);
24727c478bd9Sstevel@tonic-gate 			if (thing) {
24737c478bd9Sstevel@tonic-gate 				kmem_free(thing, thingsize);
24747c478bd9Sstevel@tonic-gate 				thing = NULL;
24757c478bd9Sstevel@tonic-gate 			}
24767c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
24777c478bd9Sstevel@tonic-gate 			break;
24787c478bd9Sstevel@tonic-gate 		}
24797c478bd9Sstevel@tonic-gate 
24807c478bd9Sstevel@tonic-gate 		nlwp = Nlwp = p->p_lwpcnt;
24817c478bd9Sstevel@tonic-gate 
24827c478bd9Sstevel@tonic-gate 		if (thing && thingsize != (Nlwp+1) * sizeof (prstatus32_t)) {
24837c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
24847c478bd9Sstevel@tonic-gate 			thing = NULL;
24857c478bd9Sstevel@tonic-gate 		}
24867c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
24877c478bd9Sstevel@tonic-gate 			thingsize = (Nlwp+1) * sizeof (prstatus32_t);
24887c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
24897c478bd9Sstevel@tonic-gate 		}
24907c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
24917c478bd9Sstevel@tonic-gate 			prunlock(pnp);
24927c478bd9Sstevel@tonic-gate 			goto startover;
24937c478bd9Sstevel@tonic-gate 		}
24947c478bd9Sstevel@tonic-gate 
24957c478bd9Sstevel@tonic-gate 		Bprsp = (prstatus32_t *)thing;
24967c478bd9Sstevel@tonic-gate 		thing = NULL;
24977c478bd9Sstevel@tonic-gate 		prsp = Bprsp;
2498fa9e4066Sahrens 		oprgetstatus32(t, prsp, VTOZONE(vp));
24997c478bd9Sstevel@tonic-gate 		t = p->p_tlist;
25007c478bd9Sstevel@tonic-gate 		do {
25017c478bd9Sstevel@tonic-gate 			ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
25027c478bd9Sstevel@tonic-gate 			ASSERT(nlwp > 0);
25037c478bd9Sstevel@tonic-gate 			--nlwp;
2504fa9e4066Sahrens 			oprgetstatus32(t, ++prsp, VTOZONE(vp));
25057c478bd9Sstevel@tonic-gate 		} while ((t = t->t_forw) != p->p_tlist);
25067c478bd9Sstevel@tonic-gate 		ASSERT(nlwp == 0);
25077c478bd9Sstevel@tonic-gate 		prunlock(pnp);
25087c478bd9Sstevel@tonic-gate 		if (copyout(Bprsp, cmaddr, (Nlwp+1) * sizeof (prstatus32_t)))
25097c478bd9Sstevel@tonic-gate 			error = EFAULT;
25107c478bd9Sstevel@tonic-gate 
25117c478bd9Sstevel@tonic-gate 		kmem_free(Bprsp, (Nlwp + 1) * sizeof (prstatus32_t));
25127c478bd9Sstevel@tonic-gate 		break;
25137c478bd9Sstevel@tonic-gate 	}
25147c478bd9Sstevel@tonic-gate 
25157c478bd9Sstevel@tonic-gate 	case PIOCPSINFO:	/* get ps(1) information */
25167c478bd9Sstevel@tonic-gate 	{
25177c478bd9Sstevel@tonic-gate 		prpsinfo32_t *psp = &un32.prps;
25187c478bd9Sstevel@tonic-gate 
25197c478bd9Sstevel@tonic-gate 		oprgetpsinfo32(p, psp,
25207c478bd9Sstevel@tonic-gate 		    (pnp->pr_type == PR_LWPIDFILE)? pcp->prc_thread : NULL);
25217c478bd9Sstevel@tonic-gate 
25227c478bd9Sstevel@tonic-gate 		prunlock(pnp);
25237c478bd9Sstevel@tonic-gate 		if (copyout(&un32.prps, cmaddr, sizeof (un32.prps)))
25247c478bd9Sstevel@tonic-gate 			error = EFAULT;
25257c478bd9Sstevel@tonic-gate 		break;
25267c478bd9Sstevel@tonic-gate 	}
25277c478bd9Sstevel@tonic-gate 
25287c478bd9Sstevel@tonic-gate 	case PIOCMAXSIG:	/* get maximum signal number */
25297c478bd9Sstevel@tonic-gate 	{
2530eb9dbf0cSRoger A. Faulkner 		int n = nsig-1;
25317c478bd9Sstevel@tonic-gate 
25327c478bd9Sstevel@tonic-gate 		prunlock(pnp);
25337c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (int)))
25347c478bd9Sstevel@tonic-gate 			error = EFAULT;
25357c478bd9Sstevel@tonic-gate 		break;
25367c478bd9Sstevel@tonic-gate 	}
25377c478bd9Sstevel@tonic-gate 
25387c478bd9Sstevel@tonic-gate 	case PIOCACTION:	/* get signal action structures */
25397c478bd9Sstevel@tonic-gate 	{
25407c478bd9Sstevel@tonic-gate 		uint_t sig;
25417c478bd9Sstevel@tonic-gate 		struct sigaction32 *sap = thing;
25427c478bd9Sstevel@tonic-gate 
25437c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p))
25447c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
25457c478bd9Sstevel@tonic-gate 		else {
25467c478bd9Sstevel@tonic-gate 			up = PTOU(p);
2547eb9dbf0cSRoger A. Faulkner 			for (sig = 1; sig < nsig; sig++)
25487c478bd9Sstevel@tonic-gate 				prgetaction32(p, up, sig, &sap[sig-1]);
25497c478bd9Sstevel@tonic-gate 		}
25507c478bd9Sstevel@tonic-gate 		prunlock(pnp);
25517c478bd9Sstevel@tonic-gate 		if (error == 0 &&
2552eb9dbf0cSRoger A. Faulkner 		    copyout(sap, cmaddr, (nsig-1)*sizeof (struct sigaction32)))
25537c478bd9Sstevel@tonic-gate 			error = EFAULT;
2554eb9dbf0cSRoger A. Faulkner 		kmem_free(sap, (nsig-1)*sizeof (struct sigaction32));
25557c478bd9Sstevel@tonic-gate 		thing = NULL;
25567c478bd9Sstevel@tonic-gate 		break;
25577c478bd9Sstevel@tonic-gate 	}
25587c478bd9Sstevel@tonic-gate 
25597c478bd9Sstevel@tonic-gate 	case PIOCGHOLD:		/* get signal-hold mask */
25607c478bd9Sstevel@tonic-gate 		schedctl_finish_sigblock(t);
25617c478bd9Sstevel@tonic-gate 		sigktou(&t->t_hold, &un32.holdmask);
25627c478bd9Sstevel@tonic-gate 		prunlock(pnp);
25637c478bd9Sstevel@tonic-gate 		if (copyout(&un32.holdmask, cmaddr, sizeof (un32.holdmask)))
25647c478bd9Sstevel@tonic-gate 			error = EFAULT;
25657c478bd9Sstevel@tonic-gate 		break;
25667c478bd9Sstevel@tonic-gate 
25677c478bd9Sstevel@tonic-gate 	case PIOCSHOLD:		/* set signal-hold mask */
25687c478bd9Sstevel@tonic-gate 		pr_sethold(pnp, &un32.holdmask);
25697c478bd9Sstevel@tonic-gate 		prunlock(pnp);
25707c478bd9Sstevel@tonic-gate 		break;
25717c478bd9Sstevel@tonic-gate 
25727c478bd9Sstevel@tonic-gate 	case PIOCNMAP:		/* get number of memory mappings */
25737c478bd9Sstevel@tonic-gate 	{
25747c478bd9Sstevel@tonic-gate 		int n;
25757c478bd9Sstevel@tonic-gate 		struct as *as = p->p_as;
25767c478bd9Sstevel@tonic-gate 
25777c478bd9Sstevel@tonic-gate 		if ((p->p_flag & SSYS) || as == &kas)
25787c478bd9Sstevel@tonic-gate 			n = 0;
25797c478bd9Sstevel@tonic-gate 		else {
25807c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
2581dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_ENTER(as, RW_WRITER);
25827c478bd9Sstevel@tonic-gate 			n = prnsegs(as, 0);
2583dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_EXIT(as);
25847c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
25857c478bd9Sstevel@tonic-gate 		}
25867c478bd9Sstevel@tonic-gate 		prunlock(pnp);
25877c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (int)))
25887c478bd9Sstevel@tonic-gate 			error = EFAULT;
25897c478bd9Sstevel@tonic-gate 		break;
25907c478bd9Sstevel@tonic-gate 	}
25917c478bd9Sstevel@tonic-gate 
25927c478bd9Sstevel@tonic-gate 	case PIOCMAP:		/* get memory map information */
25937c478bd9Sstevel@tonic-gate 	{
2594870619e9Sfrankho 		list_t iolhead;
25957c478bd9Sstevel@tonic-gate 		struct as *as = p->p_as;
25967c478bd9Sstevel@tonic-gate 
2597870619e9Sfrankho 		if ((p->p_flag & SSYS) || as == &kas) {
2598870619e9Sfrankho 			error = 0;
2599870619e9Sfrankho 			prunlock(pnp);
26007c478bd9Sstevel@tonic-gate 		} else if (PROCESS_NOT_32BIT(p)) {
26017c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
26027c478bd9Sstevel@tonic-gate 			prunlock(pnp);
26037c478bd9Sstevel@tonic-gate 		} else {
26047c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
2605dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_ENTER(as, RW_WRITER);
2606870619e9Sfrankho 			error = oprgetmap32(p, &iolhead);
2607dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_EXIT(as);
26087c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
2609870619e9Sfrankho 			prunlock(pnp);
26107c478bd9Sstevel@tonic-gate 
2611870619e9Sfrankho 			error = pr_iol_copyout_and_free(&iolhead,
2612870619e9Sfrankho 			    &cmaddr, error);
2613870619e9Sfrankho 		}
2614870619e9Sfrankho 		/*
2615870619e9Sfrankho 		 * The procfs PIOCMAP ioctl returns an all-zero buffer
2616870619e9Sfrankho 		 * to indicate the end of the prmap[] array.
2617870619e9Sfrankho 		 * Append it to whatever has already been copied out.
2618870619e9Sfrankho 		 */
2619870619e9Sfrankho 		bzero(&un32.prmap, sizeof (un32.prmap));
2620870619e9Sfrankho 		if (!error &&
2621870619e9Sfrankho 		    copyout(&un32.prmap, cmaddr, sizeof (un32.prmap)))
2622870619e9Sfrankho 				error = EFAULT;
26237c478bd9Sstevel@tonic-gate 		break;
26247c478bd9Sstevel@tonic-gate 	}
26257c478bd9Sstevel@tonic-gate 
26267c478bd9Sstevel@tonic-gate 	case PIOCGFAULT:	/* get mask of traced faults */
26277c478bd9Sstevel@tonic-gate 		prassignset(&un32.fltmask, &p->p_fltmask);
26287c478bd9Sstevel@tonic-gate 		prunlock(pnp);
26297c478bd9Sstevel@tonic-gate 		if (copyout(&un32.fltmask, cmaddr, sizeof (un32.fltmask)))
26307c478bd9Sstevel@tonic-gate 			error = EFAULT;
26317c478bd9Sstevel@tonic-gate 		break;
26327c478bd9Sstevel@tonic-gate 
26337c478bd9Sstevel@tonic-gate 	case PIOCSFAULT:	/* set mask of traced faults */
26347c478bd9Sstevel@tonic-gate 		pr_setfault(p, &un32.fltmask);
26357c478bd9Sstevel@tonic-gate 		prunlock(pnp);
26367c478bd9Sstevel@tonic-gate 		break;
26377c478bd9Sstevel@tonic-gate 
26387c478bd9Sstevel@tonic-gate 	case PIOCCFAULT:	/* clear current fault */
26397c478bd9Sstevel@tonic-gate 		lwp->lwp_curflt = 0;
26407c478bd9Sstevel@tonic-gate 		prunlock(pnp);
26417c478bd9Sstevel@tonic-gate 		break;
26427c478bd9Sstevel@tonic-gate 
26437c478bd9Sstevel@tonic-gate 	case PIOCCRED:		/* get process credentials */
26447c478bd9Sstevel@tonic-gate 	{
26457c478bd9Sstevel@tonic-gate 		cred_t *cp;
26467c478bd9Sstevel@tonic-gate 
26477c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_crlock);
26487c478bd9Sstevel@tonic-gate 		cp = p->p_cred;
26497c478bd9Sstevel@tonic-gate 		un32.prcred.pr_euid = crgetuid(cp);
26507c478bd9Sstevel@tonic-gate 		un32.prcred.pr_ruid = crgetruid(cp);
26517c478bd9Sstevel@tonic-gate 		un32.prcred.pr_suid = crgetsuid(cp);
26527c478bd9Sstevel@tonic-gate 		un32.prcred.pr_egid = crgetgid(cp);
26537c478bd9Sstevel@tonic-gate 		un32.prcred.pr_rgid = crgetrgid(cp);
26547c478bd9Sstevel@tonic-gate 		un32.prcred.pr_sgid = crgetsgid(cp);
26557c478bd9Sstevel@tonic-gate 		un32.prcred.pr_ngroups = crgetngroups(cp);
26567c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_crlock);
26577c478bd9Sstevel@tonic-gate 
26587c478bd9Sstevel@tonic-gate 		prunlock(pnp);
26597c478bd9Sstevel@tonic-gate 		if (copyout(&un32.prcred, cmaddr, sizeof (un32.prcred)))
26607c478bd9Sstevel@tonic-gate 			error = EFAULT;
26617c478bd9Sstevel@tonic-gate 		break;
26627c478bd9Sstevel@tonic-gate 	}
26637c478bd9Sstevel@tonic-gate 
26647c478bd9Sstevel@tonic-gate 	case PIOCGROUPS:	/* get supplementary groups */
26657c478bd9Sstevel@tonic-gate 	{
26667c478bd9Sstevel@tonic-gate 		cred_t *cp;
26677c478bd9Sstevel@tonic-gate 
26687c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_crlock);
26697c478bd9Sstevel@tonic-gate 		cp = p->p_cred;
26707c478bd9Sstevel@tonic-gate 		crhold(cp);
26717c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_crlock);
26727c478bd9Sstevel@tonic-gate 
26737c478bd9Sstevel@tonic-gate 		prunlock(pnp);
26747c478bd9Sstevel@tonic-gate 		if (copyout(crgetgroups(cp), cmaddr,
26757c478bd9Sstevel@tonic-gate 		    MAX(crgetngroups(cp), 1) * sizeof (gid_t)))
26767c478bd9Sstevel@tonic-gate 			error = EFAULT;
26777c478bd9Sstevel@tonic-gate 		crfree(cp);
26787c478bd9Sstevel@tonic-gate 		break;
26797c478bd9Sstevel@tonic-gate 	}
26807c478bd9Sstevel@tonic-gate 
26817c478bd9Sstevel@tonic-gate 	case PIOCUSAGE:		/* get usage info */
26827c478bd9Sstevel@tonic-gate 	{
26837c478bd9Sstevel@tonic-gate 		/*
26847c478bd9Sstevel@tonic-gate 		 * For an lwp file descriptor, return just the lwp usage.
26857c478bd9Sstevel@tonic-gate 		 * For a process file descriptor, return total usage,
26867c478bd9Sstevel@tonic-gate 		 * all current lwps plus all defunct lwps.
26877c478bd9Sstevel@tonic-gate 		 */
26887c478bd9Sstevel@tonic-gate 		prhusage_t *pup = &un32.prhusage;
26897c478bd9Sstevel@tonic-gate 		prusage32_t *upup;
26907c478bd9Sstevel@tonic-gate 
26917c478bd9Sstevel@tonic-gate 		bzero(pup, sizeof (*pup));
26927c478bd9Sstevel@tonic-gate 		pup->pr_tstamp = gethrtime();
26937c478bd9Sstevel@tonic-gate 
26947c478bd9Sstevel@tonic-gate 		if (pnp->pr_type == PR_LWPIDFILE) {
26957c478bd9Sstevel@tonic-gate 			t = pcp->prc_thread;
26967c478bd9Sstevel@tonic-gate 			if (t != NULL)
26977c478bd9Sstevel@tonic-gate 				prgetusage(t, pup);
26987c478bd9Sstevel@tonic-gate 			else
26997c478bd9Sstevel@tonic-gate 				error = ENOENT;
27007c478bd9Sstevel@tonic-gate 		} else {
27017c478bd9Sstevel@tonic-gate 			pup->pr_count  = p->p_defunct;
27027c478bd9Sstevel@tonic-gate 			pup->pr_create = p->p_mstart;
27037c478bd9Sstevel@tonic-gate 			pup->pr_term   = p->p_mterm;
27047c478bd9Sstevel@tonic-gate 
27057c478bd9Sstevel@tonic-gate 			pup->pr_rtime    = p->p_mlreal;
27067c478bd9Sstevel@tonic-gate 			pup->pr_utime    = p->p_acct[LMS_USER];
27077c478bd9Sstevel@tonic-gate 			pup->pr_stime    = p->p_acct[LMS_SYSTEM];
27087c478bd9Sstevel@tonic-gate 			pup->pr_ttime    = p->p_acct[LMS_TRAP];
27097c478bd9Sstevel@tonic-gate 			pup->pr_tftime   = p->p_acct[LMS_TFAULT];
27107c478bd9Sstevel@tonic-gate 			pup->pr_dftime   = p->p_acct[LMS_DFAULT];
27117c478bd9Sstevel@tonic-gate 			pup->pr_kftime   = p->p_acct[LMS_KFAULT];
27127c478bd9Sstevel@tonic-gate 			pup->pr_ltime    = p->p_acct[LMS_USER_LOCK];
27137c478bd9Sstevel@tonic-gate 			pup->pr_slptime  = p->p_acct[LMS_SLEEP];
27147c478bd9Sstevel@tonic-gate 			pup->pr_wtime    = p->p_acct[LMS_WAIT_CPU];
27157c478bd9Sstevel@tonic-gate 			pup->pr_stoptime = p->p_acct[LMS_STOPPED];
27167c478bd9Sstevel@tonic-gate 
27177c478bd9Sstevel@tonic-gate 			pup->pr_minf  = p->p_ru.minflt;
27187c478bd9Sstevel@tonic-gate 			pup->pr_majf  = p->p_ru.majflt;
27197c478bd9Sstevel@tonic-gate 			pup->pr_nswap = p->p_ru.nswap;
27207c478bd9Sstevel@tonic-gate 			pup->pr_inblk = p->p_ru.inblock;
27217c478bd9Sstevel@tonic-gate 			pup->pr_oublk = p->p_ru.oublock;
27227c478bd9Sstevel@tonic-gate 			pup->pr_msnd  = p->p_ru.msgsnd;
27237c478bd9Sstevel@tonic-gate 			pup->pr_mrcv  = p->p_ru.msgrcv;
27247c478bd9Sstevel@tonic-gate 			pup->pr_sigs  = p->p_ru.nsignals;
27257c478bd9Sstevel@tonic-gate 			pup->pr_vctx  = p->p_ru.nvcsw;
27267c478bd9Sstevel@tonic-gate 			pup->pr_ictx  = p->p_ru.nivcsw;
27277c478bd9Sstevel@tonic-gate 			pup->pr_sysc  = p->p_ru.sysc;
27287c478bd9Sstevel@tonic-gate 			pup->pr_ioch  = p->p_ru.ioch;
27297c478bd9Sstevel@tonic-gate 
27307c478bd9Sstevel@tonic-gate 			/*
27317c478bd9Sstevel@tonic-gate 			 * Add the usage information for each active lwp.
27327c478bd9Sstevel@tonic-gate 			 */
27337c478bd9Sstevel@tonic-gate 			if ((t = p->p_tlist) != NULL &&
27347c478bd9Sstevel@tonic-gate 			    !(pcp->prc_flags & PRC_DESTROY)) {
27357c478bd9Sstevel@tonic-gate 				do {
27367c478bd9Sstevel@tonic-gate 					ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
27377c478bd9Sstevel@tonic-gate 					pup->pr_count++;
27387c478bd9Sstevel@tonic-gate 					praddusage(t, pup);
27397c478bd9Sstevel@tonic-gate 				} while ((t = t->t_forw) != p->p_tlist);
27407c478bd9Sstevel@tonic-gate 			}
27417c478bd9Sstevel@tonic-gate 		}
27427c478bd9Sstevel@tonic-gate 
27437c478bd9Sstevel@tonic-gate 		prunlock(pnp);
27447c478bd9Sstevel@tonic-gate 
27457c478bd9Sstevel@tonic-gate 		upup = kmem_alloc(sizeof (*upup), KM_SLEEP);
27467c478bd9Sstevel@tonic-gate 		prcvtusage32(pup, upup);
27477c478bd9Sstevel@tonic-gate 		if (copyout(upup, cmaddr, sizeof (*upup)))
27487c478bd9Sstevel@tonic-gate 			error = EFAULT;
27497c478bd9Sstevel@tonic-gate 		kmem_free(upup, sizeof (*upup));
27507c478bd9Sstevel@tonic-gate 
27517c478bd9Sstevel@tonic-gate 		break;
27527c478bd9Sstevel@tonic-gate 	}
27537c478bd9Sstevel@tonic-gate 
27547c478bd9Sstevel@tonic-gate 	case PIOCLUSAGE:	/* get detailed usage info */
27557c478bd9Sstevel@tonic-gate 	{
27567c478bd9Sstevel@tonic-gate 		int Nlwp;
27577c478bd9Sstevel@tonic-gate 		int nlwp;
27587c478bd9Sstevel@tonic-gate 		prusage32_t *upup;
27597c478bd9Sstevel@tonic-gate 		prusage32_t *Bupup;
27607c478bd9Sstevel@tonic-gate 		prhusage_t *pup;
27617c478bd9Sstevel@tonic-gate 		hrtime_t curtime;
27627c478bd9Sstevel@tonic-gate 
27637c478bd9Sstevel@tonic-gate 		nlwp = Nlwp = (pcp->prc_flags & PRC_DESTROY)? 0 : p->p_lwpcnt;
27647c478bd9Sstevel@tonic-gate 
27657c478bd9Sstevel@tonic-gate 		if (thing && thingsize !=
27667c478bd9Sstevel@tonic-gate 		    sizeof (prhusage_t) + (Nlwp+1) * sizeof (prusage32_t)) {
27677c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
27687c478bd9Sstevel@tonic-gate 			thing = NULL;
27697c478bd9Sstevel@tonic-gate 		}
27707c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
27717c478bd9Sstevel@tonic-gate 			thingsize = sizeof (prhusage_t) +
27727c478bd9Sstevel@tonic-gate 			    (Nlwp+1) * sizeof (prusage32_t);
27737c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
27747c478bd9Sstevel@tonic-gate 		}
27757c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
27767c478bd9Sstevel@tonic-gate 			prunlock(pnp);
27777c478bd9Sstevel@tonic-gate 			goto startover;
27787c478bd9Sstevel@tonic-gate 		}
27797c478bd9Sstevel@tonic-gate 
27807c478bd9Sstevel@tonic-gate 		pup = (prhusage_t *)thing;
27817c478bd9Sstevel@tonic-gate 		upup = Bupup = (prusage32_t *)(pup + 1);
27827c478bd9Sstevel@tonic-gate 
27837c478bd9Sstevel@tonic-gate 		ASSERT(p == pcp->prc_proc);
27847c478bd9Sstevel@tonic-gate 
27857c478bd9Sstevel@tonic-gate 		curtime = gethrtime();
27867c478bd9Sstevel@tonic-gate 
27877c478bd9Sstevel@tonic-gate 		/*
27887c478bd9Sstevel@tonic-gate 		 * First the summation over defunct lwps.
27897c478bd9Sstevel@tonic-gate 		 */
27907c478bd9Sstevel@tonic-gate 		bzero(pup, sizeof (*pup));
27917c478bd9Sstevel@tonic-gate 		pup->pr_count  = p->p_defunct;
27927c478bd9Sstevel@tonic-gate 		pup->pr_tstamp = curtime;
27937c478bd9Sstevel@tonic-gate 		pup->pr_create = p->p_mstart;
27947c478bd9Sstevel@tonic-gate 		pup->pr_term   = p->p_mterm;
27957c478bd9Sstevel@tonic-gate 
27967c478bd9Sstevel@tonic-gate 		pup->pr_rtime    = p->p_mlreal;
27977c478bd9Sstevel@tonic-gate 		pup->pr_utime    = p->p_acct[LMS_USER];
27987c478bd9Sstevel@tonic-gate 		pup->pr_stime    = p->p_acct[LMS_SYSTEM];
27997c478bd9Sstevel@tonic-gate 		pup->pr_ttime    = p->p_acct[LMS_TRAP];
28007c478bd9Sstevel@tonic-gate 		pup->pr_tftime   = p->p_acct[LMS_TFAULT];
28017c478bd9Sstevel@tonic-gate 		pup->pr_dftime   = p->p_acct[LMS_DFAULT];
28027c478bd9Sstevel@tonic-gate 		pup->pr_kftime   = p->p_acct[LMS_KFAULT];
28037c478bd9Sstevel@tonic-gate 		pup->pr_ltime    = p->p_acct[LMS_USER_LOCK];
28047c478bd9Sstevel@tonic-gate 		pup->pr_slptime  = p->p_acct[LMS_SLEEP];
28057c478bd9Sstevel@tonic-gate 		pup->pr_wtime    = p->p_acct[LMS_WAIT_CPU];
28067c478bd9Sstevel@tonic-gate 		pup->pr_stoptime = p->p_acct[LMS_STOPPED];
28077c478bd9Sstevel@tonic-gate 
28087c478bd9Sstevel@tonic-gate 		pup->pr_minf  = p->p_ru.minflt;
28097c478bd9Sstevel@tonic-gate 		pup->pr_majf  = p->p_ru.majflt;
28107c478bd9Sstevel@tonic-gate 		pup->pr_nswap = p->p_ru.nswap;
28117c478bd9Sstevel@tonic-gate 		pup->pr_inblk = p->p_ru.inblock;
28127c478bd9Sstevel@tonic-gate 		pup->pr_oublk = p->p_ru.oublock;
28137c478bd9Sstevel@tonic-gate 		pup->pr_msnd  = p->p_ru.msgsnd;
28147c478bd9Sstevel@tonic-gate 		pup->pr_mrcv  = p->p_ru.msgrcv;
28157c478bd9Sstevel@tonic-gate 		pup->pr_sigs  = p->p_ru.nsignals;
28167c478bd9Sstevel@tonic-gate 		pup->pr_vctx  = p->p_ru.nvcsw;
28177c478bd9Sstevel@tonic-gate 		pup->pr_ictx  = p->p_ru.nivcsw;
28187c478bd9Sstevel@tonic-gate 		pup->pr_sysc  = p->p_ru.sysc;
28197c478bd9Sstevel@tonic-gate 		pup->pr_ioch  = p->p_ru.ioch;
28207c478bd9Sstevel@tonic-gate 
28217c478bd9Sstevel@tonic-gate 		prcvtusage32(pup, upup);
28227c478bd9Sstevel@tonic-gate 
28237c478bd9Sstevel@tonic-gate 		/*
28247c478bd9Sstevel@tonic-gate 		 * Fill one prusage struct for each active lwp.
28257c478bd9Sstevel@tonic-gate 		 */
28267c478bd9Sstevel@tonic-gate 		if ((t = p->p_tlist) != NULL &&
28277c478bd9Sstevel@tonic-gate 		    !(pcp->prc_flags & PRC_DESTROY)) {
28287c478bd9Sstevel@tonic-gate 			do {
28297c478bd9Sstevel@tonic-gate 				ASSERT(!(t->t_proc_flag & TP_LWPEXIT));
28307c478bd9Sstevel@tonic-gate 				ASSERT(nlwp > 0);
28317c478bd9Sstevel@tonic-gate 				--nlwp;
28327c478bd9Sstevel@tonic-gate 				upup++;
28337c478bd9Sstevel@tonic-gate 				prgetusage(t, pup);
28347c478bd9Sstevel@tonic-gate 				prcvtusage32(pup, upup);
28357c478bd9Sstevel@tonic-gate 			} while ((t = t->t_forw) != p->p_tlist);
28367c478bd9Sstevel@tonic-gate 		}
28377c478bd9Sstevel@tonic-gate 		ASSERT(nlwp == 0);
28387c478bd9Sstevel@tonic-gate 
28397c478bd9Sstevel@tonic-gate 		prunlock(pnp);
28407c478bd9Sstevel@tonic-gate 		if (copyout(Bupup, cmaddr, (Nlwp+1) * sizeof (prusage32_t)))
28417c478bd9Sstevel@tonic-gate 			error = EFAULT;
28427c478bd9Sstevel@tonic-gate 		kmem_free(thing, thingsize);
28437c478bd9Sstevel@tonic-gate 		thing = NULL;
28447c478bd9Sstevel@tonic-gate 		break;
28457c478bd9Sstevel@tonic-gate 	}
28467c478bd9Sstevel@tonic-gate 
28477c478bd9Sstevel@tonic-gate 	case PIOCNAUXV:		/* get number of aux vector entries */
28487c478bd9Sstevel@tonic-gate 	{
28497c478bd9Sstevel@tonic-gate 		int n = __KERN_NAUXV_IMPL;
28507c478bd9Sstevel@tonic-gate 
28517c478bd9Sstevel@tonic-gate 		prunlock(pnp);
28527c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (int)))
28537c478bd9Sstevel@tonic-gate 			error = EFAULT;
28547c478bd9Sstevel@tonic-gate 		break;
28557c478bd9Sstevel@tonic-gate 	}
28567c478bd9Sstevel@tonic-gate 
28577c478bd9Sstevel@tonic-gate 	case PIOCAUXV:		/* get aux vector (see sys/auxv.h) */
28587c478bd9Sstevel@tonic-gate 	{
28597c478bd9Sstevel@tonic-gate 		int i;
28607c478bd9Sstevel@tonic-gate 
28617c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p)) {
28627c478bd9Sstevel@tonic-gate 			prunlock(pnp);
28637c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
28647c478bd9Sstevel@tonic-gate 		} else {
28657c478bd9Sstevel@tonic-gate 			up = PTOU(p);
28667c478bd9Sstevel@tonic-gate 			for (i = 0; i < __KERN_NAUXV_IMPL; i++) {
28677c478bd9Sstevel@tonic-gate 				un32.auxv[i].a_type = up->u_auxv[i].a_type;
28687c478bd9Sstevel@tonic-gate 				un32.auxv[i].a_un.a_val =
286925b463cdSethindra 				    (int32_t)up->u_auxv[i].a_un.a_val;
28707c478bd9Sstevel@tonic-gate 			}
28717c478bd9Sstevel@tonic-gate 			prunlock(pnp);
28727c478bd9Sstevel@tonic-gate 			if (copyout(un32.auxv, cmaddr,
28737c478bd9Sstevel@tonic-gate 			    __KERN_NAUXV_IMPL * sizeof (auxv32_t)))
28747c478bd9Sstevel@tonic-gate 				error = EFAULT;
28757c478bd9Sstevel@tonic-gate 		}
28767c478bd9Sstevel@tonic-gate 		break;
28777c478bd9Sstevel@tonic-gate 	}
28787c478bd9Sstevel@tonic-gate 
28797c478bd9Sstevel@tonic-gate #if defined(__i386) || defined(__i386_COMPAT)
28807c478bd9Sstevel@tonic-gate 	case PIOCNLDT:		/* get number of LDT entries */
28817c478bd9Sstevel@tonic-gate 	{
28827c478bd9Sstevel@tonic-gate 		int n;
28837c478bd9Sstevel@tonic-gate 
28846e092be7SVamsi Nagineni 		mutex_exit(&p->p_lock);
28857c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_ldtlock);
28867c478bd9Sstevel@tonic-gate 		n = prnldt(p);
28877c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_ldtlock);
28886e092be7SVamsi Nagineni 		mutex_enter(&p->p_lock);
28897c478bd9Sstevel@tonic-gate 		prunlock(pnp);
28907c478bd9Sstevel@tonic-gate 		if (copyout(&n, cmaddr, sizeof (n)))
28917c478bd9Sstevel@tonic-gate 			error = EFAULT;
28927c478bd9Sstevel@tonic-gate 		break;
28937c478bd9Sstevel@tonic-gate 	}
28947c478bd9Sstevel@tonic-gate 
28957c478bd9Sstevel@tonic-gate 	case PIOCLDT:		/* get LDT entries */
28967c478bd9Sstevel@tonic-gate 	{
28977c478bd9Sstevel@tonic-gate 		struct ssd *ssd;
28987c478bd9Sstevel@tonic-gate 		int n;
28997c478bd9Sstevel@tonic-gate 
29006e092be7SVamsi Nagineni 		mutex_exit(&p->p_lock);
29017c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_ldtlock);
29027c478bd9Sstevel@tonic-gate 		n = prnldt(p);
29037c478bd9Sstevel@tonic-gate 
29047c478bd9Sstevel@tonic-gate 		if (thing && thingsize != (n+1) * sizeof (*ssd)) {
29057c478bd9Sstevel@tonic-gate 			kmem_free(thing, thingsize);
29067c478bd9Sstevel@tonic-gate 			thing = NULL;
29077c478bd9Sstevel@tonic-gate 		}
29087c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
29097c478bd9Sstevel@tonic-gate 			thingsize = (n+1) * sizeof (*ssd);
29107c478bd9Sstevel@tonic-gate 			thing = kmem_alloc(thingsize, KM_NOSLEEP);
29117c478bd9Sstevel@tonic-gate 		}
29127c478bd9Sstevel@tonic-gate 		if (thing == NULL) {
29137c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_ldtlock);
29146e092be7SVamsi Nagineni 			mutex_enter(&p->p_lock);
29157c478bd9Sstevel@tonic-gate 			prunlock(pnp);
29167c478bd9Sstevel@tonic-gate 			goto startover;
29177c478bd9Sstevel@tonic-gate 		}
29187c478bd9Sstevel@tonic-gate 
29197c478bd9Sstevel@tonic-gate 		ssd = thing;
29207c478bd9Sstevel@tonic-gate 		thing = NULL;
29217c478bd9Sstevel@tonic-gate 		if (n != 0)
29227c478bd9Sstevel@tonic-gate 			prgetldt(p, ssd);
29237c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_ldtlock);
29246e092be7SVamsi Nagineni 		mutex_enter(&p->p_lock);
29257c478bd9Sstevel@tonic-gate 		prunlock(pnp);
29267c478bd9Sstevel@tonic-gate 
29277c478bd9Sstevel@tonic-gate 		/* mark the end of the list with a null entry */
29287c478bd9Sstevel@tonic-gate 		bzero(&ssd[n], sizeof (*ssd));
29297c478bd9Sstevel@tonic-gate 		if (copyout(ssd, cmaddr, (n+1) * sizeof (*ssd)))
29307c478bd9Sstevel@tonic-gate 			error = EFAULT;
29317c478bd9Sstevel@tonic-gate 		kmem_free(ssd, (n+1) * sizeof (*ssd));
29327c478bd9Sstevel@tonic-gate 		break;
29337c478bd9Sstevel@tonic-gate 	}
29347c478bd9Sstevel@tonic-gate #endif	/* __i386 || __i386_COMPAT */
29357c478bd9Sstevel@tonic-gate 
29367c478bd9Sstevel@tonic-gate #if defined(__sparc)
29377c478bd9Sstevel@tonic-gate 	case PIOCGWIN:		/* get gwindows_t (see sys/reg.h) */
29387c478bd9Sstevel@tonic-gate 	{
29397c478bd9Sstevel@tonic-gate 		gwindows32_t *gwp = thing;
29407c478bd9Sstevel@tonic-gate 
29417c478bd9Sstevel@tonic-gate 		if (PROCESS_NOT_32BIT(p)) {
29427c478bd9Sstevel@tonic-gate 			prunlock(pnp);
29437c478bd9Sstevel@tonic-gate 			error = EOVERFLOW;
29447c478bd9Sstevel@tonic-gate 		} else {
29457c478bd9Sstevel@tonic-gate 			/* drop p->p_lock while touching the stack */
29467c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
29477c478bd9Sstevel@tonic-gate 			bzero(gwp, sizeof (*gwp));
29487c478bd9Sstevel@tonic-gate 			prgetwindows32(lwp, gwp);
29497c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
29507c478bd9Sstevel@tonic-gate 			prunlock(pnp);
29517c478bd9Sstevel@tonic-gate 			if (copyout(gwp, cmaddr, sizeof (*gwp)))
29527c478bd9Sstevel@tonic-gate 				error = EFAULT;
29537c478bd9Sstevel@tonic-gate 		}
29547c478bd9Sstevel@tonic-gate 		kmem_free(gwp, sizeof (*gwp));
29557c478bd9Sstevel@tonic-gate 		thing = NULL;
29567c478bd9Sstevel@tonic-gate 		break;
29577c478bd9Sstevel@tonic-gate 	}
29587c478bd9Sstevel@tonic-gate #endif	/* __sparc */
29597c478bd9Sstevel@tonic-gate 
29607c478bd9Sstevel@tonic-gate 	default:
29617c478bd9Sstevel@tonic-gate 		prunlock(pnp);
29627c478bd9Sstevel@tonic-gate 		error = EINVAL;
29637c478bd9Sstevel@tonic-gate 		break;
29647c478bd9Sstevel@tonic-gate 
29657c478bd9Sstevel@tonic-gate 	}
29667c478bd9Sstevel@tonic-gate 
29677c478bd9Sstevel@tonic-gate 	ASSERT(thing == NULL);
29687c478bd9Sstevel@tonic-gate 	ASSERT(xpnp == NULL);
29697c478bd9Sstevel@tonic-gate 	return (error);
29707c478bd9Sstevel@tonic-gate }
29717c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
29727c478bd9Sstevel@tonic-gate 
29737c478bd9Sstevel@tonic-gate /*
29747c478bd9Sstevel@tonic-gate  * Distinguish "writeable" ioctl requests from others.
29757c478bd9Sstevel@tonic-gate  */
29767c478bd9Sstevel@tonic-gate static int
29777c478bd9Sstevel@tonic-gate isprwrioctl(int cmd)
29787c478bd9Sstevel@tonic-gate {
29797c478bd9Sstevel@tonic-gate 	switch (cmd) {
29807c478bd9Sstevel@tonic-gate 	case PIOCSTOP:
29817c478bd9Sstevel@tonic-gate 	case PIOCRUN:
29827c478bd9Sstevel@tonic-gate 	case PIOCSTRACE:
29837c478bd9Sstevel@tonic-gate 	case PIOCSSIG:
29847c478bd9Sstevel@tonic-gate 	case PIOCKILL:
29857c478bd9Sstevel@tonic-gate 	case PIOCUNKILL:
29867c478bd9Sstevel@tonic-gate 	case PIOCNICE:
29877c478bd9Sstevel@tonic-gate 	case PIOCSENTRY:
29887c478bd9Sstevel@tonic-gate 	case PIOCSEXIT:
29897c478bd9Sstevel@tonic-gate 	case PIOCSRLC:
29907c478bd9Sstevel@tonic-gate 	case PIOCRRLC:
29917c478bd9Sstevel@tonic-gate 	case PIOCSREG:
29927c478bd9Sstevel@tonic-gate 	case PIOCSFPREG:
29937c478bd9Sstevel@tonic-gate 	case PIOCSXREG:
29947c478bd9Sstevel@tonic-gate 	case PIOCSHOLD:
29957c478bd9Sstevel@tonic-gate 	case PIOCSFAULT:
29967c478bd9Sstevel@tonic-gate 	case PIOCCFAULT:
29977c478bd9Sstevel@tonic-gate 	case PIOCSFORK:
29987c478bd9Sstevel@tonic-gate 	case PIOCRFORK:
29997c478bd9Sstevel@tonic-gate 	case PIOCSET:
30007c478bd9Sstevel@tonic-gate 	case PIOCRESET:
30017c478bd9Sstevel@tonic-gate 		return (1);
30027c478bd9Sstevel@tonic-gate 	}
30037c478bd9Sstevel@tonic-gate 	return (0);
30047c478bd9Sstevel@tonic-gate }
30057c478bd9Sstevel@tonic-gate 
30067c478bd9Sstevel@tonic-gate /*
30077c478bd9Sstevel@tonic-gate  * Map the ioctl() interface run flags to the new interface run flags.
30087c478bd9Sstevel@tonic-gate  */
30097c478bd9Sstevel@tonic-gate static ulong_t
30107c478bd9Sstevel@tonic-gate prmaprunflags(long flags)
30117c478bd9Sstevel@tonic-gate {
30127c478bd9Sstevel@tonic-gate 	ulong_t newflags = 0;
30137c478bd9Sstevel@tonic-gate 
30147c478bd9Sstevel@tonic-gate 	if (flags & PRCSIG)
30157c478bd9Sstevel@tonic-gate 		newflags |= 0x01;
30167c478bd9Sstevel@tonic-gate 	if (flags & PRCFAULT)
30177c478bd9Sstevel@tonic-gate 		newflags |= 0x02;
30187c478bd9Sstevel@tonic-gate 	if (flags & PRSTEP)
30197c478bd9Sstevel@tonic-gate 		newflags |= 0x04;
30207c478bd9Sstevel@tonic-gate 	if (flags & PRSABORT)
30217c478bd9Sstevel@tonic-gate 		newflags |= 0x08;
30227c478bd9Sstevel@tonic-gate 	if (flags & PRSTOP)
30237c478bd9Sstevel@tonic-gate 		newflags |= 0x10;
30247c478bd9Sstevel@tonic-gate 	return (newflags);
30257c478bd9Sstevel@tonic-gate }
30267c478bd9Sstevel@tonic-gate 
30277c478bd9Sstevel@tonic-gate /*
30287c478bd9Sstevel@tonic-gate  * Map the ioctl() interface settable mode flags to the new interface flags.
30297c478bd9Sstevel@tonic-gate  */
30307c478bd9Sstevel@tonic-gate static long
30317c478bd9Sstevel@tonic-gate prmapsetflags(long flags)
30327c478bd9Sstevel@tonic-gate {
30337c478bd9Sstevel@tonic-gate 	long newflags = 0;
30347c478bd9Sstevel@tonic-gate 
30357c478bd9Sstevel@tonic-gate #define	ALLFLAGS	\
30367c478bd9Sstevel@tonic-gate 	(PR_FORK|PR_RLC|PR_KLC|PR_ASYNC|PR_BPTADJ|PR_MSACCT|PR_PCOMPAT)
30377c478bd9Sstevel@tonic-gate 
30387c478bd9Sstevel@tonic-gate 	if (flags & ~ALLFLAGS)
30397c478bd9Sstevel@tonic-gate 		newflags = 0xffff;	/* forces EINVAL */
30407c478bd9Sstevel@tonic-gate 	if (flags & PR_FORK)
30417c478bd9Sstevel@tonic-gate 		newflags |= (0x00100000 | 0x08000000);
30427c478bd9Sstevel@tonic-gate 	if (flags & PR_RLC)
30437c478bd9Sstevel@tonic-gate 		newflags |= 0x00200000;
30447c478bd9Sstevel@tonic-gate 	if (flags & PR_KLC)
30457c478bd9Sstevel@tonic-gate 		newflags |= 0x00400000;
30467c478bd9Sstevel@tonic-gate 	if (flags & PR_ASYNC)
30477c478bd9Sstevel@tonic-gate 		newflags |= 0x00800000;
30487c478bd9Sstevel@tonic-gate 	if (flags & PR_MSACCT)
30497c478bd9Sstevel@tonic-gate 		newflags |= 0x01000000;
30507c478bd9Sstevel@tonic-gate 	if (flags & PR_BPTADJ)
30517c478bd9Sstevel@tonic-gate 		newflags |= 0x02000000;
30527c478bd9Sstevel@tonic-gate 	if (flags & PR_PCOMPAT)
30537c478bd9Sstevel@tonic-gate 		newflags |= 0x04000000;
30547c478bd9Sstevel@tonic-gate 	return (newflags);
30557c478bd9Sstevel@tonic-gate }
30567c478bd9Sstevel@tonic-gate 
30577c478bd9Sstevel@tonic-gate /*
30587c478bd9Sstevel@tonic-gate  * Apply PIOCRUN options specific to the ioctl() interface.
30597c478bd9Sstevel@tonic-gate  */
30607c478bd9Sstevel@tonic-gate static void
30617c478bd9Sstevel@tonic-gate prsetrun(kthread_t *t, prrun_t *prp)
30627c478bd9Sstevel@tonic-gate {
30637c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
30647c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
30657c478bd9Sstevel@tonic-gate 	long flags = prp->pr_flags;
30667c478bd9Sstevel@tonic-gate 	user_t *up = PTOU(p);
30677c478bd9Sstevel@tonic-gate 
30687c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
30697c478bd9Sstevel@tonic-gate 
30707c478bd9Sstevel@tonic-gate 	if (flags & PRSHOLD) {
30717c478bd9Sstevel@tonic-gate 		schedctl_finish_sigblock(t);
30727c478bd9Sstevel@tonic-gate 		sigutok(&prp->pr_sighold, &t->t_hold);
30737c478bd9Sstevel@tonic-gate 		t->t_sig_check = 1;	/* so ISSIG will be done */
30747c478bd9Sstevel@tonic-gate 	}
30757c478bd9Sstevel@tonic-gate 	if (flags & PRSTRACE) {
30767c478bd9Sstevel@tonic-gate 		prdelset(&prp->pr_trace, SIGKILL);
30777c478bd9Sstevel@tonic-gate 		prassignset(&p->p_sigmask, &prp->pr_trace);
30787c478bd9Sstevel@tonic-gate 		if (!sigisempty(&p->p_sigmask))
30797c478bd9Sstevel@tonic-gate 			p->p_proc_flag |= P_PR_TRACE;
30807c478bd9Sstevel@tonic-gate 		else if (prisempty(&p->p_fltmask)) {
30817c478bd9Sstevel@tonic-gate 			if (up->u_systrap == 0)
30827c478bd9Sstevel@tonic-gate 				p->p_proc_flag &= ~P_PR_TRACE;
30837c478bd9Sstevel@tonic-gate 		}
30847c478bd9Sstevel@tonic-gate 	}
30857c478bd9Sstevel@tonic-gate 	if (flags & PRSFAULT) {
30867c478bd9Sstevel@tonic-gate 		prassignset(&p->p_fltmask, &prp->pr_fault);
30877c478bd9Sstevel@tonic-gate 		if (!prisempty(&p->p_fltmask))
30887c478bd9Sstevel@tonic-gate 			p->p_proc_flag |= P_PR_TRACE;
30897c478bd9Sstevel@tonic-gate 		else if (sigisempty(&p->p_sigmask)) {
30907c478bd9Sstevel@tonic-gate 			if (up->u_systrap == 0)
30917c478bd9Sstevel@tonic-gate 				p->p_proc_flag &= ~P_PR_TRACE;
30927c478bd9Sstevel@tonic-gate 		}
30937c478bd9Sstevel@tonic-gate 	}
30947c478bd9Sstevel@tonic-gate 	/*
30957c478bd9Sstevel@tonic-gate 	 * prsvaddr() must be called before prstep() because
30967c478bd9Sstevel@tonic-gate 	 * stepping can depend on the current value of the PC.
30977c478bd9Sstevel@tonic-gate 	 * We drop p_lock while touching the lwp's registers (on stack).
30987c478bd9Sstevel@tonic-gate 	 */
30997c478bd9Sstevel@tonic-gate 	if (flags & PRSVADDR) {
31007c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
31017c478bd9Sstevel@tonic-gate 		prsvaddr(lwp, prp->pr_vaddr);
31027c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_lock);
31037c478bd9Sstevel@tonic-gate 	}
31047c478bd9Sstevel@tonic-gate }
31057c478bd9Sstevel@tonic-gate 
31067c478bd9Sstevel@tonic-gate /*
31077c478bd9Sstevel@tonic-gate  * Common code for PIOCOPENM
31087c478bd9Sstevel@tonic-gate  * Returns with the process unlocked.
31097c478bd9Sstevel@tonic-gate  */
31107c478bd9Sstevel@tonic-gate static int
31117c478bd9Sstevel@tonic-gate propenm(prnode_t *pnp, caddr_t cmaddr, caddr_t va, int *rvalp, cred_t *cr)
31127c478bd9Sstevel@tonic-gate {
31137c478bd9Sstevel@tonic-gate 	proc_t *p = pnp->pr_common->prc_proc;
31147c478bd9Sstevel@tonic-gate 	struct as *as = p->p_as;
31157c478bd9Sstevel@tonic-gate 	int error = 0;
31167c478bd9Sstevel@tonic-gate 	struct seg *seg;
31177c478bd9Sstevel@tonic-gate 	struct vnode *xvp;
31187c478bd9Sstevel@tonic-gate 	int n;
31197c478bd9Sstevel@tonic-gate 
31207c478bd9Sstevel@tonic-gate 	/*
31217c478bd9Sstevel@tonic-gate 	 * By fiat, a system process has no address space.
31227c478bd9Sstevel@tonic-gate 	 */
31237c478bd9Sstevel@tonic-gate 	if ((p->p_flag & SSYS) || as == &kas) {
31247c478bd9Sstevel@tonic-gate 		error = EINVAL;
31257c478bd9Sstevel@tonic-gate 	} else if (cmaddr) {
31267c478bd9Sstevel@tonic-gate 		/*
31277c478bd9Sstevel@tonic-gate 		 * We drop p_lock before grabbing the address
31287c478bd9Sstevel@tonic-gate 		 * space lock in order to avoid a deadlock with
31297c478bd9Sstevel@tonic-gate 		 * the clock thread.  The process will not
31307c478bd9Sstevel@tonic-gate 		 * disappear and its address space will not
31317c478bd9Sstevel@tonic-gate 		 * change because it is marked P_PR_LOCK.
31327c478bd9Sstevel@tonic-gate 		 */
31337c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
3134dc32d872SJosef 'Jeff' Sipek 		AS_LOCK_ENTER(as, RW_READER);
31357c478bd9Sstevel@tonic-gate 		seg = as_segat(as, va);
31367c478bd9Sstevel@tonic-gate 		if (seg != NULL &&
31377c478bd9Sstevel@tonic-gate 		    seg->s_ops == &segvn_ops &&
31387c478bd9Sstevel@tonic-gate 		    SEGOP_GETVP(seg, va, &xvp) == 0 &&
31397c478bd9Sstevel@tonic-gate 		    xvp != NULL &&
31407c478bd9Sstevel@tonic-gate 		    xvp->v_type == VREG) {
31417c478bd9Sstevel@tonic-gate 			VN_HOLD(xvp);
31427c478bd9Sstevel@tonic-gate 		} else {
31437c478bd9Sstevel@tonic-gate 			error = EINVAL;
31447c478bd9Sstevel@tonic-gate 		}
3145dc32d872SJosef 'Jeff' Sipek 		AS_LOCK_EXIT(as);
31467c478bd9Sstevel@tonic-gate 		mutex_enter(&p->p_lock);
31477c478bd9Sstevel@tonic-gate 	} else if ((xvp = p->p_exec) == NULL) {
31487c478bd9Sstevel@tonic-gate 		error = EINVAL;
31497c478bd9Sstevel@tonic-gate 	} else {
31507c478bd9Sstevel@tonic-gate 		VN_HOLD(xvp);
31517c478bd9Sstevel@tonic-gate 	}
31527c478bd9Sstevel@tonic-gate 
31537c478bd9Sstevel@tonic-gate 	prunlock(pnp);
31547c478bd9Sstevel@tonic-gate 
31557c478bd9Sstevel@tonic-gate 	if (error == 0) {
3156da6c28aaSamw 		if ((error = VOP_ACCESS(xvp, VREAD, 0, cr, NULL)) == 0)
31577c478bd9Sstevel@tonic-gate 			error = fassign(&xvp, FREAD, &n);
31587c478bd9Sstevel@tonic-gate 		if (error) {
31597c478bd9Sstevel@tonic-gate 			VN_RELE(xvp);
31607c478bd9Sstevel@tonic-gate 		} else {
31617c478bd9Sstevel@tonic-gate 			*rvalp = n;
31627c478bd9Sstevel@tonic-gate 		}
31637c478bd9Sstevel@tonic-gate 	}
31647c478bd9Sstevel@tonic-gate 
31657c478bd9Sstevel@tonic-gate 	return (error);
31667c478bd9Sstevel@tonic-gate }
31677c478bd9Sstevel@tonic-gate 
31687c478bd9Sstevel@tonic-gate /*
31697c478bd9Sstevel@tonic-gate  * Return old version of process/lwp status.
31707c478bd9Sstevel@tonic-gate  * The u-block is mapped in by this routine and unmapped at the end.
31717c478bd9Sstevel@tonic-gate  */
31727c478bd9Sstevel@tonic-gate void
31737c478bd9Sstevel@tonic-gate oprgetstatus(kthread_t *t, prstatus_t *sp, zone_t *zp)
31747c478bd9Sstevel@tonic-gate {
31757c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(t);
31767c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(t);
31777c478bd9Sstevel@tonic-gate 	int flags;
31787c478bd9Sstevel@tonic-gate 	user_t *up;
31797c478bd9Sstevel@tonic-gate 	ulong_t instr;
31807c478bd9Sstevel@tonic-gate 
31817c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
31827c478bd9Sstevel@tonic-gate 
31837c478bd9Sstevel@tonic-gate 	up = PTOU(p);
31847c478bd9Sstevel@tonic-gate 	bzero(sp, sizeof (*sp));
31857c478bd9Sstevel@tonic-gate 	flags = 0;
31867c478bd9Sstevel@tonic-gate 	if (t->t_state == TS_STOPPED) {
31877c478bd9Sstevel@tonic-gate 		flags |= PR_STOPPED;
31887c478bd9Sstevel@tonic-gate 		if ((t->t_schedflag & TS_PSTART) == 0)
31897c478bd9Sstevel@tonic-gate 			flags |= PR_ISTOP;
31907c478bd9Sstevel@tonic-gate 	} else if (VSTOPPED(t)) {
31917c478bd9Sstevel@tonic-gate 		flags |= PR_STOPPED|PR_ISTOP;
31927c478bd9Sstevel@tonic-gate 	}
31937c478bd9Sstevel@tonic-gate 	if (!(flags & PR_ISTOP) && (t->t_proc_flag & TP_PRSTOP))
31947c478bd9Sstevel@tonic-gate 		flags |= PR_DSTOP;
31957c478bd9Sstevel@tonic-gate 	if (lwp->lwp_asleep)
31967c478bd9Sstevel@tonic-gate 		flags |= PR_ASLEEP;
31977c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_FORK)
31987c478bd9Sstevel@tonic-gate 		flags |= PR_FORK;
31997c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_RUNLCL)
32007c478bd9Sstevel@tonic-gate 		flags |= PR_RLC;
32017c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_KILLCL)
32027c478bd9Sstevel@tonic-gate 		flags |= PR_KLC;
32037c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_ASYNC)
32047c478bd9Sstevel@tonic-gate 		flags |= PR_ASYNC;
32057c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_BPTADJ)
32067c478bd9Sstevel@tonic-gate 		flags |= PR_BPTADJ;
32077c478bd9Sstevel@tonic-gate 	if (p->p_proc_flag & P_PR_PTRACE)
32087c478bd9Sstevel@tonic-gate 		flags |= PR_PCOMPAT;
32097c478bd9Sstevel@tonic-gate 	if (t->t_proc_flag & TP_MSACCT)
32107c478bd9Sstevel@tonic-gate 		flags |= PR_MSACCT;
32117c478bd9Sstevel@tonic-gate 	sp->pr_flags = flags;
32127c478bd9Sstevel@tonic-gate 	if (VSTOPPED(t)) {
32137c478bd9Sstevel@tonic-gate 		sp->pr_why   = PR_REQUESTED;
32147c478bd9Sstevel@tonic-gate 		sp->pr_what  = 0;
32157c478bd9Sstevel@tonic-gate 	} else {
32167c478bd9Sstevel@tonic-gate 		sp->pr_why   = t->t_whystop;
32177c478bd9Sstevel@tonic-gate 		sp->pr_what  = t->t_whatstop;
32187c478bd9Sstevel@tonic-gate 	}
32197c478bd9Sstevel@tonic-gate 
32207c478bd9Sstevel@tonic-gate 	if (t->t_whystop == PR_FAULTED)
32217c478bd9Sstevel@tonic-gate 		bcopy(&lwp->lwp_siginfo,
32227c478bd9Sstevel@tonic-gate 		    &sp->pr_info, sizeof (k_siginfo_t));
32237c478bd9Sstevel@tonic-gate 	else if (lwp->lwp_curinfo)
32247c478bd9Sstevel@tonic-gate 		bcopy(&lwp->lwp_curinfo->sq_info,
32257c478bd9Sstevel@tonic-gate 		    &sp->pr_info, sizeof (k_siginfo_t));
32267c478bd9Sstevel@tonic-gate 
32277c478bd9Sstevel@tonic-gate 	if (SI_FROMUSER(&lwp->lwp_siginfo) && zp->zone_id != GLOBAL_ZONEID &&
32287c478bd9Sstevel@tonic-gate 	    sp->pr_info.si_zoneid != zp->zone_id) {
32297c478bd9Sstevel@tonic-gate 		sp->pr_info.si_pid = zp->zone_zsched->p_pid;
32307c478bd9Sstevel@tonic-gate 		sp->pr_info.si_uid = 0;
32317c478bd9Sstevel@tonic-gate 		sp->pr_info.si_ctid = -1;
32327c478bd9Sstevel@tonic-gate 		sp->pr_info.si_zoneid = zp->zone_id;
32337c478bd9Sstevel@tonic-gate 	}
32347c478bd9Sstevel@tonic-gate 
32357c478bd9Sstevel@tonic-gate 	sp->pr_cursig  = lwp->lwp_cursig;
32367c478bd9Sstevel@tonic-gate 	prassignset(&sp->pr_sigpend, &p->p_sig);
32377c478bd9Sstevel@tonic-gate 	prassignset(&sp->pr_lwppend, &t->t_sig);
32387c478bd9Sstevel@tonic-gate 	schedctl_finish_sigblock(t);
32397c478bd9Sstevel@tonic-gate 	prassignset(&sp->pr_sighold, &t->t_hold);
32407c478bd9Sstevel@tonic-gate 	sp->pr_altstack = lwp->lwp_sigaltstack;
32417c478bd9Sstevel@tonic-gate 	prgetaction(p, up, lwp->lwp_cursig, &sp->pr_action);
32427c478bd9Sstevel@tonic-gate 	sp->pr_pid   = p->p_pid;
32437c478bd9Sstevel@tonic-gate 	if (curproc->p_zone->zone_id != GLOBAL_ZONEID &&
32447c478bd9Sstevel@tonic-gate 	    (p->p_flag & SZONETOP)) {
32457c478bd9Sstevel@tonic-gate 		ASSERT(p->p_zone->zone_id != GLOBAL_ZONEID);
32467c478bd9Sstevel@tonic-gate 		/*
32477c478bd9Sstevel@tonic-gate 		 * Inside local zones, fake zsched's pid as parent pids for
32487c478bd9Sstevel@tonic-gate 		 * processes which reference processes outside of the zone.
32497c478bd9Sstevel@tonic-gate 		 */
32507c478bd9Sstevel@tonic-gate 		sp->pr_ppid = curproc->p_zone->zone_zsched->p_pid;
32517c478bd9Sstevel@tonic-gate 	} else {
32527c478bd9Sstevel@tonic-gate 		sp->pr_ppid = p->p_ppid;
32537c478bd9Sstevel@tonic-gate 	}
32547c478bd9Sstevel@tonic-gate 	sp->pr_pgrp  = p->p_pgrp;
32557c478bd9Sstevel@tonic-gate 	sp->pr_sid   = p->p_sessp->s_sid;
32567c478bd9Sstevel@tonic-gate 	hrt2ts(mstate_aggr_state(p, LMS_USER), &sp->pr_utime);
32577c478bd9Sstevel@tonic-gate 	hrt2ts(mstate_aggr_state(p, LMS_SYSTEM), &sp->pr_stime);
32587c478bd9Sstevel@tonic-gate 	TICK_TO_TIMESTRUC(p->p_cutime, &sp->pr_cutime);
32597c478bd9Sstevel@tonic-gate 	TICK_TO_TIMESTRUC(p->p_cstime, &sp->pr_cstime);
32607c478bd9Sstevel@tonic-gate 	(void) strncpy(sp->pr_clname, sclass[t->t_cid].cl_name,
326125b463cdSethindra 	    sizeof (sp->pr_clname) - 1);
32627c478bd9Sstevel@tonic-gate 	sp->pr_who = t->t_tid;
32637c478bd9Sstevel@tonic-gate 	sp->pr_nlwp = p->p_lwpcnt;
32647c478bd9Sstevel@tonic-gate 	sp->pr_brkbase = p->p_brkbase;
32657c478bd9Sstevel@tonic-gate 	sp->pr_brksize = p->p_brksize;
32667c478bd9Sstevel@tonic-gate 	sp->pr_stkbase = prgetstackbase(p);
32677c478bd9Sstevel@tonic-gate 	sp->pr_stksize = p->p_stksize;
32687c478bd9Sstevel@tonic-gate 	sp->pr_oldcontext = (struct ucontext *)lwp->lwp_oldcontext;
32697c478bd9Sstevel@tonic-gate 	sp->pr_processor = t->t_cpu->cpu_id;
32707c478bd9Sstevel@tonic-gate 	sp->pr_bind = t->t_bind_cpu;
32717c478bd9Sstevel@tonic-gate 
32727c478bd9Sstevel@tonic-gate 	/*
32737c478bd9Sstevel@tonic-gate 	 * Fetch the current instruction, if not a system process.
32747c478bd9Sstevel@tonic-gate 	 * We don't attempt this unless the lwp is stopped.
32757c478bd9Sstevel@tonic-gate 	 */
32767c478bd9Sstevel@tonic-gate 	if ((p->p_flag & SSYS) || p->p_as == &kas)
32777c478bd9Sstevel@tonic-gate 		sp->pr_flags |= (PR_ISSYS|PR_PCINVAL);
32787c478bd9Sstevel@tonic-gate 	else if (!(flags & PR_STOPPED))
32797c478bd9Sstevel@tonic-gate 		sp->pr_flags |= PR_PCINVAL;
32807c478bd9Sstevel@tonic-gate 	else if (!prfetchinstr(lwp, &instr))
32817c478bd9Sstevel@tonic-gate 		sp->pr_flags |= PR_PCINVAL;
32827c478bd9Sstevel@tonic-gate 	else
32837c478bd9Sstevel@tonic-gate 		sp->pr_instr = instr;
32847c478bd9Sstevel@tonic-gate 
32857c478bd9Sstevel@tonic-gate 	/*
32867c478bd9Sstevel@tonic-gate 	 * Drop p_lock while touching the lwp's stack.
32877c478bd9Sstevel@tonic-gate 	 */
32887c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
32897c478bd9Sstevel@tonic-gate 	if (prisstep(lwp))
32907c478bd9Sstevel@tonic-gate 		sp->pr_flags |= PR_STEP;
32917c478bd9Sstevel@tonic-gate 	if ((flags & (PR_STOPPED|PR_ASLEEP)) && t->t_sysnum) {
32927c478bd9Sstevel@tonic-gate 		int i;
32937c478bd9Sstevel@tonic-gate 		auxv_t *auxp;
32947c478bd9Sstevel@tonic-gate 
32957c478bd9Sstevel@tonic-gate 		sp->pr_syscall = get_syscall_args(lwp,
329625b463cdSethindra 		    (long *)sp->pr_sysarg, &i);
32977c478bd9Sstevel@tonic-gate 		sp->pr_nsysarg = (short)i;
32988fd04b83SRoger A. Faulkner 		if (t->t_whystop == PR_SYSEXIT && t->t_sysnum == SYS_execve) {
32997c478bd9Sstevel@tonic-gate 			sp->pr_sysarg[0] = 0;
33007c478bd9Sstevel@tonic-gate 			sp->pr_sysarg[1] = (uintptr_t)up->u_argv;
33017c478bd9Sstevel@tonic-gate 			sp->pr_sysarg[2] = (uintptr_t)up->u_envp;
33027c478bd9Sstevel@tonic-gate 			for (i = 0, auxp = up->u_auxv;
33037c478bd9Sstevel@tonic-gate 			    i < sizeof (up->u_auxv) / sizeof (up->u_auxv[0]);
33047c478bd9Sstevel@tonic-gate 			    i++, auxp++) {
33057c478bd9Sstevel@tonic-gate 				if (auxp->a_type == AT_SUN_EXECNAME) {
33067c478bd9Sstevel@tonic-gate 					sp->pr_sysarg[0] =
330725b463cdSethindra 					    (uintptr_t)auxp->a_un.a_ptr;
33087c478bd9Sstevel@tonic-gate 					break;
33097c478bd9Sstevel@tonic-gate 				}
33107c478bd9Sstevel@tonic-gate 			}
33117c478bd9Sstevel@tonic-gate 		}
33127c478bd9Sstevel@tonic-gate 	}
33137c478bd9Sstevel@tonic-gate 	if ((flags & PR_STOPPED) || t == curthread)
33147c478bd9Sstevel@tonic-gate 		prgetprregs(lwp, sp->pr_reg);
33157c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);
33167c478bd9Sstevel@tonic-gate }
33177c478bd9Sstevel@tonic-gate 
33187c478bd9Sstevel@tonic-gate /*
33197c478bd9Sstevel@tonic-gate  * Return old version of information used by ps(1).
33207c478bd9Sstevel@tonic-gate  */
33217c478bd9Sstevel@tonic-gate void
33227c478bd9Sstevel@tonic-gate oprgetpsinfo(proc_t *p, prpsinfo_t *psp, kthread_t *tp)
33237c478bd9Sstevel@tonic-gate {
33247c478bd9Sstevel@tonic-gate 	kthread_t *t;
33257c478bd9Sstevel@tonic-gate 	char c, state;
33267c478bd9Sstevel@tonic-gate 	user_t *up;
33277c478bd9Sstevel@tonic-gate 	dev_t d;
33287c478bd9Sstevel@tonic-gate 	uint64_t pct;
33297c478bd9Sstevel@tonic-gate 	int retval, niceval;
33307c478bd9Sstevel@tonic-gate 	cred_t *cred;
33317c478bd9Sstevel@tonic-gate 	struct as *as;
33327c478bd9Sstevel@tonic-gate 	hrtime_t hrutime, hrstime, cur_time;
33337c478bd9Sstevel@tonic-gate 
33347c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
33357c478bd9Sstevel@tonic-gate 
33367c478bd9Sstevel@tonic-gate 	bzero(psp, sizeof (*psp));
33377c478bd9Sstevel@tonic-gate 
33387c478bd9Sstevel@tonic-gate 	if ((t = tp) == NULL)
33397c478bd9Sstevel@tonic-gate 		t = prchoose(p);	/* returns locked thread */
33407c478bd9Sstevel@tonic-gate 	else
33417c478bd9Sstevel@tonic-gate 		thread_lock(t);
33427c478bd9Sstevel@tonic-gate 
33437c478bd9Sstevel@tonic-gate 	/* kludge: map thread state enum into process state enum */
33447c478bd9Sstevel@tonic-gate 
33457c478bd9Sstevel@tonic-gate 	if (t == NULL) {
33467c478bd9Sstevel@tonic-gate 		state = TS_ZOMB;
33477c478bd9Sstevel@tonic-gate 	} else {
33487c478bd9Sstevel@tonic-gate 		state = VSTOPPED(t) ? TS_STOPPED : t->t_state;
33497c478bd9Sstevel@tonic-gate 		thread_unlock(t);
33507c478bd9Sstevel@tonic-gate 	}
33517c478bd9Sstevel@tonic-gate 
33527c478bd9Sstevel@tonic-gate 	switch (state) {
33537c478bd9Sstevel@tonic-gate 	case TS_SLEEP:		state = SSLEEP;		break;
33547c478bd9Sstevel@tonic-gate 	case TS_RUN:		state = SRUN;		break;
33557c478bd9Sstevel@tonic-gate 	case TS_ONPROC:		state = SONPROC;	break;
33567c478bd9Sstevel@tonic-gate 	case TS_ZOMB:		state = SZOMB;		break;
33577c478bd9Sstevel@tonic-gate 	case TS_STOPPED:	state = SSTOP;		break;
33587c478bd9Sstevel@tonic-gate 	default:		state = 0;		break;
33597c478bd9Sstevel@tonic-gate 	}
33607c478bd9Sstevel@tonic-gate 	switch (state) {
33617c478bd9Sstevel@tonic-gate 	case SSLEEP:	c = 'S';	break;
33627c478bd9Sstevel@tonic-gate 	case SRUN:	c = 'R';	break;
33637c478bd9Sstevel@tonic-gate 	case SZOMB:	c = 'Z';	break;
33647c478bd9Sstevel@tonic-gate 	case SSTOP:	c = 'T';	break;
33657c478bd9Sstevel@tonic-gate 	case SIDL:	c = 'I';	break;
33667c478bd9Sstevel@tonic-gate 	case SONPROC:	c = 'O';	break;
33677c478bd9Sstevel@tonic-gate #ifdef SXBRK
33687c478bd9Sstevel@tonic-gate 	case SXBRK:	c = 'X';	break;
33697c478bd9Sstevel@tonic-gate #endif
33707c478bd9Sstevel@tonic-gate 	default:	c = '?';	break;
33717c478bd9Sstevel@tonic-gate 	}
33727c478bd9Sstevel@tonic-gate 	psp->pr_state = state;
33737c478bd9Sstevel@tonic-gate 	psp->pr_sname = c;
33747c478bd9Sstevel@tonic-gate 	psp->pr_zomb = (state == SZOMB);
33757c478bd9Sstevel@tonic-gate 	/*
33767c478bd9Sstevel@tonic-gate 	 * only export SSYS and SMSACCT; everything else is off-limits to
33777c478bd9Sstevel@tonic-gate 	 * userland apps.
33787c478bd9Sstevel@tonic-gate 	 */
33797c478bd9Sstevel@tonic-gate 	psp->pr_flag = p->p_flag & (SSYS | SMSACCT);
33807c478bd9Sstevel@tonic-gate 
33817c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_crlock);
33827c478bd9Sstevel@tonic-gate 	cred = p->p_cred;
33837c478bd9Sstevel@tonic-gate 	psp->pr_uid = crgetruid(cred);
33847c478bd9Sstevel@tonic-gate 	psp->pr_gid = crgetrgid(cred);
33857c478bd9Sstevel@tonic-gate 	psp->pr_euid = crgetuid(cred);
33867c478bd9Sstevel@tonic-gate 	psp->pr_egid = crgetgid(cred);
33877c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_crlock);
33887c478bd9Sstevel@tonic-gate 
33897c478bd9Sstevel@tonic-gate 	psp->pr_pid = p->p_pid;
33907c478bd9Sstevel@tonic-gate 	if (curproc->p_zone->zone_id != GLOBAL_ZONEID &&
33917c478bd9Sstevel@tonic-gate 	    (p->p_flag & SZONETOP)) {
33927c478bd9Sstevel@tonic-gate 		ASSERT(p->p_zone->zone_id != GLOBAL_ZONEID);
33937c478bd9Sstevel@tonic-gate 		/*
33947c478bd9Sstevel@tonic-gate 		 * Inside local zones, fake zsched's pid as parent pids for
33957c478bd9Sstevel@tonic-gate 		 * processes which reference processes outside of the zone.
33967c478bd9Sstevel@tonic-gate 		 */
33977c478bd9Sstevel@tonic-gate 		psp->pr_ppid = curproc->p_zone->zone_zsched->p_pid;
33987c478bd9Sstevel@tonic-gate 	} else {
33997c478bd9Sstevel@tonic-gate 		psp->pr_ppid = p->p_ppid;
34007c478bd9Sstevel@tonic-gate 	}
34017c478bd9Sstevel@tonic-gate 	psp->pr_pgrp = p->p_pgrp;
34027c478bd9Sstevel@tonic-gate 	psp->pr_sid = p->p_sessp->s_sid;
34037c478bd9Sstevel@tonic-gate 	psp->pr_addr = prgetpsaddr(p);
34047c478bd9Sstevel@tonic-gate 	hrutime = mstate_aggr_state(p, LMS_USER);
34057c478bd9Sstevel@tonic-gate 	hrstime = mstate_aggr_state(p, LMS_SYSTEM);
34067c478bd9Sstevel@tonic-gate 	hrt2ts(hrutime + hrstime, &psp->pr_time);
34077c478bd9Sstevel@tonic-gate 	TICK_TO_TIMESTRUC(p->p_cutime + p->p_cstime, &psp->pr_ctime);
34087c478bd9Sstevel@tonic-gate 	switch (p->p_model) {
34097c478bd9Sstevel@tonic-gate 	case DATAMODEL_ILP32:
34107c478bd9Sstevel@tonic-gate 		psp->pr_dmodel = PR_MODEL_ILP32;
34117c478bd9Sstevel@tonic-gate 		break;
34127c478bd9Sstevel@tonic-gate 	case DATAMODEL_LP64:
34137c478bd9Sstevel@tonic-gate 		psp->pr_dmodel = PR_MODEL_LP64;
34147c478bd9Sstevel@tonic-gate 		break;
34157c478bd9Sstevel@tonic-gate 	}
34167c478bd9Sstevel@tonic-gate 	if (state == SZOMB || t == NULL) {
34177c478bd9Sstevel@tonic-gate 		int wcode = p->p_wcode;		/* must be atomic read */
34187c478bd9Sstevel@tonic-gate 
34197c478bd9Sstevel@tonic-gate 		if (wcode)
34207c478bd9Sstevel@tonic-gate 			psp->pr_wstat = wstat(wcode, p->p_wdata);
34217c478bd9Sstevel@tonic-gate 		psp->pr_lttydev = PRNODEV;
34227c478bd9Sstevel@tonic-gate 		psp->pr_ottydev = (o_dev_t)PRNODEV;
34237c478bd9Sstevel@tonic-gate 		psp->pr_size = 0;
34247c478bd9Sstevel@tonic-gate 		psp->pr_rssize = 0;
34257c478bd9Sstevel@tonic-gate 		psp->pr_pctmem = 0;
34267c478bd9Sstevel@tonic-gate 	} else {
34277c478bd9Sstevel@tonic-gate 		up = PTOU(p);
34287c478bd9Sstevel@tonic-gate 		psp->pr_wchan = t->t_wchan;
34297c478bd9Sstevel@tonic-gate 		psp->pr_pri = t->t_pri;
34307c478bd9Sstevel@tonic-gate 		(void) strncpy(psp->pr_clname, sclass[t->t_cid].cl_name,
343125b463cdSethindra 		    sizeof (psp->pr_clname) - 1);
34327c478bd9Sstevel@tonic-gate 		retval = CL_DONICE(t, NULL, 0, &niceval);
34337c478bd9Sstevel@tonic-gate 		if (retval == 0) {
34347c478bd9Sstevel@tonic-gate 			psp->pr_oldpri = v.v_maxsyspri - psp->pr_pri;
34357c478bd9Sstevel@tonic-gate 			psp->pr_nice = niceval + NZERO;
34367c478bd9Sstevel@tonic-gate 		} else {
34377c478bd9Sstevel@tonic-gate 			psp->pr_oldpri = 0;
34387c478bd9Sstevel@tonic-gate 			psp->pr_nice = 0;
34397c478bd9Sstevel@tonic-gate 		}
34407c478bd9Sstevel@tonic-gate 		d = cttydev(p);
34417c478bd9Sstevel@tonic-gate #ifdef sun
34427c478bd9Sstevel@tonic-gate 		{
34437c478bd9Sstevel@tonic-gate 			extern dev_t rwsconsdev, rconsdev, uconsdev;
34447c478bd9Sstevel@tonic-gate 			/*
34457c478bd9Sstevel@tonic-gate 			 * If the controlling terminal is the real
34467c478bd9Sstevel@tonic-gate 			 * or workstation console device, map to what the
344725b463cdSethindra 			 * user thinks is the console device. Handle case when
344825b463cdSethindra 			 * rwsconsdev or rconsdev is set to NODEV for Starfire.
34497c478bd9Sstevel@tonic-gate 			 */
345025b463cdSethindra 			if ((d == rwsconsdev || d == rconsdev) && d != NODEV)
34517c478bd9Sstevel@tonic-gate 				d = uconsdev;
34527c478bd9Sstevel@tonic-gate 		}
34537c478bd9Sstevel@tonic-gate #endif
34547c478bd9Sstevel@tonic-gate 		psp->pr_lttydev = (d == NODEV) ? PRNODEV : d;
34557c478bd9Sstevel@tonic-gate 		psp->pr_ottydev = cmpdev(d);
34567c478bd9Sstevel@tonic-gate 		psp->pr_start = up->u_start;
34577c478bd9Sstevel@tonic-gate 		bcopy(up->u_comm, psp->pr_fname,
34587c478bd9Sstevel@tonic-gate 		    MIN(sizeof (up->u_comm), sizeof (psp->pr_fname)-1));
34597c478bd9Sstevel@tonic-gate 		bcopy(up->u_psargs, psp->pr_psargs,
34607c478bd9Sstevel@tonic-gate 		    MIN(PRARGSZ-1, PSARGSZ));
34617c478bd9Sstevel@tonic-gate 		psp->pr_syscall = t->t_sysnum;
34627c478bd9Sstevel@tonic-gate 		psp->pr_argc = up->u_argc;
34637c478bd9Sstevel@tonic-gate 		psp->pr_argv = (char **)up->u_argv;
34647c478bd9Sstevel@tonic-gate 		psp->pr_envp = (char **)up->u_envp;
34657c478bd9Sstevel@tonic-gate 
34667c478bd9Sstevel@tonic-gate 		/* compute %cpu for the lwp or process */
34677c478bd9Sstevel@tonic-gate 		pct = 0;
34687c478bd9Sstevel@tonic-gate 		if ((t = tp) == NULL)
34697c478bd9Sstevel@tonic-gate 			t = p->p_tlist;
34707c478bd9Sstevel@tonic-gate 		cur_time = gethrtime_unscaled();
34717c478bd9Sstevel@tonic-gate 		do {
34727c478bd9Sstevel@tonic-gate 			pct += cpu_update_pct(t, cur_time);
34737c478bd9Sstevel@tonic-gate 			if (tp != NULL)		/* just do the one lwp */
34747c478bd9Sstevel@tonic-gate 				break;
34757c478bd9Sstevel@tonic-gate 		} while ((t = t->t_forw) != p->p_tlist);
34767c478bd9Sstevel@tonic-gate 
34777c478bd9Sstevel@tonic-gate 		psp->pr_pctcpu = prgetpctcpu(pct);
34787c478bd9Sstevel@tonic-gate 		psp->pr_cpu = (psp->pr_pctcpu*100 + 0x6000) >> 15; /* [0..99] */
34797c478bd9Sstevel@tonic-gate 		if (psp->pr_cpu > 99)
34807c478bd9Sstevel@tonic-gate 			psp->pr_cpu = 99;
34817c478bd9Sstevel@tonic-gate 
34827c478bd9Sstevel@tonic-gate 		if ((p->p_flag & SSYS) || (as = p->p_as) == &kas) {
34837c478bd9Sstevel@tonic-gate 			psp->pr_size = 0;
34847c478bd9Sstevel@tonic-gate 			psp->pr_rssize = 0;
34857c478bd9Sstevel@tonic-gate 			psp->pr_pctmem = 0;
34867c478bd9Sstevel@tonic-gate 		} else {
34877c478bd9Sstevel@tonic-gate 			mutex_exit(&p->p_lock);
3488dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_ENTER(as, RW_READER);
348940688216SSudheer A 			psp->pr_size = btopr(as->a_resvsize);
34907c478bd9Sstevel@tonic-gate 			psp->pr_rssize = rm_asrss(as);
34917c478bd9Sstevel@tonic-gate 			psp->pr_pctmem = rm_pctmemory(as);
3492dc32d872SJosef 'Jeff' Sipek 			AS_LOCK_EXIT(as);
34937c478bd9Sstevel@tonic-gate 			mutex_enter(&p->p_lock);
34947c478bd9Sstevel@tonic-gate 		}
34957c478bd9Sstevel@tonic-gate 	}
34967c478bd9Sstevel@tonic-gate 	psp->pr_bysize = ptob(psp->pr_size);
34977c478bd9Sstevel@tonic-gate 	psp->pr_byrssize = ptob(psp->pr_rssize);
34987c478bd9Sstevel@tonic-gate }
34997c478bd9Sstevel@tonic-gate 
35007c478bd9Sstevel@tonic-gate /*
35017c478bd9Sstevel@tonic-gate  * Return an array of structures with memory map information.
35027c478bd9Sstevel@tonic-gate  * We allocate here; the caller must deallocate.
3503870619e9Sfrankho  * The caller is also responsible to append the zero-filled entry
3504870619e9Sfrankho  * that terminates the PIOCMAP output buffer.
35057c478bd9Sstevel@tonic-gate  */
35067c478bd9Sstevel@tonic-gate static int
3507870619e9Sfrankho oprgetmap(proc_t *p, list_t *iolhead)
35087c478bd9Sstevel@tonic-gate {
35097c478bd9Sstevel@tonic-gate 	struct as *as = p->p_as;
35107c478bd9Sstevel@tonic-gate 	prmap_t *mp;
35117c478bd9Sstevel@tonic-gate 	struct seg *seg;
35127c478bd9Sstevel@tonic-gate 	struct seg *brkseg, *stkseg;
35137c478bd9Sstevel@tonic-gate 	uint_t prot;
35147c478bd9Sstevel@tonic-gate 
3515dc32d872SJosef 'Jeff' Sipek 	ASSERT(as != &kas && AS_WRITE_HELD(as));
35167c478bd9Sstevel@tonic-gate 
3517870619e9Sfrankho 	/*
3518870619e9Sfrankho 	 * Request an initial buffer size that doesn't waste memory
3519870619e9Sfrankho 	 * if the address space has only a small number of segments.
3520870619e9Sfrankho 	 */
3521870619e9Sfrankho 	pr_iol_initlist(iolhead, sizeof (*mp), avl_numnodes(&as->a_segtree));
35227c478bd9Sstevel@tonic-gate 
3523870619e9Sfrankho 	if ((seg = AS_SEGFIRST(as)) == NULL)
3524870619e9Sfrankho 		return (0);
35257c478bd9Sstevel@tonic-gate 
35267c478bd9Sstevel@tonic-gate 	brkseg = break_seg(p);
35277c478bd9Sstevel@tonic-gate 	stkseg = as_segat(as, prgetstackbase(p));
35287c478bd9Sstevel@tonic-gate 
35297c478bd9Sstevel@tonic-gate 	do {
35307c478bd9Sstevel@tonic-gate 		caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0);
35317c478bd9Sstevel@tonic-gate 		caddr_t saddr, naddr;
35327c478bd9Sstevel@tonic-gate 		void *tmp = NULL;
35337c478bd9Sstevel@tonic-gate 
3534284ce987SPatrick Mooney 		if ((seg->s_flags & S_HOLE) != 0) {
3535284ce987SPatrick Mooney 			continue;
3536284ce987SPatrick Mooney 		}
3537284ce987SPatrick Mooney 
35387c478bd9Sstevel@tonic-gate 		for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) {
35397c478bd9Sstevel@tonic-gate 			prot = pr_getprot(seg, 0, &tmp, &saddr, &naddr, eaddr);
35407c478bd9Sstevel@tonic-gate 			if (saddr == naddr)
35417c478bd9Sstevel@tonic-gate 				continue;
3542870619e9Sfrankho 
3543870619e9Sfrankho 			mp = pr_iol_newbuf(iolhead, sizeof (*mp));
3544870619e9Sfrankho 
35457c478bd9Sstevel@tonic-gate 			mp->pr_vaddr = saddr;
35467c478bd9Sstevel@tonic-gate 			mp->pr_size = naddr - saddr;
35477c478bd9Sstevel@tonic-gate 			mp->pr_off = SEGOP_GETOFFSET(seg, saddr);
35487c478bd9Sstevel@tonic-gate 			mp->pr_mflags = 0;
35497c478bd9Sstevel@tonic-gate 			if (prot & PROT_READ)
35507c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_READ;
35517c478bd9Sstevel@tonic-gate 			if (prot & PROT_WRITE)
35527c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_WRITE;
35537c478bd9Sstevel@tonic-gate 			if (prot & PROT_EXEC)
35547c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_EXEC;
35557c478bd9Sstevel@tonic-gate 			if (SEGOP_GETTYPE(seg, saddr) & MAP_SHARED)
35567c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_SHARED;
35577c478bd9Sstevel@tonic-gate 			if (seg == brkseg)
35587c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_BREAK;
35597c478bd9Sstevel@tonic-gate 			else if (seg == stkseg)
35607c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_STACK;
35617c478bd9Sstevel@tonic-gate 			mp->pr_pagesize = PAGESIZE;
35627c478bd9Sstevel@tonic-gate 		}
35637c478bd9Sstevel@tonic-gate 		ASSERT(tmp == NULL);
35647c478bd9Sstevel@tonic-gate 	} while ((seg = AS_SEGNEXT(as, seg)) != NULL);
35657c478bd9Sstevel@tonic-gate 
3566870619e9Sfrankho 	return (0);
35677c478bd9Sstevel@tonic-gate }
35687c478bd9Sstevel@tonic-gate 
35697c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
35707c478bd9Sstevel@tonic-gate static int
3571870619e9Sfrankho oprgetmap32(proc_t *p, list_t *iolhead)
35727c478bd9Sstevel@tonic-gate {
35737c478bd9Sstevel@tonic-gate 	struct as *as = p->p_as;
35747c478bd9Sstevel@tonic-gate 	ioc_prmap32_t *mp;
35757c478bd9Sstevel@tonic-gate 	struct seg *seg;
35767c478bd9Sstevel@tonic-gate 	struct seg *brkseg, *stkseg;
35777c478bd9Sstevel@tonic-gate 	uint_t prot;
35787c478bd9Sstevel@tonic-gate 
3579dc32d872SJosef 'Jeff' Sipek 	ASSERT(as != &kas && AS_WRITE_HELD(as));
35807c478bd9Sstevel@tonic-gate 
3581870619e9Sfrankho 	/*
3582870619e9Sfrankho 	 * Request an initial buffer size that doesn't waste memory
3583870619e9Sfrankho 	 * if the address space has only a small number of segments.
3584870619e9Sfrankho 	 */
3585870619e9Sfrankho 	pr_iol_initlist(iolhead, sizeof (*mp), avl_numnodes(&as->a_segtree));
35867c478bd9Sstevel@tonic-gate 
3587870619e9Sfrankho 	if ((seg = AS_SEGFIRST(as)) == NULL)
3588870619e9Sfrankho 		return (0);
35897c478bd9Sstevel@tonic-gate 
35907c478bd9Sstevel@tonic-gate 	brkseg = break_seg(p);
35917c478bd9Sstevel@tonic-gate 	stkseg = as_segat(as, prgetstackbase(p));
35927c478bd9Sstevel@tonic-gate 
35937c478bd9Sstevel@tonic-gate 	do {
35947c478bd9Sstevel@tonic-gate 		caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0);
35957c478bd9Sstevel@tonic-gate 		caddr_t saddr, naddr;
35967c478bd9Sstevel@tonic-gate 		void *tmp = NULL;
35977c478bd9Sstevel@tonic-gate 
3598284ce987SPatrick Mooney 		if ((seg->s_flags & S_HOLE) != 0) {
3599284ce987SPatrick Mooney 			continue;
3600284ce987SPatrick Mooney 		}
3601284ce987SPatrick Mooney 
36027c478bd9Sstevel@tonic-gate 		for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) {
36037c478bd9Sstevel@tonic-gate 			prot = pr_getprot(seg, 0, &tmp, &saddr, &naddr, eaddr);
36047c478bd9Sstevel@tonic-gate 			if (saddr == naddr)
36057c478bd9Sstevel@tonic-gate 				continue;
3606870619e9Sfrankho 
3607870619e9Sfrankho 			mp = pr_iol_newbuf(iolhead, sizeof (*mp));
3608870619e9Sfrankho 
36097c478bd9Sstevel@tonic-gate 			mp->pr_vaddr = (caddr32_t)(uintptr_t)saddr;
36107c478bd9Sstevel@tonic-gate 			mp->pr_size = (size32_t)(naddr - saddr);
36117c478bd9Sstevel@tonic-gate 			mp->pr_off = (off32_t)SEGOP_GETOFFSET(seg, saddr);
36127c478bd9Sstevel@tonic-gate 			mp->pr_mflags = 0;
36137c478bd9Sstevel@tonic-gate 			if (prot & PROT_READ)
36147c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_READ;
36157c478bd9Sstevel@tonic-gate 			if (prot & PROT_WRITE)
36167c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_WRITE;
36177c478bd9Sstevel@tonic-gate 			if (prot & PROT_EXEC)
36187c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_EXEC;
36197c478bd9Sstevel@tonic-gate 			if (SEGOP_GETTYPE(seg, saddr) & MAP_SHARED)
36207c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_SHARED;
36217c478bd9Sstevel@tonic-gate 			if (seg == brkseg)
36227c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_BREAK;
36237c478bd9Sstevel@tonic-gate 			else if (seg == stkseg)
36247c478bd9Sstevel@tonic-gate 				mp->pr_mflags |= MA_STACK;
36257c478bd9Sstevel@tonic-gate 			mp->pr_pagesize = PAGESIZE;
36267c478bd9Sstevel@tonic-gate 		}
36277c478bd9Sstevel@tonic-gate 		ASSERT(tmp == NULL);
36287c478bd9Sstevel@tonic-gate 	} while ((seg = AS_SEGNEXT(as, seg)) != NULL);
36297c478bd9Sstevel@tonic-gate 
3630870619e9Sfrankho 	return (0);
36317c478bd9Sstevel@tonic-gate }
36327c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
36337c478bd9Sstevel@tonic-gate 
36347c478bd9Sstevel@tonic-gate /*
36357c478bd9Sstevel@tonic-gate  * Return the size of the old /proc page data file.
36367c478bd9Sstevel@tonic-gate  */
36377c478bd9Sstevel@tonic-gate size_t
36387c478bd9Sstevel@tonic-gate oprpdsize(struct as *as)
36397c478bd9Sstevel@tonic-gate {
36407c478bd9Sstevel@tonic-gate 	struct seg *seg;
36417c478bd9Sstevel@tonic-gate 	size_t size;
36427c478bd9Sstevel@tonic-gate 
3643dc32d872SJosef 'Jeff' Sipek 	ASSERT(as != &kas && AS_WRITE_HELD(as));
36447c478bd9Sstevel@tonic-gate 
36457c478bd9Sstevel@tonic-gate 	if ((seg = AS_SEGFIRST(as)) == NULL)
36467c478bd9Sstevel@tonic-gate 		return (0);
36477c478bd9Sstevel@tonic-gate 
36487c478bd9Sstevel@tonic-gate 	size = sizeof (prpageheader_t);
36497c478bd9Sstevel@tonic-gate 	do {
36507c478bd9Sstevel@tonic-gate 		caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0);
36517c478bd9Sstevel@tonic-gate 		caddr_t saddr, naddr;
36527c478bd9Sstevel@tonic-gate 		void *tmp = NULL;
36537c478bd9Sstevel@tonic-gate 		size_t npage;
36547c478bd9Sstevel@tonic-gate 
3655284ce987SPatrick Mooney 		if ((seg->s_flags & S_HOLE) != 0) {
3656284ce987SPatrick Mooney 			continue;
3657284ce987SPatrick Mooney 		}
3658284ce987SPatrick Mooney 
36597c478bd9Sstevel@tonic-gate 		for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) {
36607c478bd9Sstevel@tonic-gate 			(void) pr_getprot(seg, 0, &tmp, &saddr, &naddr, eaddr);
36617c478bd9Sstevel@tonic-gate 			if ((npage = (naddr - saddr) / PAGESIZE) != 0)
36627c478bd9Sstevel@tonic-gate 				size += sizeof (prasmap_t) + roundlong(npage);
36637c478bd9Sstevel@tonic-gate 		}
36647c478bd9Sstevel@tonic-gate 		ASSERT(tmp == NULL);
36657c478bd9Sstevel@tonic-gate 	} while ((seg = AS_SEGNEXT(as, seg)) != NULL);
36667c478bd9Sstevel@tonic-gate 
36677c478bd9Sstevel@tonic-gate 	return (size);
36687c478bd9Sstevel@tonic-gate }
36697c478bd9Sstevel@tonic-gate 
36707c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
36717c478bd9Sstevel@tonic-gate size_t
36727c478bd9Sstevel@tonic-gate oprpdsize32(struct as *as)
36737c478bd9Sstevel@tonic-gate {
36747c478bd9Sstevel@tonic-gate 	struct seg *seg;
36757c478bd9Sstevel@tonic-gate 	size_t size;
36767c478bd9Sstevel@tonic-gate 
3677dc32d872SJosef 'Jeff' Sipek 	ASSERT(as != &kas && AS_WRITE_HELD(as));
36787c478bd9Sstevel@tonic-gate 
36797c478bd9Sstevel@tonic-gate 	if ((seg = AS_SEGFIRST(as)) == NULL)
36807c478bd9Sstevel@tonic-gate 		return (0);
36817c478bd9Sstevel@tonic-gate 
36827c478bd9Sstevel@tonic-gate 	size = sizeof (ioc_prpageheader32_t);
36837c478bd9Sstevel@tonic-gate 	do {
36847c478bd9Sstevel@tonic-gate 		caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0);
36857c478bd9Sstevel@tonic-gate 		caddr_t saddr, naddr;
36867c478bd9Sstevel@tonic-gate 		void *tmp = NULL;
36877c478bd9Sstevel@tonic-gate 		size_t npage;
36887c478bd9Sstevel@tonic-gate 
3689284ce987SPatrick Mooney 		if ((seg->s_flags & S_HOLE) != 0) {
3690284ce987SPatrick Mooney 			continue;
3691284ce987SPatrick Mooney 		}
3692284ce987SPatrick Mooney 
36937c478bd9Sstevel@tonic-gate 		for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) {
36947c478bd9Sstevel@tonic-gate 			(void) pr_getprot(seg, 0, &tmp, &saddr, &naddr, eaddr);
36957c478bd9Sstevel@tonic-gate 			if ((npage = (naddr - saddr) / PAGESIZE) != 0)
36967c478bd9Sstevel@tonic-gate 				size += sizeof (ioc_prmap32_t) + round4(npage);
36977c478bd9Sstevel@tonic-gate 		}
36987c478bd9Sstevel@tonic-gate 		ASSERT(tmp == NULL);
36997c478bd9Sstevel@tonic-gate 	} while ((seg = AS_SEGNEXT(as, seg)) != NULL);
37007c478bd9Sstevel@tonic-gate 
37017c478bd9Sstevel@tonic-gate 	return (size);
37027c478bd9Sstevel@tonic-gate }
37037c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
37047c478bd9Sstevel@tonic-gate 
37057c478bd9Sstevel@tonic-gate /*
37067c478bd9Sstevel@tonic-gate  * Read old /proc page data information.
37077c478bd9Sstevel@tonic-gate  */
37087c478bd9Sstevel@tonic-gate int
37097c478bd9Sstevel@tonic-gate oprpdread(struct as *as, uint_t hatid, struct uio *uiop)
37107c478bd9Sstevel@tonic-gate {
37117c478bd9Sstevel@tonic-gate 	caddr_t buf;
37127c478bd9Sstevel@tonic-gate 	size_t size;
37137c478bd9Sstevel@tonic-gate 	prpageheader_t *php;
37147c478bd9Sstevel@tonic-gate 	prasmap_t *pmp;
37157c478bd9Sstevel@tonic-gate 	struct seg *seg;
37167c478bd9Sstevel@tonic-gate 	int error;
37177c478bd9Sstevel@tonic-gate 
37187c478bd9Sstevel@tonic-gate again:
3719dc32d872SJosef 'Jeff' Sipek 	AS_LOCK_ENTER(as, RW_WRITER);
37207c478bd9Sstevel@tonic-gate 
37217c478bd9Sstevel@tonic-gate 	if ((seg = AS_SEGFIRST(as)) == NULL) {
3722dc32d872SJosef 'Jeff' Sipek 		AS_LOCK_EXIT(as);
37237c478bd9Sstevel@tonic-gate 		return (0);
37247c478bd9Sstevel@tonic-gate 	}
37257c478bd9Sstevel@tonic-gate 	size = oprpdsize(as);
37267c478bd9Sstevel@tonic-gate 	if (uiop->uio_resid < size) {
3727dc32d872SJosef 'Jeff' Sipek 		AS_LOCK_EXIT(as);
37287c478bd9Sstevel@tonic-gate 		return (E2BIG);
37297c478bd9Sstevel@tonic-gate 	}
37307c478bd9Sstevel@tonic-gate 
37317c478bd9Sstevel@tonic-gate 	buf = kmem_zalloc(size, KM_SLEEP);
37327c478bd9Sstevel@tonic-gate 	php = (prpageheader_t *)buf;
37337c478bd9Sstevel@tonic-gate 	pmp = (prasmap_t *)(buf + sizeof (prpageheader_t));
37347c478bd9Sstevel@tonic-gate 
37357c478bd9Sstevel@tonic-gate 	hrt2ts(gethrtime(), &php->pr_tstamp);
37367c478bd9Sstevel@tonic-gate 	php->pr_nmap = 0;
37377c478bd9Sstevel@tonic-gate 	php->pr_npage = 0;
37387c478bd9Sstevel@tonic-gate 	do {
37397c478bd9Sstevel@tonic-gate 		caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0);
37407c478bd9Sstevel@tonic-gate 		caddr_t saddr, naddr;
37417c478bd9Sstevel@tonic-gate 		void *tmp = NULL;
37427c478bd9Sstevel@tonic-gate 
3743284ce987SPatrick Mooney 		if ((seg->s_flags & S_HOLE) != 0) {
3744284ce987SPatrick Mooney 			continue;
3745284ce987SPatrick Mooney 		}
3746284ce987SPatrick Mooney 
37477c478bd9Sstevel@tonic-gate 		for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) {
37487c478bd9Sstevel@tonic-gate 			size_t len;
37497c478bd9Sstevel@tonic-gate 			size_t npage;
37507c478bd9Sstevel@tonic-gate 			uint_t prot;
37517c478bd9Sstevel@tonic-gate 			uintptr_t next;
37527c478bd9Sstevel@tonic-gate 
37537c478bd9Sstevel@tonic-gate 			prot = pr_getprot(seg, 0, &tmp, &saddr, &naddr, eaddr);
37547c478bd9Sstevel@tonic-gate 			if ((len = naddr - saddr) == 0)
37557c478bd9Sstevel@tonic-gate 				continue;
37567c478bd9Sstevel@tonic-gate 			npage = len / PAGESIZE;
37577c478bd9Sstevel@tonic-gate 			next = (uintptr_t)(pmp + 1) + roundlong(npage);
37587c478bd9Sstevel@tonic-gate 			/*
37597c478bd9Sstevel@tonic-gate 			 * It's possible that the address space can change
37607c478bd9Sstevel@tonic-gate 			 * subtlely even though we're holding as->a_lock
37617c478bd9Sstevel@tonic-gate 			 * due to the nondeterminism of page_exists() in
37627c478bd9Sstevel@tonic-gate 			 * the presence of asychronously flushed pages or
37637c478bd9Sstevel@tonic-gate 			 * mapped files whose sizes are changing.
37647c478bd9Sstevel@tonic-gate 			 * page_exists() may be called indirectly from
37657c478bd9Sstevel@tonic-gate 			 * pr_getprot() by a SEGOP_INCORE() routine.
37667c478bd9Sstevel@tonic-gate 			 * If this happens we need to make sure we don't
37677c478bd9Sstevel@tonic-gate 			 * overrun the buffer whose size we computed based
37687c478bd9Sstevel@tonic-gate 			 * on the initial iteration through the segments.
37697c478bd9Sstevel@tonic-gate 			 * Once we've detected an overflow, we need to clean
37707c478bd9Sstevel@tonic-gate 			 * up the temporary memory allocated in pr_getprot()
37717c478bd9Sstevel@tonic-gate 			 * and retry. If there's a pending signal, we return
37727c478bd9Sstevel@tonic-gate 			 * EINTR so that this thread can be dislodged if
37737c478bd9Sstevel@tonic-gate 			 * a latent bug causes us to spin indefinitely.
37747c478bd9Sstevel@tonic-gate 			 */
37757c478bd9Sstevel@tonic-gate 			if (next > (uintptr_t)buf + size) {
37767c478bd9Sstevel@tonic-gate 				pr_getprot_done(&tmp);
3777dc32d872SJosef 'Jeff' Sipek 				AS_LOCK_EXIT(as);
37787c478bd9Sstevel@tonic-gate 
37797c478bd9Sstevel@tonic-gate 				kmem_free(buf, size);
37807c478bd9Sstevel@tonic-gate 
37817c478bd9Sstevel@tonic-gate 				if (ISSIG(curthread, JUSTLOOKING))
37827c478bd9Sstevel@tonic-gate 					return (EINTR);
37837c478bd9Sstevel@tonic-gate 
37847c478bd9Sstevel@tonic-gate 				goto again;
37857c478bd9Sstevel@tonic-gate 			}
37867c478bd9Sstevel@tonic-gate 
37877c478bd9Sstevel@tonic-gate 			php->pr_nmap++;
37887c478bd9Sstevel@tonic-gate 			php->pr_npage += npage;
37897c478bd9Sstevel@tonic-gate 			pmp->pr_vaddr = saddr;
37907c478bd9Sstevel@tonic-gate 			pmp->pr_npage = npage;
37917c478bd9Sstevel@tonic-gate 			pmp->pr_off = SEGOP_GETOFFSET(seg, saddr);
37927c478bd9Sstevel@tonic-gate 			pmp->pr_mflags = 0;
37937c478bd9Sstevel@tonic-gate 			if (prot & PROT_READ)
37947c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_READ;
37957c478bd9Sstevel@tonic-gate 			if (prot & PROT_WRITE)
37967c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_WRITE;
37977c478bd9Sstevel@tonic-gate 			if (prot & PROT_EXEC)
37987c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_EXEC;
37997c478bd9Sstevel@tonic-gate 			if (SEGOP_GETTYPE(seg, saddr) & MAP_SHARED)
38007c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_SHARED;
38017c478bd9Sstevel@tonic-gate 			pmp->pr_pagesize = PAGESIZE;
38027c478bd9Sstevel@tonic-gate 			hat_getstat(as, saddr, len, hatid,
38037c478bd9Sstevel@tonic-gate 			    (char *)(pmp + 1), HAT_SYNC_ZERORM);
38047c478bd9Sstevel@tonic-gate 			pmp = (prasmap_t *)next;
38057c478bd9Sstevel@tonic-gate 		}
38067c478bd9Sstevel@tonic-gate 		ASSERT(tmp == NULL);
38077c478bd9Sstevel@tonic-gate 	} while ((seg = AS_SEGNEXT(as, seg)) != NULL);
38087c478bd9Sstevel@tonic-gate 
3809dc32d872SJosef 'Jeff' Sipek 	AS_LOCK_EXIT(as);
38107c478bd9Sstevel@tonic-gate 
38117c478bd9Sstevel@tonic-gate 	ASSERT((uintptr_t)pmp <= (uintptr_t)buf + size);
38127c478bd9Sstevel@tonic-gate 	error = uiomove(buf, (caddr_t)pmp - buf, UIO_READ, uiop);
38137c478bd9Sstevel@tonic-gate 	kmem_free(buf, size);
38147c478bd9Sstevel@tonic-gate 
38157c478bd9Sstevel@tonic-gate 	return (error);
38167c478bd9Sstevel@tonic-gate }
38177c478bd9Sstevel@tonic-gate 
38187c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
38197c478bd9Sstevel@tonic-gate int
38207c478bd9Sstevel@tonic-gate oprpdread32(struct as *as, uint_t hatid, struct uio *uiop)
38217c478bd9Sstevel@tonic-gate {
38227c478bd9Sstevel@tonic-gate 	caddr_t buf;
38237c478bd9Sstevel@tonic-gate 	size_t size;
38247c478bd9Sstevel@tonic-gate 	ioc_prpageheader32_t *php;
38257c478bd9Sstevel@tonic-gate 	ioc_prasmap32_t *pmp;
38267c478bd9Sstevel@tonic-gate 	struct seg *seg;
38277c478bd9Sstevel@tonic-gate 	int error;
38287c478bd9Sstevel@tonic-gate 
38297c478bd9Sstevel@tonic-gate again:
3830dc32d872SJosef 'Jeff' Sipek 	AS_LOCK_ENTER(as, RW_WRITER);
38317c478bd9Sstevel@tonic-gate 
38327c478bd9Sstevel@tonic-gate 	if ((seg = AS_SEGFIRST(as)) == NULL) {
3833dc32d872SJosef 'Jeff' Sipek 		AS_LOCK_EXIT(as);
38347c478bd9Sstevel@tonic-gate 		return (0);
38357c478bd9Sstevel@tonic-gate 	}
38367c478bd9Sstevel@tonic-gate 	size = oprpdsize32(as);
38377c478bd9Sstevel@tonic-gate 	if (uiop->uio_resid < size) {
3838dc32d872SJosef 'Jeff' Sipek 		AS_LOCK_EXIT(as);
38397c478bd9Sstevel@tonic-gate 		return (E2BIG);
38407c478bd9Sstevel@tonic-gate 	}
38417c478bd9Sstevel@tonic-gate 
38427c478bd9Sstevel@tonic-gate 	buf = kmem_zalloc(size, KM_SLEEP);
38437c478bd9Sstevel@tonic-gate 	php = (ioc_prpageheader32_t *)buf;
38447c478bd9Sstevel@tonic-gate 	pmp = (ioc_prasmap32_t *)(buf + sizeof (ioc_prpageheader32_t));
38457c478bd9Sstevel@tonic-gate 
38467c478bd9Sstevel@tonic-gate 	hrt2ts32(gethrtime(), &php->pr_tstamp);
38477c478bd9Sstevel@tonic-gate 	php->pr_nmap = 0;
38487c478bd9Sstevel@tonic-gate 	php->pr_npage = 0;
38497c478bd9Sstevel@tonic-gate 	do {
38507c478bd9Sstevel@tonic-gate 		caddr_t eaddr = seg->s_base + pr_getsegsize(seg, 0);
38517c478bd9Sstevel@tonic-gate 		caddr_t saddr, naddr;
38527c478bd9Sstevel@tonic-gate 		void *tmp = NULL;
38537c478bd9Sstevel@tonic-gate 
3854284ce987SPatrick Mooney 		if ((seg->s_flags & S_HOLE) != 0) {
3855284ce987SPatrick Mooney 			continue;
3856284ce987SPatrick Mooney 		}
3857284ce987SPatrick Mooney 
38587c478bd9Sstevel@tonic-gate 		for (saddr = seg->s_base; saddr < eaddr; saddr = naddr) {
38597c478bd9Sstevel@tonic-gate 			size_t len;
38607c478bd9Sstevel@tonic-gate 			size_t npage;
38617c478bd9Sstevel@tonic-gate 			uint_t prot;
38627c478bd9Sstevel@tonic-gate 			uintptr_t next;
38637c478bd9Sstevel@tonic-gate 
38647c478bd9Sstevel@tonic-gate 			prot = pr_getprot(seg, 0, &tmp, &saddr, &naddr, eaddr);
38657c478bd9Sstevel@tonic-gate 			if ((len = naddr - saddr) == 0)
38667c478bd9Sstevel@tonic-gate 				continue;
38677c478bd9Sstevel@tonic-gate 			npage = len / PAGESIZE;
38687c478bd9Sstevel@tonic-gate 			next = (uintptr_t)(pmp + 1) + round4(npage);
38697c478bd9Sstevel@tonic-gate 			/*
38707c478bd9Sstevel@tonic-gate 			 * It's possible that the address space can change
38717c478bd9Sstevel@tonic-gate 			 * subtlely even though we're holding as->a_lock
38727c478bd9Sstevel@tonic-gate 			 * due to the nondeterminism of page_exists() in
38737c478bd9Sstevel@tonic-gate 			 * the presence of asychronously flushed pages or
38747c478bd9Sstevel@tonic-gate 			 * mapped files whose sizes are changing.
38757c478bd9Sstevel@tonic-gate 			 * page_exists() may be called indirectly from
38767c478bd9Sstevel@tonic-gate 			 * pr_getprot() by a SEGOP_INCORE() routine.
38777c478bd9Sstevel@tonic-gate 			 * If this happens we need to make sure we don't
38787c478bd9Sstevel@tonic-gate 			 * overrun the buffer whose size we computed based
38797c478bd9Sstevel@tonic-gate 			 * on the initial iteration through the segments.
38807c478bd9Sstevel@tonic-gate 			 * Once we've detected an overflow, we need to clean
38817c478bd9Sstevel@tonic-gate 			 * up the temporary memory allocated in pr_getprot()
38827c478bd9Sstevel@tonic-gate 			 * and retry. If there's a pending signal, we return
38837c478bd9Sstevel@tonic-gate 			 * EINTR so that this thread can be dislodged if
38847c478bd9Sstevel@tonic-gate 			 * a latent bug causes us to spin indefinitely.
38857c478bd9Sstevel@tonic-gate 			 */
38867c478bd9Sstevel@tonic-gate 			if (next > (uintptr_t)buf + size) {
38877c478bd9Sstevel@tonic-gate 				pr_getprot_done(&tmp);
3888dc32d872SJosef 'Jeff' Sipek 				AS_LOCK_EXIT(as);
38897c478bd9Sstevel@tonic-gate 
38907c478bd9Sstevel@tonic-gate 				kmem_free(buf, size);
38917c478bd9Sstevel@tonic-gate 
38927c478bd9Sstevel@tonic-gate 				if (ISSIG(curthread, JUSTLOOKING))
38937c478bd9Sstevel@tonic-gate 					return (EINTR);
38947c478bd9Sstevel@tonic-gate 
38957c478bd9Sstevel@tonic-gate 				goto again;
38967c478bd9Sstevel@tonic-gate 			}
38977c478bd9Sstevel@tonic-gate 
38987c478bd9Sstevel@tonic-gate 			php->pr_nmap++;
38997c478bd9Sstevel@tonic-gate 			php->pr_npage += npage;
39007c478bd9Sstevel@tonic-gate 			pmp->pr_vaddr = (uint32_t)(uintptr_t)saddr;
39017c478bd9Sstevel@tonic-gate 			pmp->pr_npage = (uint32_t)npage;
39027c478bd9Sstevel@tonic-gate 			pmp->pr_off = (int32_t)SEGOP_GETOFFSET(seg, saddr);
39037c478bd9Sstevel@tonic-gate 			pmp->pr_mflags = 0;
39047c478bd9Sstevel@tonic-gate 			if (prot & PROT_READ)
39057c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_READ;
39067c478bd9Sstevel@tonic-gate 			if (prot & PROT_WRITE)
39077c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_WRITE;
39087c478bd9Sstevel@tonic-gate 			if (prot & PROT_EXEC)
39097c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_EXEC;
39107c478bd9Sstevel@tonic-gate 			if (SEGOP_GETTYPE(seg, saddr) & MAP_SHARED)
39117c478bd9Sstevel@tonic-gate 				pmp->pr_mflags |= MA_SHARED;
39127c478bd9Sstevel@tonic-gate 			pmp->pr_pagesize = PAGESIZE;
39137c478bd9Sstevel@tonic-gate 			hat_getstat(as, saddr, len, hatid,
39147c478bd9Sstevel@tonic-gate 			    (char *)(pmp + 1), HAT_SYNC_ZERORM);
39157c478bd9Sstevel@tonic-gate 			pmp = (ioc_prasmap32_t *)next;
39167c478bd9Sstevel@tonic-gate 		}
39177c478bd9Sstevel@tonic-gate 		ASSERT(tmp == NULL);
39187c478bd9Sstevel@tonic-gate 	} while ((seg = AS_SEGNEXT(as, seg)) != NULL);
39197c478bd9Sstevel@tonic-gate 
3920dc32d872SJosef 'Jeff' Sipek 	AS_LOCK_EXIT(as);
39217c478bd9Sstevel@tonic-gate 
39227c478bd9Sstevel@tonic-gate 	ASSERT((uintptr_t)pmp == (uintptr_t)buf + size);
39237c478bd9Sstevel@tonic-gate 	error = uiomove(buf, (caddr_t)pmp - buf, UIO_READ, uiop);
39247c478bd9Sstevel@tonic-gate 	kmem_free(buf, size);
39257c478bd9Sstevel@tonic-gate 
39267c478bd9Sstevel@tonic-gate 	return (error);
39277c478bd9Sstevel@tonic-gate }
39287c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
39297c478bd9Sstevel@tonic-gate 
3930da6c28aaSamw /*ARGSUSED*/
39317c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
39327c478bd9Sstevel@tonic-gate int
3933da6c28aaSamw prioctl(
3934da6c28aaSamw 	struct vnode *vp,
3935da6c28aaSamw 	int cmd,
3936da6c28aaSamw 	intptr_t arg,
3937da6c28aaSamw 	int flag,
3938da6c28aaSamw 	cred_t *cr,
3939da6c28aaSamw 	int *rvalp,
3940da6c28aaSamw 	caller_context_t *ct)
39417c478bd9Sstevel@tonic-gate {
39427c478bd9Sstevel@tonic-gate 	switch (curproc->p_model) {
39437c478bd9Sstevel@tonic-gate 	case DATAMODEL_ILP32:
3944da6c28aaSamw 		return (prioctl32(vp, cmd, arg, flag, cr, rvalp, ct));
39457c478bd9Sstevel@tonic-gate 	case DATAMODEL_LP64:
3946da6c28aaSamw 		return (prioctl64(vp, cmd, arg, flag, cr, rvalp, ct));
39477c478bd9Sstevel@tonic-gate 	default:
39487c478bd9Sstevel@tonic-gate 		return (ENOSYS);
39497c478bd9Sstevel@tonic-gate 	}
39507c478bd9Sstevel@tonic-gate }
39517c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
3952