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 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include "misc.h"
30 #include <ucontext.h>
31 #include <sys/frame.h>
32 #include <sys/stack.h>
33 #include <stdio.h>
34
35 #if defined(__sparc) || defined(__sparcv9)
36 extern void flush_windows(void);
37 #define UMEM_FRAMESIZE MINFRAME
38
39 #elif defined(__i386) || defined(__amd64)
40 /*
41 * On x86, MINFRAME is defined to be 0, but we want to be sure we can
42 * dereference the entire frame structure.
43 */
44 #define UMEM_FRAMESIZE (sizeof (struct frame))
45
46 #else
47 #error needs update for new architecture
48 #endif
49
50 /*
51 * Get a pc-only stacktrace. Used for kmem_alloc() buffer ownership tracking.
52 * Returns MIN(current stack depth, pcstack_limit).
53 */
54 /*ARGSUSED*/
55 int
getpcstack(uintptr_t * pcstack,int pcstack_limit,int check_signal)56 getpcstack(uintptr_t *pcstack, int pcstack_limit, int check_signal)
57 {
58 struct frame *fp;
59 struct frame *nextfp, *minfp;
60 int depth = 0;
61 uintptr_t base = 0;
62 size_t size = 0;
63 #ifndef UMEM_STANDALONE
64 int on_altstack = 0;
65 uintptr_t sigbase = 0;
66 size_t sigsize = 0;
67
68 stack_t st;
69
70 if (stack_getbounds(&st) != 0) {
71 if (thr_stksegment(&st) != 0 ||
72 (uintptr_t)st.ss_sp < st.ss_size) {
73 return (0); /* unable to get stack bounds */
74 }
75 /*
76 * thr_stksegment(3C) has a slightly different interface than
77 * stack_getbounds(3C) -- correct it
78 */
79 st.ss_sp = (void *)(((uintptr_t)st.ss_sp) - st.ss_size);
80 st.ss_flags = 0; /* can't be on-stack */
81 }
82 on_altstack = (st.ss_flags & SS_ONSTACK);
83
84 if (st.ss_size != 0) {
85 base = (uintptr_t)st.ss_sp;
86 size = st.ss_size;
87 } else {
88 /*
89 * If size == 0, then ss_sp is the *top* of the stack.
90 *
91 * Since we only allow increasing frame pointers, and we
92 * know our caller set his up correctly, we can treat ss_sp
93 * as an upper bound safely.
94 */
95 base = 0;
96 size = (uintptr_t)st.ss_sp;
97 }
98
99 if (check_signal != 0) {
100 void (*sigfunc)() = NULL;
101 int sigfuncsize = 0;
102 extern void thr_sighndlrinfo(void (**)(), int *);
103
104 thr_sighndlrinfo(&sigfunc, &sigfuncsize);
105 sigbase = (uintptr_t)sigfunc;
106 sigsize = sigfuncsize;
107 }
108 #else /* UMEM_STANDALONE */
109 base = (uintptr_t)umem_min_stack;
110 size = umem_max_stack - umem_min_stack;
111 #endif
112
113 /*
114 * shorten size so that fr_savfp and fr_savpc will be within the stack
115 * bounds.
116 */
117 if (size >= UMEM_FRAMESIZE - 1)
118 size -= (UMEM_FRAMESIZE - 1);
119 else
120 size = 0;
121
122 #if defined(__sparc) || defined(__sparcv9)
123 flush_windows();
124 #endif
125
126 /* LINTED alignment */
127 fp = (struct frame *)((caddr_t)getfp() + STACK_BIAS);
128
129 minfp = fp;
130
131 if (((uintptr_t)fp - base) >= size)
132 return (0); /* the frame pointer isn't in our stack */
133
134 while (depth < pcstack_limit) {
135 uintptr_t tmp;
136
137 /* LINTED alignment */
138 nextfp = (struct frame *)((caddr_t)fp->fr_savfp + STACK_BIAS);
139 tmp = (uintptr_t)nextfp;
140
141 /*
142 * Check nextfp for validity. It must be properly aligned,
143 * increasing compared to the last %fp (or the top of the
144 * stack we just switched to), and it must be inside
145 * [base, base + size).
146 */
147 if (tmp != SA(tmp))
148 break;
149 else if (nextfp <= minfp || (tmp - base) >= size) {
150 #ifndef UMEM_STANDALONE
151 if (tmp == NULL || !on_altstack)
152 break;
153 /*
154 * If we're on an alternate signal stack, try jumping
155 * to the main thread stack.
156 *
157 * If the main thread stack has an unlimited size, we
158 * punt, since we don't know where the frame pointer's
159 * been.
160 *
161 * (thr_stksegment() returns the *top of stack*
162 * in ss_sp, not the bottom)
163 */
164 if (thr_stksegment(&st) == 0) {
165 if (st.ss_size >= (uintptr_t)st.ss_sp ||
166 st.ss_size < UMEM_FRAMESIZE - 1)
167 break;
168
169 on_altstack = 0;
170 base = (uintptr_t)st.ss_sp - st.ss_size;
171 size = st.ss_size - (UMEM_FRAMESIZE - 1);
172 minfp = (struct frame *)base;
173 continue; /* try again */
174 }
175 #endif
176 break;
177 }
178
179 #ifndef UMEM_STANDALONE
180 if (check_signal && (fp->fr_savpc - sigbase) <= sigsize)
181 umem_panic("called from signal handler");
182 #endif
183 pcstack[depth++] = fp->fr_savpc;
184 fp = nextfp;
185 minfp = fp;
186 }
187 return (depth);
188 }
189