1 // SPDX-License-Identifier: GPL-2.0-only !! 1 /* arch/sparc64/kernel/kprobes.c
2 /* !! 2 *
3 * Copyright (C) 2004, 2007-2010, 2011-2012 Sy !! 3 * Copyright (C) 2004 David S. Miller <davem@davemloft.net>
4 */ 4 */
5 5
6 #include <linux/types.h> !! 6 #include <linux/kernel.h>
7 #include <linux/kprobes.h> 7 #include <linux/kprobes.h>
8 #include <linux/slab.h> <<
9 #include <linux/module.h> 8 #include <linux/module.h>
10 #include <linux/kdebug.h> 9 #include <linux/kdebug.h>
11 #include <linux/sched.h> !! 10 #include <linux/slab.h>
12 #include <linux/uaccess.h> !! 11 #include <asm/signal.h>
13 #include <asm/cacheflush.h> 12 #include <asm/cacheflush.h>
14 #include <asm/current.h> !! 13 #include <asm/uaccess.h>
15 #include <asm/disasm.h> <<
16 14
17 #define MIN_STACK_SIZE(addr) min((unsigned !! 15 /* We do not have hardware single-stepping on sparc64.
18 (unsigned long)current_thread_ !! 16 * So we implement software single-stepping with breakpoint
>> 17 * traps. The top-level scheme is similar to that used
>> 18 * in the x86 kprobes implementation.
>> 19 *
>> 20 * In the kprobe->ainsn.insn[] array we store the original
>> 21 * instruction at index zero and a break instruction at
>> 22 * index one.
>> 23 *
>> 24 * When we hit a kprobe we:
>> 25 * - Run the pre-handler
>> 26 * - Remember "regs->tnpc" and interrupt level stored in
>> 27 * "regs->tstate" so we can restore them later
>> 28 * - Disable PIL interrupts
>> 29 * - Set regs->tpc to point to kprobe->ainsn.insn[0]
>> 30 * - Set regs->tnpc to point to kprobe->ainsn.insn[1]
>> 31 * - Mark that we are actively in a kprobe
>> 32 *
>> 33 * At this point we wait for the second breakpoint at
>> 34 * kprobe->ainsn.insn[1] to hit. When it does we:
>> 35 * - Run the post-handler
>> 36 * - Set regs->tpc to "remembered" regs->tnpc stored above,
>> 37 * restore the PIL interrupt level in "regs->tstate" as well
>> 38 * - Make any adjustments necessary to regs->tnpc in order
>> 39 * to handle relative branches correctly. See below.
>> 40 * - Mark that we are no longer actively in a kprobe.
>> 41 */
19 42
20 DEFINE_PER_CPU(struct kprobe *, current_kprobe 43 DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
21 DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ct 44 DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
22 45
>> 46 struct kretprobe_blackpoint kretprobe_blacklist[] = {{NULL, NULL}};
>> 47
23 int __kprobes arch_prepare_kprobe(struct kprob 48 int __kprobes arch_prepare_kprobe(struct kprobe *p)
24 { 49 {
25 /* Attempt to probe at unaligned addre !! 50 if ((unsigned long) p->addr & 0x3UL)
26 if ((unsigned long)p->addr & 0x01) !! 51 return -EILSEQ;
27 return -EINVAL; <<
28 52
29 /* Address should not be in exception !! 53 p->ainsn.insn[0] = *p->addr;
>> 54 flushi(&p->ainsn.insn[0]);
30 55
31 p->ainsn.is_short = is_short_instr((un !! 56 p->ainsn.insn[1] = BREAKPOINT_INSTRUCTION_2;
32 p->opcode = *p->addr; !! 57 flushi(&p->ainsn.insn[1]);
33 58
>> 59 p->opcode = *p->addr;
34 return 0; 60 return 0;
35 } 61 }
36 62
37 void __kprobes arch_arm_kprobe(struct kprobe * 63 void __kprobes arch_arm_kprobe(struct kprobe *p)
38 { 64 {
39 *p->addr = UNIMP_S_INSTRUCTION; !! 65 *p->addr = BREAKPOINT_INSTRUCTION;
40 !! 66 flushi(p->addr);
41 flush_icache_range((unsigned long)p->a <<
42 (unsigned long)p->a <<
43 } 67 }
44 68
45 void __kprobes arch_disarm_kprobe(struct kprob 69 void __kprobes arch_disarm_kprobe(struct kprobe *p)
46 { 70 {
47 *p->addr = p->opcode; 71 *p->addr = p->opcode;
48 !! 72 flushi(p->addr);
49 flush_icache_range((unsigned long)p->a <<
50 (unsigned long)p->a <<
51 } <<
52 <<
53 void __kprobes arch_remove_kprobe(struct kprob <<
54 { <<
55 arch_disarm_kprobe(p); <<
56 <<
57 /* Can we remove the kprobe in the mid <<
58 if (p->ainsn.t1_addr) { <<
59 *(p->ainsn.t1_addr) = p->ainsn <<
60 <<
61 flush_icache_range((unsigned l <<
62 (unsigned l <<
63 sizeof(kpro <<
64 <<
65 p->ainsn.t1_addr = NULL; <<
66 } <<
67 <<
68 if (p->ainsn.t2_addr) { <<
69 *(p->ainsn.t2_addr) = p->ainsn <<
70 <<
71 flush_icache_range((unsigned l <<
72 (unsigned l <<
73 sizeof(kpro <<
74 <<
75 p->ainsn.t2_addr = NULL; <<
76 } <<
77 } 73 }
78 74
79 static void __kprobes save_previous_kprobe(str 75 static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb)
80 { 76 {
81 kcb->prev_kprobe.kp = kprobe_running() 77 kcb->prev_kprobe.kp = kprobe_running();
82 kcb->prev_kprobe.status = kcb->kprobe_ 78 kcb->prev_kprobe.status = kcb->kprobe_status;
>> 79 kcb->prev_kprobe.orig_tnpc = kcb->kprobe_orig_tnpc;
>> 80 kcb->prev_kprobe.orig_tstate_pil = kcb->kprobe_orig_tstate_pil;
83 } 81 }
84 82
85 static void __kprobes restore_previous_kprobe( 83 static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb)
86 { 84 {
87 __this_cpu_write(current_kprobe, kcb-> !! 85 __get_cpu_var(current_kprobe) = kcb->prev_kprobe.kp;
88 kcb->kprobe_status = kcb->prev_kprobe. 86 kcb->kprobe_status = kcb->prev_kprobe.status;
>> 87 kcb->kprobe_orig_tnpc = kcb->prev_kprobe.orig_tnpc;
>> 88 kcb->kprobe_orig_tstate_pil = kcb->prev_kprobe.orig_tstate_pil;
89 } 89 }
90 90
91 static inline void __kprobes set_current_kprob !! 91 static void __kprobes set_current_kprobe(struct kprobe *p, struct pt_regs *regs,
>> 92 struct kprobe_ctlblk *kcb)
92 { 93 {
93 __this_cpu_write(current_kprobe, p); !! 94 __get_cpu_var(current_kprobe) = p;
>> 95 kcb->kprobe_orig_tnpc = regs->tnpc;
>> 96 kcb->kprobe_orig_tstate_pil = (regs->tstate & TSTATE_PIL);
94 } 97 }
95 98
96 static void __kprobes resume_execution(struct !! 99 static void __kprobes prepare_singlestep(struct kprobe *p, struct pt_regs *regs,
97 struct !! 100 struct kprobe_ctlblk *kcb)
98 { 101 {
99 /* Remove the trap instructions insert !! 102 regs->tstate |= TSTATE_PIL;
100 * restore the original instructions <<
101 */ <<
102 if (p->ainsn.t1_addr) { <<
103 *(p->ainsn.t1_addr) = p->ainsn <<
104 103
105 flush_icache_range((unsigned l !! 104 /*single step inline, if it a breakpoint instruction*/
106 (unsigned l !! 105 if (p->opcode == BREAKPOINT_INSTRUCTION) {
107 sizeof(kpro !! 106 regs->tpc = (unsigned long) p->addr;
108 !! 107 regs->tnpc = kcb->kprobe_orig_tnpc;
109 p->ainsn.t1_addr = NULL; !! 108 } else {
>> 109 regs->tpc = (unsigned long) &p->ainsn.insn[0];
>> 110 regs->tnpc = (unsigned long) &p->ainsn.insn[1];
110 } 111 }
>> 112 }
>> 113
>> 114 static int __kprobes kprobe_handler(struct pt_regs *regs)
>> 115 {
>> 116 struct kprobe *p;
>> 117 void *addr = (void *) regs->tpc;
>> 118 int ret = 0;
>> 119 struct kprobe_ctlblk *kcb;
111 120
112 if (p->ainsn.t2_addr) { !! 121 /*
113 *(p->ainsn.t2_addr) = p->ainsn !! 122 * We don't want to be preempted for the entire
>> 123 * duration of kprobe processing
>> 124 */
>> 125 preempt_disable();
>> 126 kcb = get_kprobe_ctlblk();
114 127
115 flush_icache_range((unsigned l !! 128 if (kprobe_running()) {
116 (unsigned l !! 129 p = get_kprobe(addr);
117 sizeof(kpro !! 130 if (p) {
>> 131 if (kcb->kprobe_status == KPROBE_HIT_SS) {
>> 132 regs->tstate = ((regs->tstate & ~TSTATE_PIL) |
>> 133 kcb->kprobe_orig_tstate_pil);
>> 134 goto no_kprobe;
>> 135 }
>> 136 /* We have reentered the kprobe_handler(), since
>> 137 * another probe was hit while within the handler.
>> 138 * We here save the original kprobes variables and
>> 139 * just single step on the instruction of the new probe
>> 140 * without calling any user handlers.
>> 141 */
>> 142 save_previous_kprobe(kcb);
>> 143 set_current_kprobe(p, regs, kcb);
>> 144 kprobes_inc_nmissed_count(p);
>> 145 kcb->kprobe_status = KPROBE_REENTER;
>> 146 prepare_singlestep(p, regs, kcb);
>> 147 return 1;
>> 148 } else {
>> 149 if (*(u32 *)addr != BREAKPOINT_INSTRUCTION) {
>> 150 /* The breakpoint instruction was removed by
>> 151 * another cpu right after we hit, no further
>> 152 * handling of this interrupt is appropriate
>> 153 */
>> 154 ret = 1;
>> 155 goto no_kprobe;
>> 156 }
>> 157 p = __get_cpu_var(current_kprobe);
>> 158 if (p->break_handler && p->break_handler(p, regs))
>> 159 goto ss_probe;
>> 160 }
>> 161 goto no_kprobe;
>> 162 }
118 163
119 p->ainsn.t2_addr = NULL; !! 164 p = get_kprobe(addr);
>> 165 if (!p) {
>> 166 if (*(u32 *)addr != BREAKPOINT_INSTRUCTION) {
>> 167 /*
>> 168 * The breakpoint instruction was removed right
>> 169 * after we hit it. Another cpu has removed
>> 170 * either a probepoint or a debugger breakpoint
>> 171 * at this address. In either case, no further
>> 172 * handling of this interrupt is appropriate.
>> 173 */
>> 174 ret = 1;
>> 175 }
>> 176 /* Not one of ours: let kernel handle it */
>> 177 goto no_kprobe;
120 } 178 }
121 179
122 return; !! 180 set_current_kprobe(p, regs, kcb);
>> 181 kcb->kprobe_status = KPROBE_HIT_ACTIVE;
>> 182 if (p->pre_handler && p->pre_handler(p, regs))
>> 183 return 1;
>> 184
>> 185 ss_probe:
>> 186 prepare_singlestep(p, regs, kcb);
>> 187 kcb->kprobe_status = KPROBE_HIT_SS;
>> 188 return 1;
>> 189
>> 190 no_kprobe:
>> 191 preempt_enable_no_resched();
>> 192 return ret;
123 } 193 }
124 194
125 static void __kprobes setup_singlestep(struct !! 195 /* If INSN is a relative control transfer instruction,
>> 196 * return the corrected branch destination value.
>> 197 *
>> 198 * regs->tpc and regs->tnpc still hold the values of the
>> 199 * program counters at the time of trap due to the execution
>> 200 * of the BREAKPOINT_INSTRUCTION_2 at p->ainsn.insn[1]
>> 201 *
>> 202 */
>> 203 static unsigned long __kprobes relbranch_fixup(u32 insn, struct kprobe *p,
>> 204 struct pt_regs *regs)
126 { 205 {
127 unsigned long next_pc; !! 206 unsigned long real_pc = (unsigned long) p->addr;
128 unsigned long tgt_if_br = 0; <<
129 int is_branch; <<
130 unsigned long bta; <<
131 207
132 /* Copy the opcode back to the kprobe !! 208 /* Branch not taken, no mods necessary. */
133 * instruction. Because of this we wil !! 209 if (regs->tnpc == regs->tpc + 0x4UL)
134 * same kprobe until this kprobe is do !! 210 return real_pc + 0x8UL;
135 */ <<
136 *(p->addr) = p->opcode; <<
137 211
138 flush_icache_range((unsigned long)p->a !! 212 /* The three cases are call, branch w/prediction,
139 (unsigned long)p->a !! 213 * and traditional branch.
>> 214 */
>> 215 if ((insn & 0xc0000000) == 0x40000000 ||
>> 216 (insn & 0xc1c00000) == 0x00400000 ||
>> 217 (insn & 0xc1c00000) == 0x00800000) {
>> 218 unsigned long ainsn_addr;
>> 219
>> 220 ainsn_addr = (unsigned long) &p->ainsn.insn[0];
>> 221
>> 222 /* The instruction did all the work for us
>> 223 * already, just apply the offset to the correct
>> 224 * instruction location.
>> 225 */
>> 226 return (real_pc + (regs->tnpc - ainsn_addr));
>> 227 }
140 228
141 /* Now we insert the trap at the next !! 229 /* It is jmpl or some other absolute PC modification instruction,
142 * single step. If it is a branch we i !! 230 * leave NPC as-is.
143 * targets <<
144 */ 231 */
>> 232 return regs->tnpc;
>> 233 }
>> 234
>> 235 /* If INSN is an instruction which writes it's PC location
>> 236 * into a destination register, fix that up.
>> 237 */
>> 238 static void __kprobes retpc_fixup(struct pt_regs *regs, u32 insn,
>> 239 unsigned long real_pc)
>> 240 {
>> 241 unsigned long *slot = NULL;
145 242
146 bta = regs->bta; !! 243 /* Simplest case is 'call', which always uses %o7 */
>> 244 if ((insn & 0xc0000000) == 0x40000000) {
>> 245 slot = ®s->u_regs[UREG_I7];
>> 246 }
147 247
148 if (regs->status32 & 0x40) { !! 248 /* 'jmpl' encodes the register inside of the opcode */
149 /* We are in a delay slot with !! 249 if ((insn & 0xc1f80000) == 0x81c00000) {
>> 250 unsigned long rd = ((insn >> 25) & 0x1f);
150 251
151 next_pc = bta & ~0x01; !! 252 if (rd <= 15) {
>> 253 slot = ®s->u_regs[rd];
>> 254 } else {
>> 255 /* Hard case, it goes onto the stack. */
>> 256 flushw_all();
152 257
153 if (!p->ainsn.is_short) { !! 258 rd -= 16;
154 if (bta & 0x01) !! 259 slot = (unsigned long *)
155 regs->blink += !! 260 (regs->u_regs[UREG_FP] + STACK_BIAS);
156 else { !! 261 slot += rd;
157 /* Branch not <<
158 next_pc += 2; <<
159 <<
160 /* next pc is <<
161 * delay slot <<
162 */ <<
163 regs->bta += 2 <<
164 } <<
165 } 262 }
166 <<
167 is_branch = 0; <<
168 } else <<
169 is_branch = <<
170 disasm_next_pc((unsigned l <<
171 (struct callee_regs *) <<
172 &next_pc, &tgt_if_br); <<
173 <<
174 p->ainsn.t1_addr = (kprobe_opcode_t *) <<
175 p->ainsn.t1_opcode = *(p->ainsn.t1_add <<
176 *(p->ainsn.t1_addr) = TRAP_S_2_INSTRUC <<
177 <<
178 flush_icache_range((unsigned long)p->a <<
179 (unsigned long)p->a <<
180 sizeof(kprobe_opcod <<
181 <<
182 if (is_branch) { <<
183 p->ainsn.t2_addr = (kprobe_opc <<
184 p->ainsn.t2_opcode = *(p->ains <<
185 *(p->ainsn.t2_addr) = TRAP_S_2 <<
186 <<
187 flush_icache_range((unsigned l <<
188 (unsigned l <<
189 sizeof(kpro <<
190 } 263 }
>> 264 if (slot != NULL)
>> 265 *slot = real_pc;
191 } 266 }
192 267
193 static int !! 268 /*
194 __kprobes arc_kprobe_handler(unsigned long add !! 269 * Called after single-stepping. p->addr is the address of the
>> 270 * instruction which has been replaced by the breakpoint
>> 271 * instruction. To avoid the SMP problems that can occur when we
>> 272 * temporarily put back the original opcode to single-step, we
>> 273 * single-stepped a copy of the instruction. The address of this
>> 274 * copy is &p->ainsn.insn[0].
>> 275 *
>> 276 * This function prepares to return from the post-single-step
>> 277 * breakpoint trap.
>> 278 */
>> 279 static void __kprobes resume_execution(struct kprobe *p,
>> 280 struct pt_regs *regs, struct kprobe_ctlblk *kcb)
195 { 281 {
196 struct kprobe *p; !! 282 u32 insn = p->ainsn.insn[0];
197 struct kprobe_ctlblk *kcb; <<
198 <<
199 preempt_disable(); <<
200 283
201 kcb = get_kprobe_ctlblk(); !! 284 regs->tnpc = relbranch_fixup(insn, p, regs);
202 p = get_kprobe((unsigned long *)addr); <<
203 <<
204 if (p) { <<
205 /* <<
206 * We have reentered the kprob <<
207 * was hit while within the ha <<
208 * kprobes and single step on <<
209 * without calling any user ha <<
210 * kprobes. <<
211 */ <<
212 if (kprobe_running()) { <<
213 save_previous_kprobe(k <<
214 set_current_kprobe(p); <<
215 kprobes_inc_nmissed_co <<
216 setup_singlestep(p, re <<
217 kcb->kprobe_status = K <<
218 return 1; <<
219 } <<
220 285
221 set_current_kprobe(p); !! 286 /* This assignment must occur after relbranch_fixup() */
222 kcb->kprobe_status = KPROBE_HI !! 287 regs->tpc = kcb->kprobe_orig_tnpc;
223 288
224 /* If we have no pre-handler o !! 289 retpc_fixup(regs, insn, (unsigned long) p->addr);
225 * normal processing. If we ha <<
226 * non-zero - which means user <<
227 * to another instruction, we <<
228 */ <<
229 if (!p->pre_handler || !p->pre <<
230 setup_singlestep(p, re <<
231 kcb->kprobe_status = K <<
232 } else { <<
233 reset_current_kprobe() <<
234 preempt_enable_no_resc <<
235 } <<
236 290
237 return 1; !! 291 regs->tstate = ((regs->tstate & ~TSTATE_PIL) |
238 } !! 292 kcb->kprobe_orig_tstate_pil);
239 <<
240 /* no_kprobe: */ <<
241 preempt_enable_no_resched(); <<
242 return 0; <<
243 } 293 }
244 294
245 static int !! 295 static int __kprobes post_kprobe_handler(struct pt_regs *regs)
246 __kprobes arc_post_kprobe_handler(unsigned lon <<
247 { 296 {
248 struct kprobe *cur = kprobe_running(); 297 struct kprobe *cur = kprobe_running();
249 struct kprobe_ctlblk *kcb = get_kprobe 298 struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
250 299
251 if (!cur) 300 if (!cur)
252 return 0; 301 return 0;
253 302
254 resume_execution(cur, addr, regs); <<
255 <<
256 /* Rearm the kprobe */ <<
257 arch_arm_kprobe(cur); <<
258 <<
259 /* <<
260 * When we return from trap instructio <<
261 * We restored the actual instruction <<
262 * return to the same address and exec <<
263 */ <<
264 regs->ret = addr; <<
265 <<
266 if ((kcb->kprobe_status != KPROBE_REEN 303 if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
267 kcb->kprobe_status = KPROBE_HI 304 kcb->kprobe_status = KPROBE_HIT_SSDONE;
268 cur->post_handler(cur, regs, 0 305 cur->post_handler(cur, regs, 0);
269 } 306 }
270 307
>> 308 resume_execution(cur, regs, kcb);
>> 309
>> 310 /*Restore back the original saved kprobes variables and continue. */
271 if (kcb->kprobe_status == KPROBE_REENT 311 if (kcb->kprobe_status == KPROBE_REENTER) {
272 restore_previous_kprobe(kcb); 312 restore_previous_kprobe(kcb);
273 goto out; 313 goto out;
274 } 314 }
275 <<
276 reset_current_kprobe(); 315 reset_current_kprobe();
277 <<
278 out: 316 out:
279 preempt_enable_no_resched(); 317 preempt_enable_no_resched();
>> 318
280 return 1; 319 return 1;
281 } 320 }
282 321
283 /* !! 322 int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
284 * Fault can be for the instruction being sing <<
285 * pre/post handlers in the module. <<
286 * This is applicable for applications like us <<
287 * probe in user space and the handlers in the <<
288 */ <<
289 <<
290 int __kprobes kprobe_fault_handler(struct pt_r <<
291 { 323 {
292 struct kprobe *cur = kprobe_running(); 324 struct kprobe *cur = kprobe_running();
293 struct kprobe_ctlblk *kcb = get_kprobe 325 struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
>> 326 const struct exception_table_entry *entry;
294 327
295 switch (kcb->kprobe_status) { !! 328 switch(kcb->kprobe_status) {
296 case KPROBE_HIT_SS: 329 case KPROBE_HIT_SS:
297 case KPROBE_REENTER: 330 case KPROBE_REENTER:
298 /* 331 /*
299 * We are here because the ins !! 332 * We are here because the instruction being single
300 * caused the fault. We reset !! 333 * stepped caused a page fault. We reset the current
301 * exception handler as if it !! 334 * kprobe and the tpc points back to the probe address
302 * case it doesn't matter beca !! 335 * and allow the page fault handler to continue as a
>> 336 * normal page fault.
303 */ 337 */
304 resume_execution(cur, (unsigne !! 338 regs->tpc = (unsigned long)cur->addr;
305 !! 339 regs->tnpc = kcb->kprobe_orig_tnpc;
>> 340 regs->tstate = ((regs->tstate & ~TSTATE_PIL) |
>> 341 kcb->kprobe_orig_tstate_pil);
306 if (kcb->kprobe_status == KPRO 342 if (kcb->kprobe_status == KPROBE_REENTER)
307 restore_previous_kprob 343 restore_previous_kprobe(kcb);
308 else 344 else
309 reset_current_kprobe() 345 reset_current_kprobe();
310 <<
311 preempt_enable_no_resched(); 346 preempt_enable_no_resched();
312 break; 347 break;
313 <<
314 case KPROBE_HIT_ACTIVE: 348 case KPROBE_HIT_ACTIVE:
315 case KPROBE_HIT_SSDONE: 349 case KPROBE_HIT_SSDONE:
316 /* 350 /*
317 * We are here because the ins !! 351 * We increment the nmissed count for accounting,
318 * caused the fault. !! 352 * we can also use npre/npostfault count for accouting
>> 353 * these specific fault cases.
>> 354 */
>> 355 kprobes_inc_nmissed_count(cur);
>> 356
>> 357 /*
>> 358 * We come here because instructions in the pre/post
>> 359 * handler caused the page_fault, this could happen
>> 360 * if handler tries to access user space by
>> 361 * copy_from_user(), get_user() etc. Let the
>> 362 * user-specified handler try to fix it first.
319 */ 363 */
>> 364 if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr))
>> 365 return 1;
320 366
321 /* 367 /*
322 * In case the user-specified !! 368 * In case the user-specified fault handler returned
323 * try to fix up. !! 369 * zero, try to fix up.
324 */ 370 */
325 if (fixup_exception(regs)) !! 371
>> 372 entry = search_exception_tables(regs->tpc);
>> 373 if (entry) {
>> 374 regs->tpc = entry->fixup;
>> 375 regs->tnpc = regs->tpc + 4;
326 return 1; 376 return 1;
>> 377 }
327 378
328 /* 379 /*
329 * fixup_exception() could not 380 * fixup_exception() could not handle it,
330 * Let do_page_fault() fix it. 381 * Let do_page_fault() fix it.
331 */ 382 */
332 break; 383 break;
333 <<
334 default: 384 default:
335 break; 385 break;
336 } 386 }
>> 387
337 return 0; 388 return 0;
338 } 389 }
339 390
>> 391 /*
>> 392 * Wrapper routine to for handling exceptions.
>> 393 */
340 int __kprobes kprobe_exceptions_notify(struct 394 int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
341 unsigne 395 unsigned long val, void *data)
342 { 396 {
343 struct die_args *args = data; !! 397 struct die_args *args = (struct die_args *)data;
344 unsigned long addr = args->err; <<
345 int ret = NOTIFY_DONE; 398 int ret = NOTIFY_DONE;
346 399
>> 400 if (args->regs && user_mode(args->regs))
>> 401 return ret;
>> 402
347 switch (val) { 403 switch (val) {
348 case DIE_IERR: !! 404 case DIE_DEBUG:
349 if (arc_kprobe_handler(addr, a !! 405 if (kprobe_handler(args->regs))
350 return NOTIFY_STOP; !! 406 ret = NOTIFY_STOP;
351 break; 407 break;
352 !! 408 case DIE_DEBUG_2:
353 case DIE_TRAP: !! 409 if (post_kprobe_handler(args->regs))
354 if (arc_post_kprobe_handler(ad !! 410 ret = NOTIFY_STOP;
355 return NOTIFY_STOP; <<
356 break; 411 break;
357 <<
358 default: 412 default:
359 break; 413 break;
360 } 414 }
361 <<
362 return ret; 415 return ret;
363 } 416 }
364 417
365 static void __used kretprobe_trampoline_holder !! 418 asmlinkage void __kprobes kprobe_trap(unsigned long trap_level,
>> 419 struct pt_regs *regs)
>> 420 {
>> 421 BUG_ON(trap_level != 0x170 && trap_level != 0x171);
>> 422
>> 423 if (user_mode(regs)) {
>> 424 local_irq_enable();
>> 425 bad_trap(regs, trap_level);
>> 426 return;
>> 427 }
>> 428
>> 429 /* trap_level == 0x170 --> ta 0x70
>> 430 * trap_level == 0x171 --> ta 0x71
>> 431 */
>> 432 if (notify_die((trap_level == 0x170) ? DIE_DEBUG : DIE_DEBUG_2,
>> 433 (trap_level == 0x170) ? "debug" : "debug_2",
>> 434 regs, 0, trap_level, SIGTRAP) != NOTIFY_STOP)
>> 435 bad_trap(regs, trap_level);
>> 436 }
>> 437
>> 438 /* Jprobes support. */
>> 439 int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
366 { 440 {
367 __asm__ __volatile__(".global __kretpr !! 441 struct jprobe *jp = container_of(p, struct jprobe, kp);
368 "__kretprobe_tram !! 442 struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
369 "nop\n"); !! 443
>> 444 memcpy(&(kcb->jprobe_saved_regs), regs, sizeof(*regs));
>> 445
>> 446 regs->tpc = (unsigned long) jp->entry;
>> 447 regs->tnpc = ((unsigned long) jp->entry) + 0x4UL;
>> 448 regs->tstate |= TSTATE_PIL;
>> 449
>> 450 return 1;
>> 451 }
>> 452
>> 453 void __kprobes jprobe_return(void)
>> 454 {
>> 455 struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
>> 456 register unsigned long orig_fp asm("g1");
>> 457
>> 458 orig_fp = kcb->jprobe_saved_regs.u_regs[UREG_FP];
>> 459 __asm__ __volatile__("\n"
>> 460 "1: cmp %%sp, %0\n\t"
>> 461 "blu,a,pt %%xcc, 1b\n\t"
>> 462 " restore\n\t"
>> 463 ".globl jprobe_return_trap_instruction\n"
>> 464 "jprobe_return_trap_instruction:\n\t"
>> 465 "ta 0x70"
>> 466 : /* no outputs */
>> 467 : "r" (orig_fp));
>> 468 }
>> 469
>> 470 extern void jprobe_return_trap_instruction(void);
>> 471
>> 472 int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
>> 473 {
>> 474 u32 *addr = (u32 *) regs->tpc;
>> 475 struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
>> 476
>> 477 if (addr == (u32 *) jprobe_return_trap_instruction) {
>> 478 memcpy(regs, &(kcb->jprobe_saved_regs), sizeof(*regs));
>> 479 preempt_enable_no_resched();
>> 480 return 1;
>> 481 }
>> 482 return 0;
370 } 483 }
371 484
>> 485 /* The value stored in the return address register is actually 2
>> 486 * instructions before where the callee will return to.
>> 487 * Sequences usually look something like this
>> 488 *
>> 489 * call some_function <--- return register points here
>> 490 * nop <--- call delay slot
>> 491 * whatever <--- where callee returns to
>> 492 *
>> 493 * To keep trampoline_probe_handler logic simpler, we normalize the
>> 494 * value kept in ri->ret_addr so we don't need to keep adjusting it
>> 495 * back and forth.
>> 496 */
372 void __kprobes arch_prepare_kretprobe(struct k 497 void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri,
373 struct p 498 struct pt_regs *regs)
374 { 499 {
375 !! 500 ri->ret_addr = (kprobe_opcode_t *)(regs->u_regs[UREG_RETPC] + 8);
376 ri->ret_addr = (kprobe_opcode_t *) reg <<
377 ri->fp = NULL; <<
378 501
379 /* Replace the return addr with trampo 502 /* Replace the return addr with trampoline addr */
380 regs->blink = (unsigned long)&__kretpr !! 503 regs->u_regs[UREG_RETPC] =
>> 504 ((unsigned long)kretprobe_trampoline) - 8;
381 } 505 }
382 506
383 static int __kprobes trampoline_probe_handler( !! 507 /*
384 !! 508 * Called when the probe at kretprobe trampoline is hit
>> 509 */
>> 510 int __kprobes trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
385 { 511 {
386 regs->ret = __kretprobe_trampoline_han !! 512 struct kretprobe_instance *ri = NULL;
>> 513 struct hlist_head *head, empty_rp;
>> 514 struct hlist_node *tmp;
>> 515 unsigned long flags, orig_ret_address = 0;
>> 516 unsigned long trampoline_address =(unsigned long)&kretprobe_trampoline;
>> 517
>> 518 INIT_HLIST_HEAD(&empty_rp);
>> 519 kretprobe_hash_lock(current, &head, &flags);
>> 520
>> 521 /*
>> 522 * It is possible to have multiple instances associated with a given
>> 523 * task either because an multiple functions in the call path
>> 524 * have a return probe installed on them, and/or more than one return
>> 525 * return probe was registered for a target function.
>> 526 *
>> 527 * We can handle this because:
>> 528 * - instances are always inserted at the head of the list
>> 529 * - when multiple return probes are registered for the same
>> 530 * function, the first instance's ret_addr will point to the
>> 531 * real return address, and all the rest will point to
>> 532 * kretprobe_trampoline
>> 533 */
>> 534 hlist_for_each_entry_safe(ri, tmp, head, hlist) {
>> 535 if (ri->task != current)
>> 536 /* another task is sharing our hash bucket */
>> 537 continue;
>> 538
>> 539 if (ri->rp && ri->rp->handler)
>> 540 ri->rp->handler(ri, regs);
>> 541
>> 542 orig_ret_address = (unsigned long)ri->ret_addr;
>> 543 recycle_rp_inst(ri, &empty_rp);
>> 544
>> 545 if (orig_ret_address != trampoline_address)
>> 546 /*
>> 547 * This is the real return address. Any other
>> 548 * instances associated with this task are for
>> 549 * other calls deeper on the call stack
>> 550 */
>> 551 break;
>> 552 }
>> 553
>> 554 kretprobe_assert(ri, orig_ret_address, trampoline_address);
>> 555 regs->tpc = orig_ret_address;
>> 556 regs->tnpc = orig_ret_address + 4;
387 557
388 /* By returning a non zero value, we a !! 558 reset_current_kprobe();
389 * that we don't want the post_handler !! 559 kretprobe_hash_unlock(current, &flags);
>> 560 preempt_enable_no_resched();
>> 561
>> 562 hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
>> 563 hlist_del(&ri->hlist);
>> 564 kfree(ri);
>> 565 }
>> 566 /*
>> 567 * By returning a non-zero value, we are telling
>> 568 * kprobe_handler() that we don't want the post_handler
>> 569 * to run (and have re-enabled preemption)
390 */ 570 */
391 return 1; 571 return 1;
392 } 572 }
393 573
>> 574 void kretprobe_trampoline_holder(void)
>> 575 {
>> 576 asm volatile(".global kretprobe_trampoline\n"
>> 577 "kretprobe_trampoline:\n"
>> 578 "\tnop\n"
>> 579 "\tnop\n");
>> 580 }
394 static struct kprobe trampoline_p = { 581 static struct kprobe trampoline_p = {
395 .addr = (kprobe_opcode_t *) &__kretpro !! 582 .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
396 .pre_handler = trampoline_probe_handle 583 .pre_handler = trampoline_probe_handler
397 }; 584 };
398 585
399 int __init arch_init_kprobes(void) 586 int __init arch_init_kprobes(void)
400 { 587 {
401 /* Registering the trampoline code for <<
402 return register_kprobe(&trampoline_p); 588 return register_kprobe(&trampoline_p);
403 } 589 }
404 590
405 int __kprobes arch_trampoline_kprobe(struct kp 591 int __kprobes arch_trampoline_kprobe(struct kprobe *p)
406 { 592 {
407 if (p->addr == (kprobe_opcode_t *) &__ !! 593 if (p->addr == (kprobe_opcode_t *)&kretprobe_trampoline)
408 return 1; 594 return 1;
409 595
410 return 0; 596 return 0;
411 } <<
412 <<
413 void trap_is_kprobe(unsigned long address, str <<
414 { <<
415 notify_die(DIE_TRAP, "kprobe_trap", re <<
416 } 597 }
417 598
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.