4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
25 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
26 * Use is subject to license terms.
28 #include <sys/cdefs.h>
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
33 #include <sys/stack.h>
36 #include <machine/frame.h>
37 #include <machine/md_var.h>
40 #include <vm/vm_param.h>
43 #include <machine/atomic.h>
44 #include <machine/db_machdep.h>
45 #include <machine/md_var.h>
46 #include <machine/stack.h>
47 #include <ddb/db_sym.h>
54 * Wee need some reasonable default to prevent backtrace code
55 * from wandering too far
57 #define MAX_FUNCTION_SIZE 0x10000
58 #define MAX_PROLOGUE_SIZE 0x100
61 uint8_t dtrace_fuword8_nocheck(void *);
62 uint16_t dtrace_fuword16_nocheck(void *);
63 uint32_t dtrace_fuword32_nocheck(void *);
64 uint64_t dtrace_fuword64_nocheck(void *);
67 dtrace_getpcstack(pc_t *pcstack, int pcstack_limit, int aframes,
70 struct unwind_state state;
76 pcstack[depth++] = (pc_t) intrpc;
80 __asm __volatile("mov %0, sp" : "=&r" (sp));
82 state.registers[FP] = (uint32_t)__builtin_frame_address(0);
83 state.registers[SP] = sp;
84 state.registers[LR] = (uint32_t)__builtin_return_address(0);
85 state.registers[PC] = (uint32_t)dtrace_getpcstack;
87 while (depth < pcstack_limit) {
90 done = unwind_stack_one(&state, 1);
93 * NB: Unlike some other architectures, we don't need to
94 * explicitly insert cpu_dtrace_caller as it appears in the
95 * normal kernel stack trace rather than a special trap frame.
100 pcstack[depth++] = state.registers[PC];
107 for (; depth < pcstack_limit; depth++) {
113 dtrace_getupcstack(uint64_t *pcstack, int pcstack_limit)
115 printf("IMPLEMENT ME: %s\n", __func__);
119 dtrace_getustackdepth(void)
121 printf("IMPLEMENT ME: %s\n", __func__);
126 dtrace_getufpstack(uint64_t *pcstack, uint64_t *fpstack, int pcstack_limit)
128 printf("IMPLEMENT ME: %s\n", __func__);
133 dtrace_getarg(int arg, int aframes)
135 /* struct arm_frame *fp = (struct arm_frame *)dtrace_getfp();*/
141 dtrace_getstackdepth(int aframes)
143 struct unwind_state state;
149 __asm __volatile("mov %0, sp" : "=&r" (sp));
151 state.registers[FP] = (uint32_t)__builtin_frame_address(0);
152 state.registers[SP] = sp;
153 state.registers[LR] = (uint32_t)__builtin_return_address(0);
154 state.registers[PC] = (uint32_t)dtrace_getstackdepth;
157 done = unwind_stack_one(&state, 1);
164 return depth - aframes;
168 dtrace_getreg(struct trapframe *rp, uint_t reg)
170 printf("IMPLEMENT ME: %s\n", __func__);
176 dtrace_copycheck(uintptr_t uaddr, uintptr_t kaddr, size_t size)
179 if (uaddr + size > VM_MAXUSER_ADDRESS || uaddr + size < uaddr) {
180 DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
181 cpu_core[curcpu].cpuc_dtrace_illval = uaddr;
189 dtrace_copyin(uintptr_t uaddr, uintptr_t kaddr, size_t size,
190 volatile uint16_t *flags)
192 if (dtrace_copycheck(uaddr, kaddr, size))
193 dtrace_copy(uaddr, kaddr, size);
197 dtrace_copyout(uintptr_t kaddr, uintptr_t uaddr, size_t size,
198 volatile uint16_t *flags)
200 if (dtrace_copycheck(uaddr, kaddr, size))
201 dtrace_copy(kaddr, uaddr, size);
205 dtrace_copyinstr(uintptr_t uaddr, uintptr_t kaddr, size_t size,
206 volatile uint16_t *flags)
208 if (dtrace_copycheck(uaddr, kaddr, size))
209 dtrace_copystr(uaddr, kaddr, size, flags);
213 dtrace_copyoutstr(uintptr_t kaddr, uintptr_t uaddr, size_t size,
214 volatile uint16_t *flags)
216 if (dtrace_copycheck(uaddr, kaddr, size))
217 dtrace_copystr(kaddr, uaddr, size, flags);
221 dtrace_fuword8(void *uaddr)
223 if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
224 DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
225 cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
228 return (dtrace_fuword8_nocheck(uaddr));
232 dtrace_fuword16(void *uaddr)
234 if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
235 DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
236 cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
239 return (dtrace_fuword16_nocheck(uaddr));
243 dtrace_fuword32(void *uaddr)
245 if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
246 DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
247 cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
250 return (dtrace_fuword32_nocheck(uaddr));
254 dtrace_fuword64(void *uaddr)
256 if ((uintptr_t)uaddr > VM_MAXUSER_ADDRESS) {
257 DTRACE_CPUFLAG_SET(CPU_DTRACE_BADADDR);
258 cpu_core[curcpu].cpuc_dtrace_illval = (uintptr_t)uaddr;
261 return (dtrace_fuword64_nocheck(uaddr));