xref: /illumos-gate/usr/src/uts/intel/fs/proc/prmachdep.c (revision ed093b41)
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
5ae115bc7Smrj  * Common Development and Distribution License (the "License").
6ae115bc7Smrj  * 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  */
2107a48826SRoger A. Faulkner 
227c478bd9Sstevel@tonic-gate /*
2307a48826SRoger A. Faulkner  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28*ed093b41SRobert Mustacchi /*	  All Rights Reserved	*/
29*ed093b41SRobert Mustacchi 
30*ed093b41SRobert Mustacchi /*
31*ed093b41SRobert Mustacchi  * Copyright 2023 Oxide Computer Company
32*ed093b41SRobert Mustacchi  */
337c478bd9Sstevel@tonic-gate 
347c478bd9Sstevel@tonic-gate #include <sys/types.h>
357c478bd9Sstevel@tonic-gate #include <sys/t_lock.h>
367c478bd9Sstevel@tonic-gate #include <sys/param.h>
377c478bd9Sstevel@tonic-gate #include <sys/cred.h>
387c478bd9Sstevel@tonic-gate #include <sys/debug.h>
397c478bd9Sstevel@tonic-gate #include <sys/inline.h>
407c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
417c478bd9Sstevel@tonic-gate #include <sys/proc.h>
427c478bd9Sstevel@tonic-gate #include <sys/regset.h>
437c478bd9Sstevel@tonic-gate #include <sys/privregs.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/psw.h>
497c478bd9Sstevel@tonic-gate #include <sys/pcb.h>
507c478bd9Sstevel@tonic-gate #include <sys/buf.h>
517c478bd9Sstevel@tonic-gate #include <sys/signal.h>
527c478bd9Sstevel@tonic-gate #include <sys/user.h>
537c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
54*ed093b41SRobert Mustacchi #include <sys/stdalign.h>
557c478bd9Sstevel@tonic-gate 
567c478bd9Sstevel@tonic-gate #include <sys/fault.h>
577c478bd9Sstevel@tonic-gate #include <sys/syscall.h>
587c478bd9Sstevel@tonic-gate #include <sys/procfs.h>
597c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
607c478bd9Sstevel@tonic-gate #include <sys/stack.h>
617c478bd9Sstevel@tonic-gate #include <sys/debugreg.h>
627c478bd9Sstevel@tonic-gate #include <sys/copyops.h>
637c478bd9Sstevel@tonic-gate 
647c478bd9Sstevel@tonic-gate #include <sys/vmem.h>
657c478bd9Sstevel@tonic-gate #include <sys/mman.h>
667c478bd9Sstevel@tonic-gate #include <sys/vmparam.h>
677c478bd9Sstevel@tonic-gate #include <sys/fp.h>
687c478bd9Sstevel@tonic-gate #include <sys/archsystm.h>
697c478bd9Sstevel@tonic-gate #include <sys/vmsystm.h>
707c478bd9Sstevel@tonic-gate #include <vm/hat.h>
717c478bd9Sstevel@tonic-gate #include <vm/as.h>
727c478bd9Sstevel@tonic-gate #include <vm/seg.h>
737c478bd9Sstevel@tonic-gate #include <vm/seg_kmem.h>
747c478bd9Sstevel@tonic-gate #include <vm/seg_kp.h>
757c478bd9Sstevel@tonic-gate #include <vm/page.h>
767c478bd9Sstevel@tonic-gate 
777c478bd9Sstevel@tonic-gate #include <sys/sysi86.h>
787c478bd9Sstevel@tonic-gate 
797c478bd9Sstevel@tonic-gate #include <fs/proc/prdata.h>
807c478bd9Sstevel@tonic-gate 
817c478bd9Sstevel@tonic-gate int	prnwatch = 10000;	/* maximum number of watched areas */
827c478bd9Sstevel@tonic-gate 
837c478bd9Sstevel@tonic-gate /*
847c478bd9Sstevel@tonic-gate  * Force a thread into the kernel if it is not already there.
857c478bd9Sstevel@tonic-gate  * This is a no-op on uniprocessors.
867c478bd9Sstevel@tonic-gate  */
877c478bd9Sstevel@tonic-gate /* ARGSUSED */
887c478bd9Sstevel@tonic-gate void
prpokethread(kthread_t * t)897c478bd9Sstevel@tonic-gate prpokethread(kthread_t *t)
907c478bd9Sstevel@tonic-gate {
917c478bd9Sstevel@tonic-gate 	if (t->t_state == TS_ONPROC && t->t_cpu != CPU)
927c478bd9Sstevel@tonic-gate 		poke_cpu(t->t_cpu->cpu_id);
937c478bd9Sstevel@tonic-gate }
947c478bd9Sstevel@tonic-gate 
957c478bd9Sstevel@tonic-gate /*
967c478bd9Sstevel@tonic-gate  * Return general registers.
977c478bd9Sstevel@tonic-gate  */
987c478bd9Sstevel@tonic-gate void
prgetprregs(klwp_t * lwp,prgregset_t prp)997c478bd9Sstevel@tonic-gate prgetprregs(klwp_t *lwp, prgregset_t prp)
1007c478bd9Sstevel@tonic-gate {
1017c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&lwptoproc(lwp)->p_lock));
1027c478bd9Sstevel@tonic-gate 
1037c478bd9Sstevel@tonic-gate 	getgregs(lwp, prp);
1047c478bd9Sstevel@tonic-gate }
1057c478bd9Sstevel@tonic-gate 
1067c478bd9Sstevel@tonic-gate /*
1077c478bd9Sstevel@tonic-gate  * Set general registers.
1087c478bd9Sstevel@tonic-gate  * (Note: This can be an alias to setgregs().)
1097c478bd9Sstevel@tonic-gate  */
1107c478bd9Sstevel@tonic-gate void
prsetprregs(klwp_t * lwp,prgregset_t prp,int initial)1117c478bd9Sstevel@tonic-gate prsetprregs(klwp_t *lwp, prgregset_t prp, int initial)
1127c478bd9Sstevel@tonic-gate {
1137c478bd9Sstevel@tonic-gate 	if (initial)		/* set initial values */
1147c478bd9Sstevel@tonic-gate 		lwptoregs(lwp)->r_ps = PSL_USER;
1157c478bd9Sstevel@tonic-gate 	(void) setgregs(lwp, prp);
1167c478bd9Sstevel@tonic-gate }
1177c478bd9Sstevel@tonic-gate 
1187c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
1197c478bd9Sstevel@tonic-gate 
1207c478bd9Sstevel@tonic-gate /*
1217c478bd9Sstevel@tonic-gate  * Convert prgregset32 to native prgregset
1227c478bd9Sstevel@tonic-gate  */
1237c478bd9Sstevel@tonic-gate void
prgregset_32ton(klwp_t * lwp,prgregset32_t src,prgregset_t dst)1247c478bd9Sstevel@tonic-gate prgregset_32ton(klwp_t *lwp, prgregset32_t src, prgregset_t dst)
1257c478bd9Sstevel@tonic-gate {
1267c478bd9Sstevel@tonic-gate 	struct regs *rp = lwptoregs(lwp);
1277c478bd9Sstevel@tonic-gate 
1287c478bd9Sstevel@tonic-gate 	dst[REG_GSBASE] = lwp->lwp_pcb.pcb_gsbase;
1297c478bd9Sstevel@tonic-gate 	dst[REG_FSBASE] = lwp->lwp_pcb.pcb_fsbase;
1307c478bd9Sstevel@tonic-gate 
1317c478bd9Sstevel@tonic-gate 	dst[REG_DS] = (uint16_t)src[DS];
1327c478bd9Sstevel@tonic-gate 	dst[REG_ES] = (uint16_t)src[ES];
1337c478bd9Sstevel@tonic-gate 
1347c478bd9Sstevel@tonic-gate 	dst[REG_GS] = (uint16_t)src[GS];
1357c478bd9Sstevel@tonic-gate 	dst[REG_FS] = (uint16_t)src[FS];
1367c478bd9Sstevel@tonic-gate 	dst[REG_SS] = (uint16_t)src[SS];
1377c478bd9Sstevel@tonic-gate 	dst[REG_RSP] = (uint32_t)src[UESP];
1387c478bd9Sstevel@tonic-gate 	dst[REG_RFL] =
13907a48826SRoger A. Faulkner 	    (rp->r_ps & ~PSL_USERMASK) | (src[EFL] & PSL_USERMASK);
1407c478bd9Sstevel@tonic-gate 	dst[REG_CS] = (uint16_t)src[CS];
1417c478bd9Sstevel@tonic-gate 	dst[REG_RIP] = (uint32_t)src[EIP];
1427c478bd9Sstevel@tonic-gate 	dst[REG_ERR] = (uint32_t)src[ERR];
1437c478bd9Sstevel@tonic-gate 	dst[REG_TRAPNO] = (uint32_t)src[TRAPNO];
1447c478bd9Sstevel@tonic-gate 	dst[REG_RAX] = (uint32_t)src[EAX];
1457c478bd9Sstevel@tonic-gate 	dst[REG_RCX] = (uint32_t)src[ECX];
1467c478bd9Sstevel@tonic-gate 	dst[REG_RDX] = (uint32_t)src[EDX];
1477c478bd9Sstevel@tonic-gate 	dst[REG_RBX] = (uint32_t)src[EBX];
1487c478bd9Sstevel@tonic-gate 	dst[REG_RBP] = (uint32_t)src[EBP];
1497c478bd9Sstevel@tonic-gate 	dst[REG_RSI] = (uint32_t)src[ESI];
1507c478bd9Sstevel@tonic-gate 	dst[REG_RDI] = (uint32_t)src[EDI];
1517c478bd9Sstevel@tonic-gate 	dst[REG_R8] = dst[REG_R9] = dst[REG_R10] = dst[REG_R11] =
1527c478bd9Sstevel@tonic-gate 	    dst[REG_R12] = dst[REG_R13] = dst[REG_R14] = dst[REG_R15] = 0;
1537c478bd9Sstevel@tonic-gate }
1547c478bd9Sstevel@tonic-gate 
1557c478bd9Sstevel@tonic-gate /*
1567c478bd9Sstevel@tonic-gate  * Return 32-bit general registers
1577c478bd9Sstevel@tonic-gate  */
1587c478bd9Sstevel@tonic-gate void
prgetprregs32(klwp_t * lwp,prgregset32_t prp)1597c478bd9Sstevel@tonic-gate prgetprregs32(klwp_t *lwp, prgregset32_t prp)
1607c478bd9Sstevel@tonic-gate {
1617c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&lwptoproc(lwp)->p_lock));
1627c478bd9Sstevel@tonic-gate 	getgregs32(lwp, prp);
1637c478bd9Sstevel@tonic-gate }
1647c478bd9Sstevel@tonic-gate 
1657c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
1667c478bd9Sstevel@tonic-gate 
1677c478bd9Sstevel@tonic-gate /*
1687c478bd9Sstevel@tonic-gate  * Get the syscall return values for the lwp.
1697c478bd9Sstevel@tonic-gate  */
1707c478bd9Sstevel@tonic-gate int
prgetrvals(klwp_t * lwp,long * rval1,long * rval2)1717c478bd9Sstevel@tonic-gate prgetrvals(klwp_t *lwp, long *rval1, long *rval2)
1727c478bd9Sstevel@tonic-gate {
1737c478bd9Sstevel@tonic-gate 	struct regs *r = lwptoregs(lwp);
1747c478bd9Sstevel@tonic-gate 
1757c478bd9Sstevel@tonic-gate 	if (r->r_ps & PS_C)
1767c478bd9Sstevel@tonic-gate 		return (r->r_r0);
1777c478bd9Sstevel@tonic-gate 	if (lwp->lwp_eosys == JUSTRETURN) {
1787c478bd9Sstevel@tonic-gate 		*rval1 = 0;
1797c478bd9Sstevel@tonic-gate 		*rval2 = 0;
1807c478bd9Sstevel@tonic-gate 	} else if (lwp_getdatamodel(lwp) != DATAMODEL_NATIVE) {
1817c478bd9Sstevel@tonic-gate 		/*
1827c478bd9Sstevel@tonic-gate 		 * XX64	Not sure we -really- need to do this, because the
1837c478bd9Sstevel@tonic-gate 		 *	syscall return already masks off the bottom values ..?
1847c478bd9Sstevel@tonic-gate 		 */
1857c478bd9Sstevel@tonic-gate 		*rval1 = r->r_r0 & (uint32_t)0xffffffffu;
1867c478bd9Sstevel@tonic-gate 		*rval2 = r->r_r1 & (uint32_t)0xffffffffu;
1877c478bd9Sstevel@tonic-gate 	} else {
1887c478bd9Sstevel@tonic-gate 		*rval1 = r->r_r0;
1897c478bd9Sstevel@tonic-gate 		*rval2 = r->r_r1;
1907c478bd9Sstevel@tonic-gate 	}
1917c478bd9Sstevel@tonic-gate 	return (0);
1927c478bd9Sstevel@tonic-gate }
1937c478bd9Sstevel@tonic-gate 
1947c478bd9Sstevel@tonic-gate /*
1957c478bd9Sstevel@tonic-gate  * Does the system support floating-point, either through hardware
1967c478bd9Sstevel@tonic-gate  * or by trapping and emulating floating-point machine instructions?
1977c478bd9Sstevel@tonic-gate  */
1987c478bd9Sstevel@tonic-gate int
prhasfp(void)1997c478bd9Sstevel@tonic-gate prhasfp(void)
2007c478bd9Sstevel@tonic-gate {
2017c478bd9Sstevel@tonic-gate 	extern int fp_kind;
2027c478bd9Sstevel@tonic-gate 
2037c478bd9Sstevel@tonic-gate 	return (fp_kind != FP_NO);
2047c478bd9Sstevel@tonic-gate }
2057c478bd9Sstevel@tonic-gate 
2067c478bd9Sstevel@tonic-gate /*
2077c478bd9Sstevel@tonic-gate  * Get floating-point registers.
2087c478bd9Sstevel@tonic-gate  */
2097c478bd9Sstevel@tonic-gate void
prgetprfpregs(klwp_t * lwp,prfpregset_t * pfp)2107c478bd9Sstevel@tonic-gate prgetprfpregs(klwp_t *lwp, prfpregset_t *pfp)
2117c478bd9Sstevel@tonic-gate {
2127c478bd9Sstevel@tonic-gate 	bzero(pfp, sizeof (prfpregset_t));
2137c478bd9Sstevel@tonic-gate 	getfpregs(lwp, pfp);
2147c478bd9Sstevel@tonic-gate }
2157c478bd9Sstevel@tonic-gate 
2167c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL)
2177c478bd9Sstevel@tonic-gate void
prgetprfpregs32(klwp_t * lwp,prfpregset32_t * pfp)2187c478bd9Sstevel@tonic-gate prgetprfpregs32(klwp_t *lwp, prfpregset32_t *pfp)
2197c478bd9Sstevel@tonic-gate {
2207c478bd9Sstevel@tonic-gate 	bzero(pfp, sizeof (*pfp));
2217c478bd9Sstevel@tonic-gate 	getfpregs32(lwp, pfp);
2227c478bd9Sstevel@tonic-gate }
2237c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
2247c478bd9Sstevel@tonic-gate 
2257c478bd9Sstevel@tonic-gate /*
2267c478bd9Sstevel@tonic-gate  * Set floating-point registers.
2277c478bd9Sstevel@tonic-gate  * (Note: This can be an alias to setfpregs().)
2287c478bd9Sstevel@tonic-gate  */
2297c478bd9Sstevel@tonic-gate void
prsetprfpregs(klwp_t * lwp,prfpregset_t * pfp)2307c478bd9Sstevel@tonic-gate prsetprfpregs(klwp_t *lwp, prfpregset_t *pfp)
2317c478bd9Sstevel@tonic-gate {
2327c478bd9Sstevel@tonic-gate 	setfpregs(lwp, pfp);
2337c478bd9Sstevel@tonic-gate }
2347c478bd9Sstevel@tonic-gate 
2357c478bd9Sstevel@tonic-gate #if defined(_SYSCALL32_IMPL)
2367c478bd9Sstevel@tonic-gate void
prsetprfpregs32(klwp_t * lwp,prfpregset32_t * pfp)2377c478bd9Sstevel@tonic-gate prsetprfpregs32(klwp_t *lwp, prfpregset32_t *pfp)
2387c478bd9Sstevel@tonic-gate {
2397c478bd9Sstevel@tonic-gate 	setfpregs32(lwp, pfp);
2407c478bd9Sstevel@tonic-gate }
2417c478bd9Sstevel@tonic-gate #endif	/* _SYSCALL32_IMPL */
2427c478bd9Sstevel@tonic-gate 
2437c478bd9Sstevel@tonic-gate /*
244*ed093b41SRobert Mustacchi  * This is a general function that the main part of /proc and the rest of the
245*ed093b41SRobert Mustacchi  * system uses to ask does a given process actually have extended state. Right
246*ed093b41SRobert Mustacchi  * now, this question is not process-specific, but rather CPU specific. We look
247*ed093b41SRobert Mustacchi  * at whether xsave has been enabled to determine that. While strictly speaking
248*ed093b41SRobert Mustacchi  * one could make the argument that all amd64 CPUs support fxsave and we could
249*ed093b41SRobert Mustacchi  * emulate something that only supports that, we don't think that makes sense.
2507c478bd9Sstevel@tonic-gate  */
2517c478bd9Sstevel@tonic-gate int
prhasx(proc_t * p)2527c478bd9Sstevel@tonic-gate prhasx(proc_t *p)
2537c478bd9Sstevel@tonic-gate {
254*ed093b41SRobert Mustacchi 	return (fpu_xsave_enabled());
2557c478bd9Sstevel@tonic-gate }
2567c478bd9Sstevel@tonic-gate 
2577c478bd9Sstevel@tonic-gate /*
258*ed093b41SRobert Mustacchi  * Return the minimum size that we need to determine the full size of a
259*ed093b41SRobert Mustacchi  * prxregset_t.
2607c478bd9Sstevel@tonic-gate  */
261*ed093b41SRobert Mustacchi boolean_t
prwriteminxreg(size_t * sizep)262*ed093b41SRobert Mustacchi prwriteminxreg(size_t *sizep)
263*ed093b41SRobert Mustacchi {
264*ed093b41SRobert Mustacchi 	*sizep = sizeof (prxregset_hdr_t);
265*ed093b41SRobert Mustacchi 	return (B_TRUE);
266*ed093b41SRobert Mustacchi }
267*ed093b41SRobert Mustacchi 
268*ed093b41SRobert Mustacchi /*
269*ed093b41SRobert Mustacchi  * This routine services both ILP32 and LP64 callers. We cannot assume anything
270*ed093b41SRobert Mustacchi  * about the alignment of argp and must bcopy things to known structures that we
271*ed093b41SRobert Mustacchi  * care about. We are guaranteed to have prxregset_hdr_t bytes because we asked
272*ed093b41SRobert Mustacchi  * for them above.
273*ed093b41SRobert Mustacchi  */
274*ed093b41SRobert Mustacchi boolean_t
prwritesizexreg(const void * argp,size_t * sizep)275*ed093b41SRobert Mustacchi prwritesizexreg(const void *argp, size_t *sizep)
276*ed093b41SRobert Mustacchi {
277*ed093b41SRobert Mustacchi 	prxregset_hdr_t hdr;
278*ed093b41SRobert Mustacchi 
279*ed093b41SRobert Mustacchi 	/*
280*ed093b41SRobert Mustacchi 	 * While it's tempting to validate everything here, the only thing we
281*ed093b41SRobert Mustacchi 	 * care about is that we understand the type and the size meets our
282*ed093b41SRobert Mustacchi 	 * constraints:
283*ed093b41SRobert Mustacchi 	 *
284*ed093b41SRobert Mustacchi 	 *  o We actually have an item of type PR_TYPE_XSAVE, otherwise we
285*ed093b41SRobert Mustacchi 	 *    don't know what this is.
286*ed093b41SRobert Mustacchi 	 *  o The indicated size actually contains at least the
287*ed093b41SRobert Mustacchi 	 *    prxregset_hdr_t.
288*ed093b41SRobert Mustacchi 	 *  o The indicated size isn't larger than what the FPU tells us is
289*ed093b41SRobert Mustacchi 	 *    allowed.
290*ed093b41SRobert Mustacchi 	 *
291*ed093b41SRobert Mustacchi 	 * We do not check if the reset of the structure makes semantic sense at
292*ed093b41SRobert Mustacchi 	 * this point. We save all other validation for the normal set function
293*ed093b41SRobert Mustacchi 	 * as that's when we'll have the rest of our data.
294*ed093b41SRobert Mustacchi 	 */
295*ed093b41SRobert Mustacchi 	bcopy(argp, &hdr, sizeof (hdr));
296*ed093b41SRobert Mustacchi 	if (hdr.pr_type != PR_TYPE_XSAVE ||
297*ed093b41SRobert Mustacchi 	    hdr.pr_size > fpu_proc_xregs_max_size() ||
298*ed093b41SRobert Mustacchi 	    hdr.pr_size < sizeof (prxregset_hdr_t)) {
299*ed093b41SRobert Mustacchi 		return (B_FALSE);
300*ed093b41SRobert Mustacchi 	}
301*ed093b41SRobert Mustacchi 
302*ed093b41SRobert Mustacchi 	*sizep = hdr.pr_size - sizeof (prxregset_hdr_t);
303*ed093b41SRobert Mustacchi 	return (B_TRUE);
304*ed093b41SRobert Mustacchi }
305*ed093b41SRobert Mustacchi 
306*ed093b41SRobert Mustacchi /*
307*ed093b41SRobert Mustacchi  * Get the size of the extra registers. The ultimate size here depends on a
308*ed093b41SRobert Mustacchi  * combination of a few different things. Right now the xregs always have our
309*ed093b41SRobert Mustacchi  * header, the illumos-specific XCR information, the xsave information, and then
310*ed093b41SRobert Mustacchi  * otherwise this varies based on the items that the CPU supports.
311*ed093b41SRobert Mustacchi  *
312*ed093b41SRobert Mustacchi  * The ultimate size here is going to be:
313*ed093b41SRobert Mustacchi  *
314*ed093b41SRobert Mustacchi  *  o 1x prxregset_hdr_t
315*ed093b41SRobert Mustacchi  *  o n  prxregset_info_t structures
316*ed093b41SRobert Mustacchi  *  o The individual data for each one
317*ed093b41SRobert Mustacchi  */
318*ed093b41SRobert Mustacchi size_t
prgetprxregsize(proc_t * p)3197c478bd9Sstevel@tonic-gate prgetprxregsize(proc_t *p)
3207c478bd9Sstevel@tonic-gate {
321*ed093b41SRobert Mustacchi 	uint32_t size;
322*ed093b41SRobert Mustacchi 
323*ed093b41SRobert Mustacchi 	fpu_proc_xregs_info(p, NULL, &size, NULL);
324*ed093b41SRobert Mustacchi 	return (size);
3257c478bd9Sstevel@tonic-gate }
3267c478bd9Sstevel@tonic-gate 
3277c478bd9Sstevel@tonic-gate /*
3287c478bd9Sstevel@tonic-gate  * Get extra registers.
3297c478bd9Sstevel@tonic-gate  */
3307c478bd9Sstevel@tonic-gate void
prgetprxregs(klwp_t * lwp,prxregset_t * prx)331*ed093b41SRobert Mustacchi prgetprxregs(klwp_t *lwp, prxregset_t *prx)
3327c478bd9Sstevel@tonic-gate {
333*ed093b41SRobert Mustacchi 	fpu_proc_xregs_get(lwp, prx);
3347c478bd9Sstevel@tonic-gate }
3357c478bd9Sstevel@tonic-gate 
3367c478bd9Sstevel@tonic-gate /*
3377c478bd9Sstevel@tonic-gate  * Set extra registers.
338*ed093b41SRobert Mustacchi  *
339*ed093b41SRobert Mustacchi  * We've been given a regset to set. Before we hand it off to the FPU, we have
340*ed093b41SRobert Mustacchi  * to go through and make sure that the different parts of this actually make
341*ed093b41SRobert Mustacchi  * sense. The kernel has guaranteed us through the functions above that we have
342*ed093b41SRobert Mustacchi  * the number of bytes that the header indicates are present. In particular we
343*ed093b41SRobert Mustacchi  * need to validate:
344*ed093b41SRobert Mustacchi  *
345*ed093b41SRobert Mustacchi  *   o The information in the header is reasonable: we have a known type, flags
346*ed093b41SRobert Mustacchi  *     and padding are zero, and there is at least one info structure.
347*ed093b41SRobert Mustacchi  *   o Each of the info structures has a valid type, size, and fits within the
348*ed093b41SRobert Mustacchi  *     data we were given.
349*ed093b41SRobert Mustacchi  *   o We do not validate or modify the actual data in the different pieces for
350*ed093b41SRobert Mustacchi  *     validity. That is considered something that the FPU does. Similarly if
351*ed093b41SRobert Mustacchi  *     something is read-only or not used, that is something that it checks.
352*ed093b41SRobert Mustacchi  *
353*ed093b41SRobert Mustacchi  * While we would like to return something other than EINVAL, the /proc APIs
354*ed093b41SRobert Mustacchi  * pretty much lead that to being the primary errno for all sorts of situations.
3557c478bd9Sstevel@tonic-gate  */
356*ed093b41SRobert Mustacchi int
prsetprxregs(klwp_t * lwp,prxregset_t * prx)357*ed093b41SRobert Mustacchi prsetprxregs(klwp_t *lwp, prxregset_t *prx)
3587c478bd9Sstevel@tonic-gate {
359*ed093b41SRobert Mustacchi 	size_t infosz;
360*ed093b41SRobert Mustacchi 	prxregset_hdr_t *hdr = (prxregset_hdr_t *)prx;
361*ed093b41SRobert Mustacchi 
362*ed093b41SRobert Mustacchi 	if (hdr->pr_type != PR_TYPE_XSAVE || hdr->pr_flags != 0 ||
363*ed093b41SRobert Mustacchi 	    hdr->pr_pad[0] != 0 || hdr->pr_pad[1] != 0 || hdr->pr_pad[2] != 0 ||
364*ed093b41SRobert Mustacchi 	    hdr->pr_pad[3] != 0 || hdr->pr_ninfo == 0) {
365*ed093b41SRobert Mustacchi 		return (EINVAL);
366*ed093b41SRobert Mustacchi 	}
367*ed093b41SRobert Mustacchi 
368*ed093b41SRobert Mustacchi 	infosz = hdr->pr_ninfo * sizeof (prxregset_info_t) +
369*ed093b41SRobert Mustacchi 	    sizeof (prxregset_hdr_t);
370*ed093b41SRobert Mustacchi 	if (infosz > hdr->pr_size) {
371*ed093b41SRobert Mustacchi 		return (EINVAL);
372*ed093b41SRobert Mustacchi 	}
373*ed093b41SRobert Mustacchi 
374*ed093b41SRobert Mustacchi 	for (uint32_t i = 0; i < hdr->pr_ninfo; i++) {
375*ed093b41SRobert Mustacchi 		uint32_t exp_size;
376*ed093b41SRobert Mustacchi 		size_t need_len, exp_align;
377*ed093b41SRobert Mustacchi 		const prxregset_info_t *info = &hdr->pr_info[i];
378*ed093b41SRobert Mustacchi 
379*ed093b41SRobert Mustacchi 		switch (info->pri_type) {
380*ed093b41SRobert Mustacchi 		case PRX_INFO_XCR:
381*ed093b41SRobert Mustacchi 			exp_size = sizeof (prxregset_xcr_t);
382*ed093b41SRobert Mustacchi 			exp_align = alignof (prxregset_xcr_t);
383*ed093b41SRobert Mustacchi 			break;
384*ed093b41SRobert Mustacchi 		case PRX_INFO_XSAVE:
385*ed093b41SRobert Mustacchi 			exp_size = sizeof (prxregset_xsave_t);
386*ed093b41SRobert Mustacchi 			exp_align = alignof (prxregset_xsave_t);
387*ed093b41SRobert Mustacchi 			break;
388*ed093b41SRobert Mustacchi 		case PRX_INFO_YMM:
389*ed093b41SRobert Mustacchi 			exp_size = sizeof (prxregset_ymm_t);
390*ed093b41SRobert Mustacchi 			exp_align = alignof (prxregset_ymm_t);
391*ed093b41SRobert Mustacchi 			break;
392*ed093b41SRobert Mustacchi 		case PRX_INFO_OPMASK:
393*ed093b41SRobert Mustacchi 			exp_size = sizeof (prxregset_opmask_t);
394*ed093b41SRobert Mustacchi 			exp_align = alignof (prxregset_opmask_t);
395*ed093b41SRobert Mustacchi 			break;
396*ed093b41SRobert Mustacchi 		case PRX_INFO_ZMM:
397*ed093b41SRobert Mustacchi 			exp_size = sizeof (prxregset_zmm_t);
398*ed093b41SRobert Mustacchi 			exp_align = alignof (prxregset_zmm_t);
399*ed093b41SRobert Mustacchi 			break;
400*ed093b41SRobert Mustacchi 		case PRX_INFO_HI_ZMM:
401*ed093b41SRobert Mustacchi 			exp_size = sizeof (prxregset_hi_zmm_t);
402*ed093b41SRobert Mustacchi 			exp_align = alignof (prxregset_hi_zmm_t);
403*ed093b41SRobert Mustacchi 			break;
404*ed093b41SRobert Mustacchi 		default:
405*ed093b41SRobert Mustacchi 			return (EINVAL);
406*ed093b41SRobert Mustacchi 		}
407*ed093b41SRobert Mustacchi 
408*ed093b41SRobert Mustacchi 		if (info->pri_flags != 0 || info->pri_size != exp_size) {
409*ed093b41SRobert Mustacchi 			return (EINVAL);
410*ed093b41SRobert Mustacchi 		}
411*ed093b41SRobert Mustacchi 
412*ed093b41SRobert Mustacchi 		if ((info->pri_offset % exp_align) != 0) {
413*ed093b41SRobert Mustacchi 			return (EINVAL);
414*ed093b41SRobert Mustacchi 		}
415*ed093b41SRobert Mustacchi 
416*ed093b41SRobert Mustacchi 		/*
417*ed093b41SRobert Mustacchi 		 * No bytes of this item's entry should overlap with the
418*ed093b41SRobert Mustacchi 		 * information area. If users want to overlap the actual data
419*ed093b41SRobert Mustacchi 		 * information for some odd reason, we don't check that and let
420*ed093b41SRobert Mustacchi 		 * them do what they want. However, the total data for this
421*ed093b41SRobert Mustacchi 		 * region must actually fit. Because exp_size and pri_offset are
422*ed093b41SRobert Mustacchi 		 * uint32_t's, we can sum them without overflow worries in an
423*ed093b41SRobert Mustacchi 		 * LP64 environment.
424*ed093b41SRobert Mustacchi 		 *
425*ed093b41SRobert Mustacchi 		 * While we try to grantee alignment when writing this structure
426*ed093b41SRobert Mustacchi 		 * out to userland, that is in no way a requirement and users
427*ed093b41SRobert Mustacchi 		 * are allowed to start these structures wherever they want.
428*ed093b41SRobert Mustacchi 		 * Hence that is not checked here.
429*ed093b41SRobert Mustacchi 		 */
430*ed093b41SRobert Mustacchi 		need_len = (size_t)exp_size + (size_t)info->pri_offset;
431*ed093b41SRobert Mustacchi 		if (info->pri_offset < infosz ||
432*ed093b41SRobert Mustacchi 		    need_len > (size_t)hdr->pr_size) {
433*ed093b41SRobert Mustacchi 			return (EINVAL);
434*ed093b41SRobert Mustacchi 		}
435*ed093b41SRobert Mustacchi 	}
436*ed093b41SRobert Mustacchi 
437*ed093b41SRobert Mustacchi 	return (fpu_proc_xregs_set(lwp, prx));
4387c478bd9Sstevel@tonic-gate }
4397c478bd9Sstevel@tonic-gate 
4407c478bd9Sstevel@tonic-gate /*
4417c478bd9Sstevel@tonic-gate  * Return the base (lower limit) of the process stack.
4427c478bd9Sstevel@tonic-gate  */
4437c478bd9Sstevel@tonic-gate caddr_t
prgetstackbase(proc_t * p)4447c478bd9Sstevel@tonic-gate prgetstackbase(proc_t *p)
4457c478bd9Sstevel@tonic-gate {
4467c478bd9Sstevel@tonic-gate 	return (p->p_usrstack - p->p_stksize);
4477c478bd9Sstevel@tonic-gate }
4487c478bd9Sstevel@tonic-gate 
4497c478bd9Sstevel@tonic-gate /*
4507c478bd9Sstevel@tonic-gate  * Return the "addr" field for pr_addr in prpsinfo_t.
4517c478bd9Sstevel@tonic-gate  * This is a vestige of the past, so whatever we return is OK.
4527c478bd9Sstevel@tonic-gate  */
4537c478bd9Sstevel@tonic-gate caddr_t
prgetpsaddr(proc_t * p)4547c478bd9Sstevel@tonic-gate prgetpsaddr(proc_t *p)
4557c478bd9Sstevel@tonic-gate {
4567c478bd9Sstevel@tonic-gate 	return ((caddr_t)p);
4577c478bd9Sstevel@tonic-gate }
4587c478bd9Sstevel@tonic-gate 
4597c478bd9Sstevel@tonic-gate /*
4607c478bd9Sstevel@tonic-gate  * Arrange to single-step the lwp.
4617c478bd9Sstevel@tonic-gate  */
4627c478bd9Sstevel@tonic-gate void
prstep(klwp_t * lwp,int watchstep)4637c478bd9Sstevel@tonic-gate prstep(klwp_t *lwp, int watchstep)
4647c478bd9Sstevel@tonic-gate {
4657c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&lwptoproc(lwp)->p_lock));
4667c478bd9Sstevel@tonic-gate 
46765a89a64Smarx 	/*
46865a89a64Smarx 	 * flag LWP so that its r_efl trace bit (PS_T) will be set on
46965a89a64Smarx 	 * next return to usermode.
47065a89a64Smarx 	 */
47165a89a64Smarx 	lwp->lwp_pcb.pcb_flags |= REQUEST_STEP;
47265a89a64Smarx 	lwp->lwp_pcb.pcb_flags &= ~REQUEST_NOSTEP;
47365a89a64Smarx 
4747c478bd9Sstevel@tonic-gate 	if (watchstep)
4757c478bd9Sstevel@tonic-gate 		lwp->lwp_pcb.pcb_flags |= WATCH_STEP;
4767c478bd9Sstevel@tonic-gate 	else
4777c478bd9Sstevel@tonic-gate 		lwp->lwp_pcb.pcb_flags |= NORMAL_STEP;
4787c478bd9Sstevel@tonic-gate 
47965a89a64Smarx 	aston(lwptot(lwp));	/* let trap() set PS_T in rp->r_efl */
4807c478bd9Sstevel@tonic-gate }
4817c478bd9Sstevel@tonic-gate 
4827c478bd9Sstevel@tonic-gate /*
4837c478bd9Sstevel@tonic-gate  * Undo prstep().
4847c478bd9Sstevel@tonic-gate  */
4857c478bd9Sstevel@tonic-gate void
prnostep(klwp_t * lwp)4867c478bd9Sstevel@tonic-gate prnostep(klwp_t *lwp)
4877c478bd9Sstevel@tonic-gate {
4887c478bd9Sstevel@tonic-gate 	ASSERT(ttolwp(curthread) == lwp ||
4897c478bd9Sstevel@tonic-gate 	    MUTEX_NOT_HELD(&lwptoproc(lwp)->p_lock));
4907c478bd9Sstevel@tonic-gate 
49165a89a64Smarx 	/*
49265a89a64Smarx 	 * flag LWP so that its r_efl trace bit (PS_T) will be cleared on
49365a89a64Smarx 	 * next return to usermode.
49465a89a64Smarx 	 */
49565a89a64Smarx 	lwp->lwp_pcb.pcb_flags |= REQUEST_NOSTEP;
49665a89a64Smarx 
49765a89a64Smarx 	lwp->lwp_pcb.pcb_flags &=
49865a89a64Smarx 	    ~(REQUEST_STEP|NORMAL_STEP|WATCH_STEP|DEBUG_PENDING);
49965a89a64Smarx 
50065a89a64Smarx 	aston(lwptot(lwp));	/* let trap() clear PS_T in rp->r_efl */
5017c478bd9Sstevel@tonic-gate }
5027c478bd9Sstevel@tonic-gate 
5037c478bd9Sstevel@tonic-gate /*
5047c478bd9Sstevel@tonic-gate  * Return non-zero if a single-step is in effect.
5057c478bd9Sstevel@tonic-gate  */
5067c478bd9Sstevel@tonic-gate int
prisstep(klwp_t * lwp)5077c478bd9Sstevel@tonic-gate prisstep(klwp_t *lwp)
5087c478bd9Sstevel@tonic-gate {
5097c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&lwptoproc(lwp)->p_lock));
5107c478bd9Sstevel@tonic-gate 
5117c478bd9Sstevel@tonic-gate 	return ((lwp->lwp_pcb.pcb_flags &
51207a48826SRoger A. Faulkner 	    (NORMAL_STEP|WATCH_STEP|DEBUG_PENDING)) != 0);
5137c478bd9Sstevel@tonic-gate }
5147c478bd9Sstevel@tonic-gate 
5157c478bd9Sstevel@tonic-gate /*
5167c478bd9Sstevel@tonic-gate  * Set the PC to the specified virtual address.
5177c478bd9Sstevel@tonic-gate  */
5187c478bd9Sstevel@tonic-gate void
prsvaddr(klwp_t * lwp,caddr_t vaddr)5197c478bd9Sstevel@tonic-gate prsvaddr(klwp_t *lwp, caddr_t vaddr)
5207c478bd9Sstevel@tonic-gate {
5217c478bd9Sstevel@tonic-gate 	struct regs *r = lwptoregs(lwp);
5227c478bd9Sstevel@tonic-gate 
5237c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&lwptoproc(lwp)->p_lock));
5247c478bd9Sstevel@tonic-gate 
5257c478bd9Sstevel@tonic-gate 	r->r_pc = (uintptr_t)vaddr;
5267c478bd9Sstevel@tonic-gate }
5277c478bd9Sstevel@tonic-gate 
5287c478bd9Sstevel@tonic-gate /*
5297c478bd9Sstevel@tonic-gate  * Map address "addr" in address space "as" into a kernel virtual address.
5307c478bd9Sstevel@tonic-gate  * The memory is guaranteed to be resident and locked down.
5317c478bd9Sstevel@tonic-gate  */
5327c478bd9Sstevel@tonic-gate caddr_t
prmapin(struct as * as,caddr_t addr,int writing)5337c478bd9Sstevel@tonic-gate prmapin(struct as *as, caddr_t addr, int writing)
5347c478bd9Sstevel@tonic-gate {
5357c478bd9Sstevel@tonic-gate 	page_t *pp;
5367c478bd9Sstevel@tonic-gate 	caddr_t kaddr;
5377c478bd9Sstevel@tonic-gate 	pfn_t pfnum;
5387c478bd9Sstevel@tonic-gate 
5397c478bd9Sstevel@tonic-gate 	/*
5407c478bd9Sstevel@tonic-gate 	 * XXX - Because of past mistakes, we have bits being returned
5417c478bd9Sstevel@tonic-gate 	 * by getpfnum that are actually the page type bits of the pte.
5427c478bd9Sstevel@tonic-gate 	 * When the object we are trying to map is a memory page with
5437c478bd9Sstevel@tonic-gate 	 * a page structure everything is ok and we can use the optimal
5447c478bd9Sstevel@tonic-gate 	 * method, ppmapin.  Otherwise, we have to do something special.
5457c478bd9Sstevel@tonic-gate 	 */
5467c478bd9Sstevel@tonic-gate 	pfnum = hat_getpfnum(as->a_hat, addr);
5477c478bd9Sstevel@tonic-gate 	if (pf_is_memory(pfnum)) {
5487c478bd9Sstevel@tonic-gate 		pp = page_numtopp_nolock(pfnum);
5497c478bd9Sstevel@tonic-gate 		if (pp != NULL) {
5507c478bd9Sstevel@tonic-gate 			ASSERT(PAGE_LOCKED(pp));
5517c478bd9Sstevel@tonic-gate 			kaddr = ppmapin(pp, writing ?
5527c478bd9Sstevel@tonic-gate 			    (PROT_READ | PROT_WRITE) : PROT_READ, (caddr_t)-1);
5537c478bd9Sstevel@tonic-gate 			return (kaddr + ((uintptr_t)addr & PAGEOFFSET));
5547c478bd9Sstevel@tonic-gate 		}
5557c478bd9Sstevel@tonic-gate 	}
5567c478bd9Sstevel@tonic-gate 
5577c478bd9Sstevel@tonic-gate 	/*
5587c478bd9Sstevel@tonic-gate 	 * Oh well, we didn't have a page struct for the object we were
5597c478bd9Sstevel@tonic-gate 	 * trying to map in; ppmapin doesn't handle devices, but allocating a
5607c478bd9Sstevel@tonic-gate 	 * heap address allows ppmapout to free virtual space when done.
5617c478bd9Sstevel@tonic-gate 	 */
5627c478bd9Sstevel@tonic-gate 	kaddr = vmem_alloc(heap_arena, PAGESIZE, VM_SLEEP);
5637c478bd9Sstevel@tonic-gate 
5647c478bd9Sstevel@tonic-gate 	hat_devload(kas.a_hat, kaddr, MMU_PAGESIZE,  pfnum,
5657c478bd9Sstevel@tonic-gate 	    writing ? (PROT_READ | PROT_WRITE) : PROT_READ, 0);
5667c478bd9Sstevel@tonic-gate 
5677c478bd9Sstevel@tonic-gate 	return (kaddr + ((uintptr_t)addr & PAGEOFFSET));
5687c478bd9Sstevel@tonic-gate }
5697c478bd9Sstevel@tonic-gate 
5707c478bd9Sstevel@tonic-gate /*
5717c478bd9Sstevel@tonic-gate  * Unmap address "addr" in address space "as"; inverse of prmapin().
5727c478bd9Sstevel@tonic-gate  */
5737c478bd9Sstevel@tonic-gate /* ARGSUSED */
5747c478bd9Sstevel@tonic-gate void
prmapout(struct as * as,caddr_t addr,caddr_t vaddr,int writing)5757c478bd9Sstevel@tonic-gate prmapout(struct as *as, caddr_t addr, caddr_t vaddr, int writing)
5767c478bd9Sstevel@tonic-gate {
5777c478bd9Sstevel@tonic-gate 	extern void ppmapout(caddr_t);
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate 	vaddr = (caddr_t)((uintptr_t)vaddr & PAGEMASK);
5807c478bd9Sstevel@tonic-gate 	ppmapout(vaddr);
5817c478bd9Sstevel@tonic-gate }
5827c478bd9Sstevel@tonic-gate 
5837c478bd9Sstevel@tonic-gate /*
5847c478bd9Sstevel@tonic-gate  * Make sure the lwp is in an orderly state
5857c478bd9Sstevel@tonic-gate  * for inspection by a debugger through /proc.
58607a48826SRoger A. Faulkner  *
58707a48826SRoger A. Faulkner  * This needs to be called only once while the current thread remains in the
58807a48826SRoger A. Faulkner  * kernel and needs to be called while holding no resources (mutex locks, etc).
58907a48826SRoger A. Faulkner  *
59007a48826SRoger A. Faulkner  * As a hedge against these conditions, if prstop() is called repeatedly
59107a48826SRoger A. Faulkner  * before prunstop() is called, it does nothing and just returns.
59207a48826SRoger A. Faulkner  *
59307a48826SRoger A. Faulkner  * prunstop() must be called before the thread returns to user level.
5947c478bd9Sstevel@tonic-gate  */
5957c478bd9Sstevel@tonic-gate /* ARGSUSED */
5967c478bd9Sstevel@tonic-gate void
prstop(int why,int what)5977c478bd9Sstevel@tonic-gate prstop(int why, int what)
5987c478bd9Sstevel@tonic-gate {
5997c478bd9Sstevel@tonic-gate 	klwp_t *lwp = ttolwp(curthread);
6007c478bd9Sstevel@tonic-gate 	struct regs *r = lwptoregs(lwp);
6017c478bd9Sstevel@tonic-gate 
60207a48826SRoger A. Faulkner 	if (lwp->lwp_pcb.pcb_flags & PRSTOP_CALLED)
60307a48826SRoger A. Faulkner 		return;
60407a48826SRoger A. Faulkner 
6057c478bd9Sstevel@tonic-gate 	/*
6068548bf79Snr 	 * Make sure we don't deadlock on a recursive call
6078548bf79Snr 	 * to prstop().  stop() tests the lwp_nostop flag.
6087c478bd9Sstevel@tonic-gate 	 */
6098548bf79Snr 	ASSERT(lwp->lwp_nostop == 0);
6108548bf79Snr 	lwp->lwp_nostop = 1;
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate 	if (copyin_nowatch((caddr_t)r->r_pc, &lwp->lwp_pcb.pcb_instr,
61307a48826SRoger A. Faulkner 	    sizeof (lwp->lwp_pcb.pcb_instr)) == 0)
6147c478bd9Sstevel@tonic-gate 		lwp->lwp_pcb.pcb_flags |= INSTR_VALID;
6157c478bd9Sstevel@tonic-gate 	else {
6167c478bd9Sstevel@tonic-gate 		lwp->lwp_pcb.pcb_flags &= ~INSTR_VALID;
6177c478bd9Sstevel@tonic-gate 		lwp->lwp_pcb.pcb_instr = 0;
6187c478bd9Sstevel@tonic-gate 	}
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate 	(void) save_syscall_args();
6218548bf79Snr 	ASSERT(lwp->lwp_nostop == 1);
6228548bf79Snr 	lwp->lwp_nostop = 0;
62307a48826SRoger A. Faulkner 
62407a48826SRoger A. Faulkner 	lwp->lwp_pcb.pcb_flags |= PRSTOP_CALLED;
62507a48826SRoger A. Faulkner 	aston(curthread);	/* so prunstop() will be called */
62607a48826SRoger A. Faulkner }
62707a48826SRoger A. Faulkner 
62807a48826SRoger A. Faulkner /*
62907a48826SRoger A. Faulkner  * Inform prstop() that it should do its work again
63007a48826SRoger A. Faulkner  * the next time it is called.
63107a48826SRoger A. Faulkner  */
63207a48826SRoger A. Faulkner void
prunstop(void)63307a48826SRoger A. Faulkner prunstop(void)
63407a48826SRoger A. Faulkner {
63507a48826SRoger A. Faulkner 	ttolwp(curthread)->lwp_pcb.pcb_flags &= ~PRSTOP_CALLED;
6367c478bd9Sstevel@tonic-gate }
6377c478bd9Sstevel@tonic-gate 
6387c478bd9Sstevel@tonic-gate /*
6397c478bd9Sstevel@tonic-gate  * Fetch the user-level instruction on which the lwp is stopped.
6407c478bd9Sstevel@tonic-gate  * It was saved by the lwp itself, in prstop().
6417c478bd9Sstevel@tonic-gate  * Return non-zero if the instruction is valid.
6427c478bd9Sstevel@tonic-gate  */
6437c478bd9Sstevel@tonic-gate int
prfetchinstr(klwp_t * lwp,ulong_t * ip)6447c478bd9Sstevel@tonic-gate prfetchinstr(klwp_t *lwp, ulong_t *ip)
6457c478bd9Sstevel@tonic-gate {
6467c478bd9Sstevel@tonic-gate 	*ip = (ulong_t)(instr_t)lwp->lwp_pcb.pcb_instr;
6477c478bd9Sstevel@tonic-gate 	return (lwp->lwp_pcb.pcb_flags & INSTR_VALID);
6487c478bd9Sstevel@tonic-gate }
6497c478bd9Sstevel@tonic-gate 
6507c478bd9Sstevel@tonic-gate /*
6517c478bd9Sstevel@tonic-gate  * Called from trap() when a load or store instruction
6527c478bd9Sstevel@tonic-gate  * falls in a watched page but is not a watchpoint.
6537c478bd9Sstevel@tonic-gate  * We emulate the instruction in the kernel.
6547c478bd9Sstevel@tonic-gate  */
6557c478bd9Sstevel@tonic-gate /* ARGSUSED */
6567c478bd9Sstevel@tonic-gate int
pr_watch_emul(struct regs * rp,caddr_t addr,enum seg_rw rw)6577c478bd9Sstevel@tonic-gate pr_watch_emul(struct regs *rp, caddr_t addr, enum seg_rw rw)
6587c478bd9Sstevel@tonic-gate {
6597c478bd9Sstevel@tonic-gate #ifdef SOMEDAY
6607c478bd9Sstevel@tonic-gate 	int res;
6617c478bd9Sstevel@tonic-gate 	proc_t *p = curproc;
6627c478bd9Sstevel@tonic-gate 	char *badaddr = (caddr_t)(-1);
6637c478bd9Sstevel@tonic-gate 	int mapped;
6647c478bd9Sstevel@tonic-gate 
6657c478bd9Sstevel@tonic-gate 	/* prevent recursive calls to pr_watch_emul() */
6667c478bd9Sstevel@tonic-gate 	ASSERT(!(curthread->t_flag & T_WATCHPT));
6677c478bd9Sstevel@tonic-gate 	curthread->t_flag |= T_WATCHPT;
6687c478bd9Sstevel@tonic-gate 
6697c478bd9Sstevel@tonic-gate 	watch_disable_addr(addr, 8, rw);
6707c478bd9Sstevel@tonic-gate 	res = do_unaligned(rp, &badaddr);
6717c478bd9Sstevel@tonic-gate 	watch_enable_addr(addr, 8, rw);
6727c478bd9Sstevel@tonic-gate 
6737c478bd9Sstevel@tonic-gate 	curthread->t_flag &= ~T_WATCHPT;
6747c478bd9Sstevel@tonic-gate 	if (res == SIMU_SUCCESS) {
6757c478bd9Sstevel@tonic-gate 		/* adjust the pc */
6767c478bd9Sstevel@tonic-gate 		return (1);
6777c478bd9Sstevel@tonic-gate 	}
6787c478bd9Sstevel@tonic-gate #endif
6797c478bd9Sstevel@tonic-gate 	return (0);
6807c478bd9Sstevel@tonic-gate }
6817c478bd9Sstevel@tonic-gate 
6827c478bd9Sstevel@tonic-gate /*
6837c478bd9Sstevel@tonic-gate  * Return the number of active entries in the local descriptor table.
6847c478bd9Sstevel@tonic-gate  */
6857c478bd9Sstevel@tonic-gate int
prnldt(proc_t * p)6867c478bd9Sstevel@tonic-gate prnldt(proc_t *p)
6877c478bd9Sstevel@tonic-gate {
6887c478bd9Sstevel@tonic-gate 	int limit, i, n;
6897c478bd9Sstevel@tonic-gate 	user_desc_t *udp;
6907c478bd9Sstevel@tonic-gate 
6917c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_ldtlock));
6927c478bd9Sstevel@tonic-gate 
6937c478bd9Sstevel@tonic-gate 	/*
694ddece0baSsethg 	 * Currently 64 bit processes cannot have private LDTs.
6957c478bd9Sstevel@tonic-gate 	 */
696ddece0baSsethg 	ASSERT(p->p_model != DATAMODEL_LP64 || p->p_ldt == NULL);
6977c478bd9Sstevel@tonic-gate 
6987c478bd9Sstevel@tonic-gate 	if (p->p_ldt == NULL)
6997c478bd9Sstevel@tonic-gate 		return (0);
7007c478bd9Sstevel@tonic-gate 	n = 0;
7017c478bd9Sstevel@tonic-gate 	limit = p->p_ldtlimit;
7027c478bd9Sstevel@tonic-gate 	ASSERT(limit >= 0 && limit < MAXNLDT);
7037c478bd9Sstevel@tonic-gate 
7047c478bd9Sstevel@tonic-gate 	/*
7057c478bd9Sstevel@tonic-gate 	 * Count all present user descriptors.
7067c478bd9Sstevel@tonic-gate 	 */
7077c478bd9Sstevel@tonic-gate 	for (i = LDT_UDBASE, udp = &p->p_ldt[i]; i <= limit; i++, udp++)
7087c478bd9Sstevel@tonic-gate 		if (udp->usd_type != 0 || udp->usd_dpl != 0 || udp->usd_p != 0)
7097c478bd9Sstevel@tonic-gate 			n++;
7107c478bd9Sstevel@tonic-gate 	return (n);
7117c478bd9Sstevel@tonic-gate }
7127c478bd9Sstevel@tonic-gate 
7137c478bd9Sstevel@tonic-gate /*
7147c478bd9Sstevel@tonic-gate  * Fetch the active entries from the local descriptor table.
7157c478bd9Sstevel@tonic-gate  */
7167c478bd9Sstevel@tonic-gate void
prgetldt(proc_t * p,struct ssd * ssd)7177c478bd9Sstevel@tonic-gate prgetldt(proc_t *p, struct ssd *ssd)
7187c478bd9Sstevel@tonic-gate {
7197c478bd9Sstevel@tonic-gate 	int i, limit;
7207c478bd9Sstevel@tonic-gate 	user_desc_t *udp;
7217c478bd9Sstevel@tonic-gate 
7227c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_ldtlock));
7237c478bd9Sstevel@tonic-gate 
7247c478bd9Sstevel@tonic-gate 	if (p->p_ldt == NULL)
7257c478bd9Sstevel@tonic-gate 		return;
7267c478bd9Sstevel@tonic-gate 
7277c478bd9Sstevel@tonic-gate 	limit = p->p_ldtlimit;
7287c478bd9Sstevel@tonic-gate 	ASSERT(limit >= 0 && limit < MAXNLDT);
7297c478bd9Sstevel@tonic-gate 
7307c478bd9Sstevel@tonic-gate 	/*
7317c478bd9Sstevel@tonic-gate 	 * All present user descriptors.
7327c478bd9Sstevel@tonic-gate 	 */
7337c478bd9Sstevel@tonic-gate 	for (i = LDT_UDBASE, udp = &p->p_ldt[i]; i <= limit; i++, udp++)
7347c478bd9Sstevel@tonic-gate 		if (udp->usd_type != 0 || udp->usd_dpl != 0 ||
7357c478bd9Sstevel@tonic-gate 		    udp->usd_p != 0)
7367c478bd9Sstevel@tonic-gate 			usd_to_ssd(udp, ssd++, SEL_LDT(i));
7377c478bd9Sstevel@tonic-gate }
738