1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28/*	  All Rights Reserved  	*/
29
30#include <sys/param.h>
31#include <sys/types.h>
32#include <sys/vmparam.h>
33#include <sys/systm.h>
34#include <sys/signal.h>
35#include <sys/stack.h>
36#include <sys/regset.h>
37#include <sys/privregs.h>
38#include <sys/frame.h>
39#include <sys/proc.h>
40#include <sys/brand.h>
41#include <sys/psw.h>
42#include <sys/ucontext.h>
43#include <sys/asm_linkage.h>
44#include <sys/errno.h>
45#include <sys/archsystm.h>
46#include <sys/schedctl.h>
47#include <sys/debug.h>
48#include <sys/sysmacros.h>
49
50/*
51 * Save user context.
52 */
53void
54savecontext(ucontext_t *ucp, const k_sigset_t *mask)
55{
56	proc_t *p = ttoproc(curthread);
57	klwp_t *lwp = ttolwp(curthread);
58	struct regs *rp = lwptoregs(lwp);
59
60	/*
61	 * We unconditionally assign to every field through the end
62	 * of the gregs, but we need to bzero() everything -after- that
63	 * to avoid having any kernel stack garbage escape to userland.
64	 */
65	bzero(&ucp->uc_mcontext.fpregs, sizeof (ucontext_t) -
66	    offsetof(ucontext_t, uc_mcontext.fpregs));
67
68	ucp->uc_flags = UC_ALL;
69	ucp->uc_link = (struct ucontext *)lwp->lwp_oldcontext;
70
71	/*
72	 * Try to copyin() the ustack if one is registered. If the stack
73	 * has zero size, this indicates that stack bounds checking has
74	 * been disabled for this LWP. If stack bounds checking is disabled
75	 * or the copyin() fails, we fall back to the legacy behavior.
76	 */
77	if (lwp->lwp_ustack == (uintptr_t)NULL ||
78	    copyin((void *)lwp->lwp_ustack, &ucp->uc_stack,
79	    sizeof (ucp->uc_stack)) != 0 ||
80	    ucp->uc_stack.ss_size == 0) {
81
82		if (lwp->lwp_sigaltstack.ss_flags == SS_ONSTACK) {
83			ucp->uc_stack = lwp->lwp_sigaltstack;
84		} else {
85			ucp->uc_stack.ss_sp = p->p_usrstack - p->p_stksize;
86			ucp->uc_stack.ss_size = p->p_stksize;
87			ucp->uc_stack.ss_flags = 0;
88		}
89	}
90
91	/*
92	 * If either the trace flag or REQUEST_STEP is set,
93	 * arrange for single-stepping and turn off the trace flag.
94	 */
95	if ((rp->r_ps & PS_T) || (lwp->lwp_pcb.pcb_flags & REQUEST_STEP)) {
96		/*
97		 * Clear PS_T so that saved user context won't have trace
98		 * flag set.
99		 */
100		rp->r_ps &= ~PS_T;
101
102		if (!(lwp->lwp_pcb.pcb_flags & REQUEST_NOSTEP)) {
103			lwp->lwp_pcb.pcb_flags |= DEBUG_PENDING;
104			/*
105			 * trap() always checks DEBUG_PENDING before
106			 * checking for any pending signal. This at times
107			 * can potentially lead to DEBUG_PENDING not being
108			 * honoured. (for eg: the lwp is stopped by
109			 * stop_on_fault() called from trap(), after being
110			 * awakened it might see a pending signal and call
111			 * savecontext(), however on the way back to userland
112			 * there is no place it can be detected). Hence in
113			 * anticipation of such occassions, set AST flag for
114			 * the thread which will make the thread take an
115			 * excursion through trap() where it will be handled
116			 * appropriately.
117			 */
118			aston(curthread);
119		}
120	}
121
122	getgregs(lwp, ucp->uc_mcontext.gregs);
123	if (lwp->lwp_pcb.pcb_fpu.fpu_flags & FPU_EN)
124		getfpregs(lwp, &ucp->uc_mcontext.fpregs);
125	else
126		ucp->uc_flags &= ~UC_FPU;
127
128	sigktou(mask, &ucp->uc_sigmask);
129}
130
131/*
132 * Restore user context.
133 */
134void
135restorecontext(ucontext_t *ucp)
136{
137	kthread_t *t = curthread;
138	klwp_t *lwp = ttolwp(t);
139
140	lwp->lwp_oldcontext = (uintptr_t)ucp->uc_link;
141
142	if (ucp->uc_flags & UC_STACK) {
143		if (ucp->uc_stack.ss_flags == SS_ONSTACK)
144			lwp->lwp_sigaltstack = ucp->uc_stack;
145		else
146			lwp->lwp_sigaltstack.ss_flags &= ~SS_ONSTACK;
147	}
148
149	if (ucp->uc_flags & UC_CPU) {
150		/*
151		 * If the trace flag is set, mark the lwp to take a
152		 * single-step trap on return to user level (below).
153		 * The x86 lcall interface and sysenter has already done this,
154		 * and turned off the flag, but amd64 syscall interface has not.
155		 */
156		if (lwptoregs(lwp)->r_ps & PS_T)
157			lwp->lwp_pcb.pcb_flags |= DEBUG_PENDING;
158		setgregs(lwp, ucp->uc_mcontext.gregs);
159		lwp->lwp_eosys = JUSTRETURN;
160		t->t_post_sys = 1;
161		aston(curthread);
162	}
163
164	if (ucp->uc_flags & UC_FPU)
165		setfpregs(lwp, &ucp->uc_mcontext.fpregs);
166
167	if (ucp->uc_flags & UC_SIGMASK) {
168		/*
169		 * We don't need to acquire p->p_lock here;
170		 * we are manipulating thread-private data.
171		 */
172		schedctl_finish_sigblock(t);
173		sigutok(&ucp->uc_sigmask, &t->t_hold);
174		if (sigcheck(ttoproc(t), t))
175			t->t_sig_check = 1;
176	}
177}
178
179
180int
181getsetcontext(int flag, void *arg)
182{
183	ucontext_t uc;
184	ucontext_t *ucp;
185	klwp_t *lwp = ttolwp(curthread);
186	stack_t dummy_stk;
187
188	/*
189	 * In future releases, when the ucontext structure grows,
190	 * getcontext should be modified to only return the fields
191	 * specified in the uc_flags.  That way, the structure can grow
192	 * and still be binary compatible will all .o's which will only
193	 * have old fields defined in uc_flags
194	 */
195
196	switch (flag) {
197	default:
198		return (set_errno(EINVAL));
199
200	case GETCONTEXT:
201		schedctl_finish_sigblock(curthread);
202		savecontext(&uc, &curthread->t_hold);
203		if (uc.uc_flags & UC_SIGMASK)
204			SIGSET_NATIVE_TO_BRAND(&uc.uc_sigmask);
205		if (copyout(&uc, arg, sizeof (uc)))
206			return (set_errno(EFAULT));
207		return (0);
208
209	case SETCONTEXT:
210		ucp = arg;
211		if (ucp == NULL)
212			exit(CLD_EXITED, 0);
213		/*
214		 * Don't copyin filler or floating state unless we need it.
215		 * The ucontext_t struct and fields are specified in the ABI.
216		 */
217		if (copyin(ucp, &uc, sizeof (ucontext_t) -
218		    sizeof (uc.uc_filler) -
219		    sizeof (uc.uc_mcontext.fpregs))) {
220			return (set_errno(EFAULT));
221		}
222		if (uc.uc_flags & UC_SIGMASK)
223			SIGSET_BRAND_TO_NATIVE(&uc.uc_sigmask);
224
225		if ((uc.uc_flags & UC_FPU) &&
226		    copyin(&ucp->uc_mcontext.fpregs, &uc.uc_mcontext.fpregs,
227		    sizeof (uc.uc_mcontext.fpregs))) {
228			return (set_errno(EFAULT));
229		}
230
231		restorecontext(&uc);
232
233		if ((uc.uc_flags & UC_STACK) && (lwp->lwp_ustack != 0))
234			(void) copyout(&uc.uc_stack, (stack_t *)lwp->lwp_ustack,
235			    sizeof (uc.uc_stack));
236		return (0);
237
238	case GETUSTACK:
239		if (copyout(&lwp->lwp_ustack, arg, sizeof (caddr_t)))
240			return (set_errno(EFAULT));
241		return (0);
242
243	case SETUSTACK:
244		if (copyin(arg, &dummy_stk, sizeof (dummy_stk)))
245			return (set_errno(EFAULT));
246		lwp->lwp_ustack = (uintptr_t)arg;
247		return (0);
248	}
249}
250
251#ifdef _SYSCALL32_IMPL
252
253/*
254 * Save user context for 32-bit processes.
255 */
256void
257savecontext32(ucontext32_t *ucp, const k_sigset_t *mask)
258{
259	proc_t *p = ttoproc(curthread);
260	klwp_t *lwp = ttolwp(curthread);
261	struct regs *rp = lwptoregs(lwp);
262
263	bzero(&ucp->uc_mcontext.fpregs, sizeof (ucontext32_t) -
264	    offsetof(ucontext32_t, uc_mcontext.fpregs));
265
266	ucp->uc_flags = UC_ALL;
267	ucp->uc_link = (caddr32_t)lwp->lwp_oldcontext;
268
269	if (lwp->lwp_ustack == (uintptr_t)NULL ||
270	    copyin((void *)lwp->lwp_ustack, &ucp->uc_stack,
271	    sizeof (ucp->uc_stack)) != 0 ||
272	    ucp->uc_stack.ss_size == 0) {
273
274		if (lwp->lwp_sigaltstack.ss_flags == SS_ONSTACK) {
275			ucp->uc_stack.ss_sp =
276			    (caddr32_t)(uintptr_t)lwp->lwp_sigaltstack.ss_sp;
277			ucp->uc_stack.ss_size =
278			    (size32_t)lwp->lwp_sigaltstack.ss_size;
279			ucp->uc_stack.ss_flags = SS_ONSTACK;
280		} else {
281			ucp->uc_stack.ss_sp = (caddr32_t)(uintptr_t)
282			    (p->p_usrstack - p->p_stksize);
283			ucp->uc_stack.ss_size = (size32_t)p->p_stksize;
284			ucp->uc_stack.ss_flags = 0;
285		}
286	}
287
288	/*
289	 * If either the trace flag or REQUEST_STEP is set, arrange
290	 * for single-stepping and turn off the trace flag.
291	 */
292	if ((rp->r_ps & PS_T) || (lwp->lwp_pcb.pcb_flags & REQUEST_STEP)) {
293		/*
294		 * Clear PS_T so that saved user context won't have trace
295		 * flag set.
296		 */
297		rp->r_ps &= ~PS_T;
298
299		if (!(lwp->lwp_pcb.pcb_flags & REQUEST_NOSTEP)) {
300			lwp->lwp_pcb.pcb_flags |= DEBUG_PENDING;
301			/*
302			 * See comments in savecontext().
303			 */
304			aston(curthread);
305		}
306	}
307
308	getgregs32(lwp, ucp->uc_mcontext.gregs);
309	if (lwp->lwp_pcb.pcb_fpu.fpu_flags & FPU_EN)
310		getfpregs32(lwp, &ucp->uc_mcontext.fpregs);
311	else
312		ucp->uc_flags &= ~UC_FPU;
313
314	sigktou(mask, &ucp->uc_sigmask);
315}
316
317int
318getsetcontext32(int flag, void *arg)
319{
320	ucontext32_t uc;
321	ucontext_t ucnat;
322	ucontext32_t *ucp;
323	klwp_t *lwp = ttolwp(curthread);
324	caddr32_t ustack32;
325	stack32_t dummy_stk32;
326
327	switch (flag) {
328	default:
329		return (set_errno(EINVAL));
330
331	case GETCONTEXT:
332		schedctl_finish_sigblock(curthread);
333		savecontext32(&uc, &curthread->t_hold);
334		if (uc.uc_flags & UC_SIGMASK)
335			SIGSET_NATIVE_TO_BRAND(&uc.uc_sigmask);
336		if (copyout(&uc, arg, sizeof (uc)))
337			return (set_errno(EFAULT));
338		return (0);
339
340	case SETCONTEXT:
341		ucp = arg;
342		if (ucp == NULL)
343			exit(CLD_EXITED, 0);
344		if (copyin(ucp, &uc, sizeof (uc) -
345		    sizeof (uc.uc_filler) -
346		    sizeof (uc.uc_mcontext.fpregs))) {
347			return (set_errno(EFAULT));
348		}
349		if (uc.uc_flags & UC_SIGMASK)
350			SIGSET_BRAND_TO_NATIVE(&uc.uc_sigmask);
351		if ((uc.uc_flags & UC_FPU) &&
352		    copyin(&ucp->uc_mcontext.fpregs, &uc.uc_mcontext.fpregs,
353		    sizeof (uc.uc_mcontext.fpregs))) {
354			return (set_errno(EFAULT));
355		}
356
357		ucontext_32ton(&uc, &ucnat);
358		restorecontext(&ucnat);
359
360		if ((uc.uc_flags & UC_STACK) && (lwp->lwp_ustack != 0))
361			(void) copyout(&uc.uc_stack,
362			    (stack32_t *)lwp->lwp_ustack, sizeof (uc.uc_stack));
363		return (0);
364
365	case GETUSTACK:
366		ustack32 = (caddr32_t)lwp->lwp_ustack;
367		if (copyout(&ustack32, arg, sizeof (ustack32)))
368			return (set_errno(EFAULT));
369		return (0);
370
371	case SETUSTACK:
372		if (copyin(arg, &dummy_stk32, sizeof (dummy_stk32)))
373			return (set_errno(EFAULT));
374		lwp->lwp_ustack = (uintptr_t)arg;
375		return (0);
376	}
377}
378
379#endif	/* _SYSCALL32_IMPL */
380