]> git.karo-electronics.de Git - karo-tx-linux.git/blob - arch/powerpc/kernel/kprobes.c
Replace <asm/uaccess.h> with <linux/uaccess.h> globally
[karo-tx-linux.git] / arch / powerpc / kernel / kprobes.c
1 /*
2  *  Kernel Probes (KProbes)
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  *
18  * Copyright (C) IBM Corporation, 2002, 2004
19  *
20  * 2002-Oct     Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
21  *              Probes initial implementation ( includes contributions from
22  *              Rusty Russell).
23  * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
24  *              interface to access function arguments.
25  * 2004-Nov     Ananth N Mavinakayanahalli <ananth@in.ibm.com> kprobes port
26  *              for PPC64
27  */
28
29 #include <linux/kprobes.h>
30 #include <linux/ptrace.h>
31 #include <linux/preempt.h>
32 #include <linux/extable.h>
33 #include <linux/kdebug.h>
34 #include <linux/slab.h>
35 #include <asm/code-patching.h>
36 #include <asm/cacheflush.h>
37 #include <asm/sstep.h>
38 #include <linux/uaccess.h>
39
40 DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
41 DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
42
43 struct kretprobe_blackpoint kretprobe_blacklist[] = {{NULL, NULL}};
44
45 int __kprobes arch_prepare_kprobe(struct kprobe *p)
46 {
47         int ret = 0;
48         kprobe_opcode_t insn = *p->addr;
49
50         if ((unsigned long)p->addr & 0x03) {
51                 printk("Attempt to register kprobe at an unaligned address\n");
52                 ret = -EINVAL;
53         } else if (IS_MTMSRD(insn) || IS_RFID(insn) || IS_RFI(insn)) {
54                 printk("Cannot register a kprobe on rfi/rfid or mtmsr[d]\n");
55                 ret = -EINVAL;
56         }
57
58         /* insn must be on a special executable page on ppc64.  This is
59          * not explicitly required on ppc32 (right now), but it doesn't hurt */
60         if (!ret) {
61                 p->ainsn.insn = get_insn_slot();
62                 if (!p->ainsn.insn)
63                         ret = -ENOMEM;
64         }
65
66         if (!ret) {
67                 memcpy(p->ainsn.insn, p->addr,
68                                 MAX_INSN_SIZE * sizeof(kprobe_opcode_t));
69                 p->opcode = *p->addr;
70                 flush_icache_range((unsigned long)p->ainsn.insn,
71                         (unsigned long)p->ainsn.insn + sizeof(kprobe_opcode_t));
72         }
73
74         p->ainsn.boostable = 0;
75         return ret;
76 }
77
78 void __kprobes arch_arm_kprobe(struct kprobe *p)
79 {
80         *p->addr = BREAKPOINT_INSTRUCTION;
81         flush_icache_range((unsigned long) p->addr,
82                            (unsigned long) p->addr + sizeof(kprobe_opcode_t));
83 }
84
85 void __kprobes arch_disarm_kprobe(struct kprobe *p)
86 {
87         *p->addr = p->opcode;
88         flush_icache_range((unsigned long) p->addr,
89                            (unsigned long) p->addr + sizeof(kprobe_opcode_t));
90 }
91
92 void __kprobes arch_remove_kprobe(struct kprobe *p)
93 {
94         if (p->ainsn.insn) {
95                 free_insn_slot(p->ainsn.insn, 0);
96                 p->ainsn.insn = NULL;
97         }
98 }
99
100 static void __kprobes prepare_singlestep(struct kprobe *p, struct pt_regs *regs)
101 {
102         enable_single_step(regs);
103
104         /*
105          * On powerpc we should single step on the original
106          * instruction even if the probed insn is a trap
107          * variant as values in regs could play a part in
108          * if the trap is taken or not
109          */
110         regs->nip = (unsigned long)p->ainsn.insn;
111 }
112
113 static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb)
114 {
115         kcb->prev_kprobe.kp = kprobe_running();
116         kcb->prev_kprobe.status = kcb->kprobe_status;
117         kcb->prev_kprobe.saved_msr = kcb->kprobe_saved_msr;
118 }
119
120 static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb)
121 {
122         __this_cpu_write(current_kprobe, kcb->prev_kprobe.kp);
123         kcb->kprobe_status = kcb->prev_kprobe.status;
124         kcb->kprobe_saved_msr = kcb->prev_kprobe.saved_msr;
125 }
126
127 static void __kprobes set_current_kprobe(struct kprobe *p, struct pt_regs *regs,
128                                 struct kprobe_ctlblk *kcb)
129 {
130         __this_cpu_write(current_kprobe, p);
131         kcb->kprobe_saved_msr = regs->msr;
132 }
133
134 void __kprobes arch_prepare_kretprobe(struct kretprobe_instance *ri,
135                                       struct pt_regs *regs)
136 {
137         ri->ret_addr = (kprobe_opcode_t *)regs->link;
138
139         /* Replace the return addr with trampoline addr */
140         regs->link = (unsigned long)kretprobe_trampoline;
141 }
142
143 int __kprobes kprobe_handler(struct pt_regs *regs)
144 {
145         struct kprobe *p;
146         int ret = 0;
147         unsigned int *addr = (unsigned int *)regs->nip;
148         struct kprobe_ctlblk *kcb;
149
150         if (user_mode(regs))
151                 return 0;
152
153         /*
154          * We don't want to be preempted for the entire
155          * duration of kprobe processing
156          */
157         preempt_disable();
158         kcb = get_kprobe_ctlblk();
159
160         /* Check we're not actually recursing */
161         if (kprobe_running()) {
162                 p = get_kprobe(addr);
163                 if (p) {
164                         kprobe_opcode_t insn = *p->ainsn.insn;
165                         if (kcb->kprobe_status == KPROBE_HIT_SS &&
166                                         is_trap(insn)) {
167                                 /* Turn off 'trace' bits */
168                                 regs->msr &= ~MSR_SINGLESTEP;
169                                 regs->msr |= kcb->kprobe_saved_msr;
170                                 goto no_kprobe;
171                         }
172                         /* We have reentered the kprobe_handler(), since
173                          * another probe was hit while within the handler.
174                          * We here save the original kprobes variables and
175                          * just single step on the instruction of the new probe
176                          * without calling any user handlers.
177                          */
178                         save_previous_kprobe(kcb);
179                         set_current_kprobe(p, regs, kcb);
180                         kcb->kprobe_saved_msr = regs->msr;
181                         kprobes_inc_nmissed_count(p);
182                         prepare_singlestep(p, regs);
183                         kcb->kprobe_status = KPROBE_REENTER;
184                         return 1;
185                 } else {
186                         if (*addr != BREAKPOINT_INSTRUCTION) {
187                                 /* If trap variant, then it belongs not to us */
188                                 kprobe_opcode_t cur_insn = *addr;
189                                 if (is_trap(cur_insn))
190                                         goto no_kprobe;
191                                 /* The breakpoint instruction was removed by
192                                  * another cpu right after we hit, no further
193                                  * handling of this interrupt is appropriate
194                                  */
195                                 ret = 1;
196                                 goto no_kprobe;
197                         }
198                         p = __this_cpu_read(current_kprobe);
199                         if (p->break_handler && p->break_handler(p, regs)) {
200                                 goto ss_probe;
201                         }
202                 }
203                 goto no_kprobe;
204         }
205
206         p = get_kprobe(addr);
207         if (!p) {
208                 if (*addr != BREAKPOINT_INSTRUCTION) {
209                         /*
210                          * PowerPC has multiple variants of the "trap"
211                          * instruction. If the current instruction is a
212                          * trap variant, it could belong to someone else
213                          */
214                         kprobe_opcode_t cur_insn = *addr;
215                         if (is_trap(cur_insn))
216                                 goto no_kprobe;
217                         /*
218                          * The breakpoint instruction was removed right
219                          * after we hit it.  Another cpu has removed
220                          * either a probepoint or a debugger breakpoint
221                          * at this address.  In either case, no further
222                          * handling of this interrupt is appropriate.
223                          */
224                         ret = 1;
225                 }
226                 /* Not one of ours: let kernel handle it */
227                 goto no_kprobe;
228         }
229
230         kcb->kprobe_status = KPROBE_HIT_ACTIVE;
231         set_current_kprobe(p, regs, kcb);
232         if (p->pre_handler && p->pre_handler(p, regs))
233                 /* handler has already set things up, so skip ss setup */
234                 return 1;
235
236 ss_probe:
237         if (p->ainsn.boostable >= 0) {
238                 unsigned int insn = *p->ainsn.insn;
239
240                 /* regs->nip is also adjusted if emulate_step returns 1 */
241                 ret = emulate_step(regs, insn);
242                 if (ret > 0) {
243                         /*
244                          * Once this instruction has been boosted
245                          * successfully, set the boostable flag
246                          */
247                         if (unlikely(p->ainsn.boostable == 0))
248                                 p->ainsn.boostable = 1;
249
250                         if (p->post_handler)
251                                 p->post_handler(p, regs, 0);
252
253                         kcb->kprobe_status = KPROBE_HIT_SSDONE;
254                         reset_current_kprobe();
255                         preempt_enable_no_resched();
256                         return 1;
257                 } else if (ret < 0) {
258                         /*
259                          * We don't allow kprobes on mtmsr(d)/rfi(d), etc.
260                          * So, we should never get here... but, its still
261                          * good to catch them, just in case...
262                          */
263                         printk("Can't step on instruction %x\n", insn);
264                         BUG();
265                 } else if (ret == 0)
266                         /* This instruction can't be boosted */
267                         p->ainsn.boostable = -1;
268         }
269         prepare_singlestep(p, regs);
270         kcb->kprobe_status = KPROBE_HIT_SS;
271         return 1;
272
273 no_kprobe:
274         preempt_enable_no_resched();
275         return ret;
276 }
277
278 /*
279  * Function return probe trampoline:
280  *      - init_kprobes() establishes a probepoint here
281  *      - When the probed function returns, this probe
282  *              causes the handlers to fire
283  */
284 asm(".global kretprobe_trampoline\n"
285         ".type kretprobe_trampoline, @function\n"
286         "kretprobe_trampoline:\n"
287         "nop\n"
288         ".size kretprobe_trampoline, .-kretprobe_trampoline\n");
289
290 /*
291  * Called when the probe at kretprobe trampoline is hit
292  */
293 static int __kprobes trampoline_probe_handler(struct kprobe *p,
294                                                 struct pt_regs *regs)
295 {
296         struct kretprobe_instance *ri = NULL;
297         struct hlist_head *head, empty_rp;
298         struct hlist_node *tmp;
299         unsigned long flags, orig_ret_address = 0;
300         unsigned long trampoline_address =(unsigned long)&kretprobe_trampoline;
301
302         INIT_HLIST_HEAD(&empty_rp);
303         kretprobe_hash_lock(current, &head, &flags);
304
305         /*
306          * It is possible to have multiple instances associated with a given
307          * task either because an multiple functions in the call path
308          * have a return probe installed on them, and/or more than one return
309          * return probe was registered for a target function.
310          *
311          * We can handle this because:
312          *     - instances are always inserted at the head of the list
313          *     - when multiple return probes are registered for the same
314          *       function, the first instance's ret_addr will point to the
315          *       real return address, and all the rest will point to
316          *       kretprobe_trampoline
317          */
318         hlist_for_each_entry_safe(ri, tmp, head, hlist) {
319                 if (ri->task != current)
320                         /* another task is sharing our hash bucket */
321                         continue;
322
323                 if (ri->rp && ri->rp->handler)
324                         ri->rp->handler(ri, regs);
325
326                 orig_ret_address = (unsigned long)ri->ret_addr;
327                 recycle_rp_inst(ri, &empty_rp);
328
329                 if (orig_ret_address != trampoline_address)
330                         /*
331                          * This is the real return address. Any other
332                          * instances associated with this task are for
333                          * other calls deeper on the call stack
334                          */
335                         break;
336         }
337
338         kretprobe_assert(ri, orig_ret_address, trampoline_address);
339         regs->nip = orig_ret_address;
340
341         reset_current_kprobe();
342         kretprobe_hash_unlock(current, &flags);
343         preempt_enable_no_resched();
344
345         hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
346                 hlist_del(&ri->hlist);
347                 kfree(ri);
348         }
349         /*
350          * By returning a non-zero value, we are telling
351          * kprobe_handler() that we don't want the post_handler
352          * to run (and have re-enabled preemption)
353          */
354         return 1;
355 }
356
357 /*
358  * Called after single-stepping.  p->addr is the address of the
359  * instruction whose first byte has been replaced by the "breakpoint"
360  * instruction.  To avoid the SMP problems that can occur when we
361  * temporarily put back the original opcode to single-step, we
362  * single-stepped a copy of the instruction.  The address of this
363  * copy is p->ainsn.insn.
364  */
365 int __kprobes kprobe_post_handler(struct pt_regs *regs)
366 {
367         struct kprobe *cur = kprobe_running();
368         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
369
370         if (!cur || user_mode(regs))
371                 return 0;
372
373         /* make sure we got here for instruction we have a kprobe on */
374         if (((unsigned long)cur->ainsn.insn + 4) != regs->nip)
375                 return 0;
376
377         if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
378                 kcb->kprobe_status = KPROBE_HIT_SSDONE;
379                 cur->post_handler(cur, regs, 0);
380         }
381
382         /* Adjust nip to after the single-stepped instruction */
383         regs->nip = (unsigned long)cur->addr + 4;
384         regs->msr |= kcb->kprobe_saved_msr;
385
386         /*Restore back the original saved kprobes variables and continue. */
387         if (kcb->kprobe_status == KPROBE_REENTER) {
388                 restore_previous_kprobe(kcb);
389                 goto out;
390         }
391         reset_current_kprobe();
392 out:
393         preempt_enable_no_resched();
394
395         /*
396          * if somebody else is singlestepping across a probe point, msr
397          * will have DE/SE set, in which case, continue the remaining processing
398          * of do_debug, as if this is not a probe hit.
399          */
400         if (regs->msr & MSR_SINGLESTEP)
401                 return 0;
402
403         return 1;
404 }
405
406 int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
407 {
408         struct kprobe *cur = kprobe_running();
409         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
410         const struct exception_table_entry *entry;
411
412         switch(kcb->kprobe_status) {
413         case KPROBE_HIT_SS:
414         case KPROBE_REENTER:
415                 /*
416                  * We are here because the instruction being single
417                  * stepped caused a page fault. We reset the current
418                  * kprobe and the nip points back to the probe address
419                  * and allow the page fault handler to continue as a
420                  * normal page fault.
421                  */
422                 regs->nip = (unsigned long)cur->addr;
423                 regs->msr &= ~MSR_SINGLESTEP; /* Turn off 'trace' bits */
424                 regs->msr |= kcb->kprobe_saved_msr;
425                 if (kcb->kprobe_status == KPROBE_REENTER)
426                         restore_previous_kprobe(kcb);
427                 else
428                         reset_current_kprobe();
429                 preempt_enable_no_resched();
430                 break;
431         case KPROBE_HIT_ACTIVE:
432         case KPROBE_HIT_SSDONE:
433                 /*
434                  * We increment the nmissed count for accounting,
435                  * we can also use npre/npostfault count for accounting
436                  * these specific fault cases.
437                  */
438                 kprobes_inc_nmissed_count(cur);
439
440                 /*
441                  * We come here because instructions in the pre/post
442                  * handler caused the page_fault, this could happen
443                  * if handler tries to access user space by
444                  * copy_from_user(), get_user() etc. Let the
445                  * user-specified handler try to fix it first.
446                  */
447                 if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr))
448                         return 1;
449
450                 /*
451                  * In case the user-specified fault handler returned
452                  * zero, try to fix up.
453                  */
454                 if ((entry = search_exception_tables(regs->nip)) != NULL) {
455                         regs->nip = extable_fixup(entry);
456                         return 1;
457                 }
458
459                 /*
460                  * fixup_exception() could not handle it,
461                  * Let do_page_fault() fix it.
462                  */
463                 break;
464         default:
465                 break;
466         }
467         return 0;
468 }
469
470 /*
471  * Wrapper routine to for handling exceptions.
472  */
473 int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
474                                        unsigned long val, void *data)
475 {
476         return NOTIFY_DONE;
477 }
478
479 unsigned long arch_deref_entry_point(void *entry)
480 {
481         return ppc_global_function_entry(entry);
482 }
483
484 int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
485 {
486         struct jprobe *jp = container_of(p, struct jprobe, kp);
487         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
488
489         memcpy(&kcb->jprobe_saved_regs, regs, sizeof(struct pt_regs));
490
491         /* setup return addr to the jprobe handler routine */
492         regs->nip = arch_deref_entry_point(jp->entry);
493 #ifdef PPC64_ELF_ABI_v2
494         regs->gpr[12] = (unsigned long)jp->entry;
495 #elif defined(PPC64_ELF_ABI_v1)
496         regs->gpr[2] = (unsigned long)(((func_descr_t *)jp->entry)->toc);
497 #endif
498
499         return 1;
500 }
501
502 void __used __kprobes jprobe_return(void)
503 {
504         asm volatile("trap" ::: "memory");
505 }
506
507 static void __used __kprobes jprobe_return_end(void)
508 {
509 };
510
511 int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
512 {
513         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
514
515         /*
516          * FIXME - we should ideally be validating that we got here 'cos
517          * of the "trap" in jprobe_return() above, before restoring the
518          * saved regs...
519          */
520         memcpy(regs, &kcb->jprobe_saved_regs, sizeof(struct pt_regs));
521         preempt_enable_no_resched();
522         return 1;
523 }
524
525 static struct kprobe trampoline_p = {
526         .addr = (kprobe_opcode_t *) &kretprobe_trampoline,
527         .pre_handler = trampoline_probe_handler
528 };
529
530 int __init arch_init_kprobes(void)
531 {
532         return register_kprobe(&trampoline_p);
533 }
534
535 int __kprobes arch_trampoline_kprobe(struct kprobe *p)
536 {
537         if (p->addr == (kprobe_opcode_t *)&kretprobe_trampoline)
538                 return 1;
539
540         return 0;
541 }