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 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #include "thr_uberdata.h"
28 #include <sys/stack.h>
29
30 /*
31 * Initialization of the main stack is performed in libc_init().
32 * Initialization of thread stacks is performed in _thrp_setup().
33 */
34
35 #pragma weak _stack_getbounds = stack_getbounds
36 int
stack_getbounds(stack_t * sp)37 stack_getbounds(stack_t *sp)
38 {
39 *sp = curthread->ul_ustack;
40 return (0);
41 }
42
43 #pragma weak _stack_setbounds = stack_setbounds
44 int
stack_setbounds(const stack_t * sp)45 stack_setbounds(const stack_t *sp)
46 {
47 ulwp_t *self = curthread;
48
49 if (sp == NULL || sp->ss_sp == NULL ||
50 (uintptr_t)sp->ss_sp != SA((uintptr_t)sp->ss_sp) ||
51 sp->ss_flags != 0 || sp->ss_size < MINSIGSTKSZ ||
52 (uintptr_t)sp->ss_size != SA((uintptr_t)sp->ss_size)) {
53 errno = EINVAL;
54 return (-1);
55 }
56
57 sigoff(self);
58 self->ul_ustack = *sp;
59 sigon(self);
60
61 return (0);
62 }
63
64 /*
65 * Returns a boolean value:
66 * 1 addr is within the bounds of the current stack
67 * 0 addr is outside of the bounds of the current stack
68 * Note that addr is an unbiased value.
69 */
70 #pragma weak _stack_inbounds = stack_inbounds
71 int
stack_inbounds(void * addr)72 stack_inbounds(void *addr)
73 {
74 stack_t *ustackp = &curthread->ul_ustack;
75 uintptr_t base = (uintptr_t)ustackp->ss_sp;
76 size_t size = ustackp->ss_size;
77
78 return ((uintptr_t)addr >= base && (uintptr_t)addr < base + size);
79 }
80
81 #pragma weak _stack_violation = stack_violation
82 int
stack_violation(int sig,const siginfo_t * sip,const ucontext_t * ucp)83 stack_violation(int sig, const siginfo_t *sip, const ucontext_t *ucp)
84 {
85 uintptr_t addr;
86 uintptr_t base;
87 size_t size;
88
89 if ((sig != SIGSEGV && sig != SIGBUS) ||
90 sip == NULL || ucp == NULL || SI_FROMUSER(sip))
91 return (0);
92
93 /*
94 * ucp has the correct view of the stack when the signal was raised.
95 */
96 base = (uintptr_t)ucp->uc_stack.ss_sp;
97 size = ucp->uc_stack.ss_size;
98 #if defined(__sparc)
99 addr = ucp->uc_mcontext.gregs[REG_SP] + STACK_BIAS;
100 #elif defined(__amd64) || defined(__i386)
101 addr = ucp->uc_mcontext.gregs[REG_SP];
102 /*
103 * If the faulted address is just below the stack pointer we
104 * might be looking at a push instruction that caused the fault
105 * (the largest amount a push instruction can decrement the
106 * stack pointer by is 32). In that case, use the faulted
107 * address in our computation rather than the stack pointer.
108 */
109 if (addr - (uintptr_t)sip->si_addr < 32)
110 addr = (uintptr_t)sip->si_addr;
111 #else
112 #error "none of __sparc, __amd64, __i386 is defined"
113 #endif
114 return (!(addr >= base && addr < base + size));
115 }
116