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