1 /*
2 * Copyright (c) 2007 Apple Inc. All rights reserved.
3 */
4 /*
5 * CDDL HEADER START
6 *
7 * The contents of this file are subject to the terms of the
8 * Common Development and Distribution License, Version 1.0 only
9 * (the "License"). You may not use this file except in compliance
10 * with the License.
11 *
12 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
13 * or http://www.opensolaris.org/os/licensing.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 *
17 * When distributing Covered Code, include this CDDL HEADER in each
18 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
19 * If applicable, add the following below this CDDL HEADER, with the
20 * fields enclosed by brackets "[]" replaced with your own identifying
21 * information: Portions Copyright [yyyy] [name of copyright owner]
22 *
23 * CDDL HEADER END
24 */
25 /*
26 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
27 * Use is subject to license terms.
28 */
29
30 #include <sys/dtrace.h>
31 #include <sys/dtrace_glue.h>
32 #include <sys/dtrace_impl.h>
33 #include <sys/fasttrap.h>
34 #include <sys/vm.h>
35 #include <sys/user.h>
36 #include <sys/kauth.h>
37 #include <kern/debug.h>
38 #include <arm/proc_reg.h>
39
40 int (*dtrace_pid_probe_ptr)(arm_saved_state_t *);
41 int (*dtrace_return_probe_ptr) (arm_saved_state_t *);
42
43 kern_return_t
44 dtrace_user_probe(arm_saved_state_t *, unsigned int);
45
46 kern_return_t
dtrace_user_probe(arm_saved_state_t * regs,unsigned int instr)47 dtrace_user_probe(arm_saved_state_t *regs, unsigned int instr)
48 {
49 /*
50 * FIXME
51 *
52 * The only call path into this method is always a user trap.
53 * We don't need to test for user trap, but should assert it.
54 */
55
56 lck_rw_t *rwp;
57 struct proc *p = current_proc();
58
59 thread_t thread = current_thread();
60 uthread_t uthread = current_uthread();
61
62 kauth_cred_thread_update(thread, p);
63
64 if (((regs->cpsr & PSR_TF) && ((uint16_t) instr) == FASTTRAP_THUMB_RET_INSTR) ||
65 ((uint32_t) instr == FASTTRAP_ARM_RET_INSTR)) {
66 uint8_t step = uthread->t_dtrace_step;
67 uint8_t ret = uthread->t_dtrace_ret;
68 user_addr_t npc = uthread->t_dtrace_npc;
69
70 if (uthread->t_dtrace_ast) {
71 printf("dtrace_user_probe() should be calling aston()\n");
72 // aston(thread);
73 // uthread->t_sig_check = 1;
74 }
75
76 /*
77 * Clear all user tracing flags.
78 */
79 uthread->t_dtrace_ft = 0;
80
81 /*
82 * If we weren't expecting to take a return probe trap, kill
83 * the process as though it had just executed an unassigned
84 * trap instruction.
85 */
86 if (step == 0) {
87 /*
88 * APPLE NOTE: We're returning KERN_FAILURE, which causes
89 * the generic signal handling code to take over, which will effectively
90 * deliver a EXC_BAD_INSTRUCTION to the user process.
91 */
92 return KERN_FAILURE;
93 }
94
95 /*
96 * If we hit this trap unrelated to a return probe, we're
97 * just here to reset the AST flag since we deferred a signal
98 * until after we logically single-stepped the instruction we
99 * copied out.
100 */
101 if (ret == 0) {
102 regs->pc = npc;
103 return KERN_SUCCESS;
104 }
105
106 /*
107 * We need to wait until after we've called the
108 * dtrace_return_probe_ptr function pointer to step the pc.
109 */
110 rwp = &CPU->cpu_ft_lock;
111 lck_rw_lock_shared(rwp);
112
113 if (dtrace_return_probe_ptr != NULL) {
114 (void) (*dtrace_return_probe_ptr)(regs);
115 }
116 lck_rw_unlock_shared(rwp);
117
118 regs->pc = npc;
119
120 return KERN_SUCCESS;
121 } else {
122 rwp = &CPU->cpu_ft_lock;
123
124 /*
125 * The DTrace fasttrap provider uses a trap,
126 * FASTTRAP_{ARM,THUMB}_INSTR. We let
127 * DTrace take the first crack at handling
128 * this trap; if it's not a probe that DTrace knows about,
129 * we call into the trap() routine to handle it like a
130 * breakpoint placed by a conventional debugger.
131 */
132
133 /*
134 * APPLE NOTE: I believe the purpose of the reader/writers lock
135 * is thus: There are times which dtrace needs to prevent calling
136 * dtrace_pid_probe_ptr(). Sun's original impl grabbed a plain
137 * mutex here. However, that serialized all probe calls, and
138 * destroyed MP behavior. So now they use a RW lock, with probes
139 * as readers, and the top level synchronization as a writer.
140 */
141 lck_rw_lock_shared(rwp);
142 if (dtrace_pid_probe_ptr != NULL &&
143 (*dtrace_pid_probe_ptr)(regs) == 0) {
144 lck_rw_unlock_shared(rwp);
145 return KERN_SUCCESS;
146 }
147 lck_rw_unlock_shared(rwp);
148
149 /*
150 * If the instruction that caused the breakpoint trap doesn't
151 * look like our trap anymore, it may be that this tracepoint
152 * was removed just after the user thread executed it. In
153 * that case, return to user land to retry the instuction.
154 *
155 * Note that the PC points to the instruction that caused the fault.
156 */
157 if (regs->cpsr & PSR_TF) {
158 uint16_t instr_check;
159 if (fuword16(regs->pc, &instr_check) == 0 && instr_check != FASTTRAP_THUMB_INSTR) {
160 return KERN_SUCCESS;
161 }
162 } else {
163 uint32_t instr_check;
164 if (fuword32(regs->pc, &instr_check) == 0 && instr_check != FASTTRAP_ARM_INSTR) {
165 return KERN_SUCCESS;
166 }
167 }
168 }
169
170 return KERN_FAILURE;
171 }
172