2 * Kernel Probes (KProbes)
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 * Copyright (C) IBM Corporation, 2002, 2004
23 * Dynamic Binary Instrumentation Module based on KProbes
24 * modules/kprobe/dbi_kprobes.h
26 * This program is free software; you can redistribute it and/or modify
27 * it under the terms of the GNU General Public License as published by
28 * the Free Software Foundation; either version 2 of the License, or
29 * (at your option) any later version.
31 * This program is distributed in the hope that it will be useful,
32 * but WITHOUT ANY WARRANTY; without even the implied warranty of
33 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 * GNU General Public License for more details.
36 * You should have received a copy of the GNU General Public License
37 * along with this program; if not, write to the Free Software
38 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
40 * Copyright (C) Samsung Electronics, 2006-2010
42 * 2006-2007 Ekaterina Gorelkina <e.gorelkina@samsung.com>: initial implementation for ARM and MIPS
43 * 2008-2009 Alexey Gerenkov <a.gerenkov@samsung.com> User-Space
44 * Probes initial implementation; Support x86/ARM/MIPS for both user and kernel spaces.
45 * 2010 Ekaterina Gorelkina <e.gorelkina@samsung.com>: redesign module for separating core and arch parts
49 #include "dbi_kprobes.h"
50 #include "arch/asm/dbi_kprobes.h"
52 #include "dbi_kdebug.h"
53 #include "dbi_kprobes_deps.h"
54 #include "dbi_insn_slots.h"
57 #include <linux/version.h>
58 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
59 #include <linux/config.h>
62 #include <linux/hash.h>
63 #include <linux/module.h>
65 #include <linux/pagemap.h>
67 struct slot_manager sm;
69 DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
70 static DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
72 DEFINE_SPINLOCK(kretprobe_lock); /* Protects kretprobe_inst_table */
73 EXPORT_SYMBOL_GPL(kretprobe_lock);
74 static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
76 struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
77 static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
79 atomic_t kprobe_count;
80 EXPORT_SYMBOL_GPL(kprobe_count);
82 static void *sm_alloc(struct slot_manager *sm)
84 return kmalloc(PAGE_SIZE, GFP_ATOMIC);
87 static void sm_free(struct slot_manager *sm, void *ptr)
94 sm.slot_size = KPROBES_TRAMP_LEN;
97 INIT_HLIST_NODE(&sm.page_list);
100 static void exit_sm()
105 void kretprobe_assert(struct kretprobe_instance *ri, unsigned long orig_ret_address, unsigned long trampoline_address)
107 if (!orig_ret_address || (orig_ret_address == trampoline_address)) {
108 struct task_struct *task;
110 panic("kretprobe BUG!: ri = NULL\n");
116 panic("kretprobe BUG!: task = NULL\n");
119 if (ri->rp == NULL) {
120 panic("kretprobe BUG!: ri->rp = NULL\n");
123 panic("kretprobe BUG!: Processing kretprobe %p @ %p (%d/%d - %s)\n",
124 ri->rp, ri->rp->kp.addr, ri->task->tgid, ri->task->pid, ri->task->comm);
128 /* We have preemption disabled.. so it is safe to use __ versions */
129 static inline void set_kprobe_instance(struct kprobe *kp)
131 __get_cpu_var(kprobe_instance) = kp;
134 static inline void reset_kprobe_instance(void)
136 __get_cpu_var(kprobe_instance) = NULL;
139 /* kprobe_running() will just return the current_kprobe on this CPU */
140 struct kprobe *kprobe_running(void)
142 return __get_cpu_var(current_kprobe);
145 void reset_current_kprobe(void)
147 __get_cpu_var(current_kprobe) = NULL;
150 struct kprobe_ctlblk *get_kprobe_ctlblk(void)
152 return &__get_cpu_var(kprobe_ctlblk);
156 * This routine is called either:
157 * - under the kprobe_mutex - during kprobe_[un]register()
159 * - with preemption disabled - from arch/xxx/kernel/kprobes.c
161 struct kprobe *get_kprobe(void *addr)
163 struct hlist_head *head;
164 struct hlist_node *node;
167 head = &kprobe_table[hash_ptr (addr, KPROBE_HASH_BITS)];
168 swap_hlist_for_each_entry_rcu(p, node, head, hlist) {
169 if (p->addr == addr) {
178 * Aggregate handlers for multiple kprobes support - these handlers
179 * take care of invoking the individual kprobe handlers on p->list
181 static int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs)
186 list_for_each_entry_rcu(kp, &p->list, list) {
187 if (kp->pre_handler) {
188 set_kprobe_instance(kp);
189 ret = kp->pre_handler(kp, regs);
193 reset_kprobe_instance();
199 static void aggr_post_handler(struct kprobe *p, struct pt_regs *regs, unsigned long flags)
203 list_for_each_entry_rcu(kp, &p->list, list) {
204 if (kp->post_handler) {
205 set_kprobe_instance(kp);
206 kp->post_handler(kp, regs, flags);
207 reset_kprobe_instance();
212 static int aggr_fault_handler(struct kprobe *p, struct pt_regs *regs, int trapnr)
214 struct kprobe *cur = __get_cpu_var(kprobe_instance);
217 * if we faulted "during" the execution of a user specified
218 * probe handler, invoke just that probe's fault handler
220 if (cur && cur->fault_handler) {
221 if (cur->fault_handler(cur, regs, trapnr))
228 static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs)
230 struct kprobe *cur = __get_cpu_var(kprobe_instance);
232 DBPRINTF ("cur = 0x%p\n", cur);
234 DBPRINTF ("cur = 0x%p cur->break_handler = 0x%p\n", cur, cur->break_handler);
236 if (cur && cur->break_handler) {
237 if (cur->break_handler(cur, regs))
240 reset_kprobe_instance();
245 /* Walks the list and increments nmissed count for multiprobe case */
246 void kprobes_inc_nmissed_count(struct kprobe *p)
249 if (p->pre_handler != aggr_pre_handler) {
252 list_for_each_entry_rcu(kp, &p->list, list) {
258 /* Called with kretprobe_lock held */
259 struct kretprobe_instance *get_free_rp_inst(struct kretprobe *rp)
261 struct hlist_node *node;
262 struct kretprobe_instance *ri;
264 swap_hlist_for_each_entry(ri, node, &rp->free_instances, uflist) {
268 if (!alloc_nodes_kretprobe(rp)) {
269 swap_hlist_for_each_entry(ri, node, &rp->free_instances, uflist) {
276 EXPORT_SYMBOL_GPL(get_free_rp_inst);
278 /* Called with kretprobe_lock held */
279 struct kretprobe_instance *get_free_rp_inst_no_alloc(struct kretprobe *rp)
281 struct hlist_node *node;
282 struct kretprobe_instance *ri;
284 swap_hlist_for_each_entry(ri, node, &rp->free_instances, uflist) {
291 /* Called with kretprobe_lock held */
292 struct kretprobe_instance *get_used_rp_inst(struct kretprobe *rp)
294 struct hlist_node *node;
295 struct kretprobe_instance *ri;
297 swap_hlist_for_each_entry(ri, node, &rp->used_instances, uflist) {
303 EXPORT_SYMBOL_GPL(get_used_rp_inst);
305 /* Called with kretprobe_lock held */
306 void add_rp_inst (struct kretprobe_instance *ri)
309 * Remove rp inst off the free list -
310 * Add it back when probed function returns
312 hlist_del(&ri->uflist);
314 /* Add rp inst onto table */
315 INIT_HLIST_NODE(&ri->hlist);
317 hlist_add_head(&ri->hlist, &kretprobe_inst_table[hash_ptr(ri->task, KPROBE_HASH_BITS)]);
319 /* Also add this rp inst to the used list. */
320 INIT_HLIST_NODE(&ri->uflist);
321 hlist_add_head(&ri->uflist, &ri->rp->used_instances);
323 EXPORT_SYMBOL_GPL(add_rp_inst);
325 /* Called with kretprobe_lock held */
326 void recycle_rp_inst(struct kretprobe_instance *ri)
329 hlist_del(&ri->hlist);
330 /* remove rp inst off the used list */
331 hlist_del(&ri->uflist);
332 /* put rp inst back onto the free list */
333 INIT_HLIST_NODE(&ri->uflist);
334 hlist_add_head(&ri->uflist, &ri->rp->free_instances);
337 EXPORT_SYMBOL_GPL(recycle_rp_inst);
339 struct hlist_head *kretprobe_inst_table_head(void *hash_key)
341 return &kretprobe_inst_table[hash_ptr(hash_key, KPROBE_HASH_BITS)];
343 EXPORT_SYMBOL_GPL(kretprobe_inst_table_head);
345 void free_rp_inst(struct kretprobe *rp)
347 struct kretprobe_instance *ri;
348 while ((ri = get_free_rp_inst_no_alloc(rp)) != NULL) {
349 hlist_del(&ri->uflist);
353 EXPORT_SYMBOL_GPL(free_rp_inst);
356 * Keep all fields in the kprobe consistent
358 static inline void copy_kprobe(struct kprobe *old_p, struct kprobe *p)
360 memcpy(&p->opcode, &old_p->opcode, sizeof(kprobe_opcode_t));
361 memcpy(&p->ainsn, &old_p->ainsn, sizeof(struct arch_specific_insn));
362 p->ss_addr = old_p->ss_addr;
364 p->safe_arm = old_p->safe_arm;
365 p->safe_thumb = old_p->safe_thumb;
370 * Add the new probe to old_p->list. Fail if this is the
371 * second jprobe at the address - two jprobes can't coexist
373 static int add_new_kprobe(struct kprobe *old_p, struct kprobe *p)
375 if (p->break_handler) {
376 if (old_p->break_handler) {
380 list_add_tail_rcu(&p->list, &old_p->list);
381 old_p->break_handler = aggr_break_handler;
383 list_add_rcu(&p->list, &old_p->list);
386 if (p->post_handler && !old_p->post_handler) {
387 old_p->post_handler = aggr_post_handler;
394 * hlist_replace_rcu - replace old entry by new one
395 * @old : the element to be replaced
396 * @new : the new element to insert
398 * The @old entry will be replaced with the @new entry atomically.
400 inline void dbi_hlist_replace_rcu(struct hlist_node *old, struct hlist_node *new)
402 struct hlist_node *next = old->next;
405 new->pprev = old->pprev;
408 new->next->pprev = &new->next;
411 old->pprev = LIST_POISON2;
415 * Fill in the required fields of the "manager kprobe". Replace the
416 * earlier kprobe in the hlist with the manager kprobe
418 static inline void add_aggr_kprobe(struct kprobe *ap, struct kprobe *p)
422 ap->pre_handler = aggr_pre_handler;
423 ap->fault_handler = aggr_fault_handler;
425 ap->post_handler = aggr_post_handler;
426 if (p->break_handler)
427 ap->break_handler = aggr_break_handler;
429 INIT_LIST_HEAD(&ap->list);
430 list_add_rcu(&p->list, &ap->list);
432 dbi_hlist_replace_rcu(&p->hlist, &ap->hlist);
436 * This is the second or subsequent kprobe at the address - handle
439 int register_aggr_kprobe(struct kprobe *old_p, struct kprobe *p)
443 DBPRINTF ("start\n");
445 DBPRINTF ("p = %p old_p = %p \n", p, old_p);
446 if (old_p->pre_handler == aggr_pre_handler) {
447 DBPRINTF ("aggr_pre_handler \n");
449 copy_kprobe(old_p, p);
450 ret = add_new_kprobe(old_p, p);
452 DBPRINTF ("kzalloc\n");
454 ap = kzalloc(sizeof(struct kprobe), GFP_KERNEL);
456 ap = kmalloc(sizeof(struct kprobe), GFP_KERNEL);
458 memset(ap, 0, sizeof(struct kprobe));
462 add_aggr_kprobe(ap, old_p);
464 DBPRINTF ("ap = %p p = %p old_p = %p \n", ap, p, old_p);
465 ret = add_new_kprobe(ap, p);
470 EXPORT_SYMBOL_GPL(register_aggr_kprobe);
472 static void remove_kprobe(struct kprobe *p)
474 /* TODO: check boostable for x86 and MIPS */
475 free_insn_slot(&sm, p->ainsn.insn);
478 int dbi_register_kprobe(struct kprobe *p)
480 struct kprobe *old_p;
483 * If we have a symbol_name argument look it up,
484 * and add it to the address. That way the addr
485 * field can either be global or relative to a symbol.
487 if (p->symbol_name) {
490 p->addr = (kprobe_opcode_t *)swap_ksyms(p->symbol_name);
495 DBPRINTF ("p->addr = 0x%p\n", p->addr);
496 p->addr = (kprobe_opcode_t *)(((char *)p->addr) + p->offset);
497 DBPRINTF ("p->addr = 0x%p p = 0x%p\n", p->addr, p);
499 #ifdef KPROBES_PROFILE
500 p->start_tm.tv_sec = p->start_tm.tv_usec = 0;
501 p->hnd_tm_sum.tv_sec = p->hnd_tm_sum.tv_usec = 0;
504 p->mod_refcounted = 0;
507 old_p = get_kprobe(p->addr);
509 ret = register_aggr_kprobe(old_p, p);
511 atomic_inc(&kprobe_count);
515 if ((ret = arch_prepare_kprobe(p, &sm)) != 0)
518 DBPRINTF ("before out ret = 0x%x\n", ret);
519 INIT_HLIST_NODE(&p->hlist);
520 hlist_add_head_rcu(&p->hlist, &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
524 DBPRINTF ("out ret = 0x%x\n", ret);
528 void dbi_unregister_kprobe(struct kprobe *p, struct task_struct *task)
530 struct kprobe *old_p, *list_p;
533 old_p = get_kprobe(p->addr);
534 DBPRINTF ("dbi_unregister_kprobe p=%p old_p=%p", p, old_p);
535 if (unlikely (!old_p))
539 list_for_each_entry_rcu(list_p, &old_p->list, list)
541 /* kprobe p is a valid probe */
547 DBPRINTF ("dbi_unregister_kprobe valid_p");
548 if ((old_p == p) || ((old_p->pre_handler == aggr_pre_handler) &&
549 (p->list.next == &old_p->list) && (p->list.prev == &old_p->list))) {
550 /* Only probe on the hash list */
551 arch_disarm_kprobe(p);
552 hlist_del_rcu(&old_p->hlist);
555 list_del_rcu(&p->list);
558 DBPRINTF ("dbi_unregister_kprobe cleanup_p=%d", cleanup_p);
562 list_del_rcu(&p->list);
572 if (p->break_handler)
573 old_p->break_handler = NULL;
574 if (p->post_handler) {
575 list_for_each_entry_rcu(list_p, &old_p->list, list) {
576 if (list_p->post_handler) {
583 old_p->post_handler = NULL;
588 int dbi_register_jprobe(struct jprobe *jp)
590 /* Todo: Verify probepoint is a function entry point */
591 jp->kp.pre_handler = setjmp_pre_handler;
592 jp->kp.break_handler = longjmp_break_handler;
594 return dbi_register_kprobe(&jp->kp);
597 void dbi_unregister_jprobe(struct jprobe *jp)
599 dbi_unregister_kprobe(&jp->kp, NULL);
603 * This kprobe pre_handler is registered with every kretprobe. When probe
604 * hits it will set up the return probe.
606 static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
608 struct kretprobe *rp = container_of(p, struct kretprobe, kp);
609 struct kretprobe_instance *ri;
610 unsigned long flags = 0;
612 /* TODO: consider to only swap the RA after the last pre_handler fired */
613 spin_lock_irqsave(&kretprobe_lock, flags);
615 /* TODO: test - remove retprobe after func entry but before its exit */
616 if ((ri = get_free_rp_inst(rp)) != NULL) {
620 if (rp->entry_handler) {
621 rp->entry_handler(ri, regs, ri->rp->priv_arg);
624 arch_prepare_kretprobe(ri, regs);
631 spin_unlock_irqrestore(&kretprobe_lock, flags);
636 struct kretprobe *sched_rp;
638 #define SCHED_RP_NR 200
639 #define COMMON_RP_NR 10
641 int alloc_nodes_kretprobe(struct kretprobe *rp)
644 struct kretprobe_instance *inst;
647 DBPRINTF("Alloc aditional mem for retprobes");
649 if ((unsigned long)rp->kp.addr == sched_addr) {
650 rp->maxactive += SCHED_RP_NR;//max (100, 2 * NR_CPUS);
651 alloc_nodes = SCHED_RP_NR;
653 #if 1//def CONFIG_PREEMPT
654 rp->maxactive += max (COMMON_RP_NR, 2 * NR_CPUS);
656 rp->maxacpptive += NR_CPUS;
658 alloc_nodes = COMMON_RP_NR;
661 for (i = 0; i < alloc_nodes; i++) {
662 inst = kmalloc(sizeof(inst) + rp->data_size, GFP_ATOMIC);
667 INIT_HLIST_NODE(&inst->uflist);
668 hlist_add_head(&inst->uflist, &rp->free_instances);
671 DBPRINTF ("addr=%p, *addr=[%lx %lx %lx]", rp->kp.addr, (unsigned long) (*(rp->kp.addr)), (unsigned long) (*(rp->kp.addr + 1)), (unsigned long) (*(rp->kp.addr + 2)));
675 int dbi_register_kretprobe(struct kretprobe *rp)
678 struct kretprobe_instance *inst;
682 rp->kp.pre_handler = pre_handler_kretprobe;
683 rp->kp.post_handler = NULL;
684 rp->kp.fault_handler = NULL;
685 rp->kp.break_handler = NULL;
687 /* Pre-allocate memory for max kretprobe instances */
688 if ((unsigned long)rp->kp.addr == sched_addr) {
689 rp->maxactive = SCHED_RP_NR;//max (100, 2 * NR_CPUS);
690 rp->kp.pre_handler = NULL; //not needed for __switch_to
691 } else if ((unsigned long)rp->kp.addr == exit_addr) {
692 rp->kp.pre_handler = NULL; //not needed for do_exit
694 } else if (rp->maxactive <= 0) {
695 #if 1//def CONFIG_PREEMPT
696 rp->maxactive = max (COMMON_RP_NR, 2 * NR_CPUS);
698 rp->maxactive = NR_CPUS;
701 INIT_HLIST_HEAD(&rp->used_instances);
702 INIT_HLIST_HEAD(&rp->free_instances);
703 for (i = 0; i < rp->maxactive; i++) {
704 inst = kmalloc(sizeof(*inst) + rp->data_size, GFP_KERNEL);
709 INIT_HLIST_NODE(&inst->uflist);
710 hlist_add_head(&inst->uflist, &rp->free_instances);
713 DBPRINTF ("addr=%p, *addr=[%lx %lx %lx]", rp->kp.addr, (unsigned long) (*(rp->kp.addr)), (unsigned long) (*(rp->kp.addr + 1)), (unsigned long) (*(rp->kp.addr + 2)));
715 /* Establish function entry probe point */
716 if ((ret = dbi_register_kprobe(&rp->kp)) != 0)
719 DBPRINTF ("addr=%p, *addr=[%lx %lx %lx]", rp->kp.addr, (unsigned long) (*(rp->kp.addr)), (unsigned long) (*(rp->kp.addr + 1)), (unsigned long) (*(rp->kp.addr + 2)));
720 if ((unsigned long)rp->kp.addr == sched_addr) {
727 static int dbi_disarm_krp_inst(struct kretprobe_instance *ri);
729 void dbi_unregister_kretprobe(struct kretprobe *rp)
732 struct kretprobe_instance *ri;
734 dbi_unregister_kprobe(&rp->kp, NULL);
737 spin_lock_irqsave(&kretprobe_lock, flags);
739 if ((unsigned long)rp->kp.addr == sched_addr)
742 while ((ri = get_used_rp_inst(rp)) != NULL) {
743 if (dbi_disarm_krp_inst(ri) == 0)
746 panic("%s (%d/%d): cannot disarm krp instance (%08lx)",
747 ri->task->comm, ri->task->tgid, ri->task->pid,
748 (unsigned long)rp->kp.addr);
751 spin_unlock_irqrestore(&kretprobe_lock, flags);
755 struct kretprobe *clone_kretprobe(struct kretprobe *rp)
757 struct kprobe *old_p;
758 struct kretprobe *clone = NULL;
761 clone = kmalloc(sizeof(struct kretprobe), GFP_KERNEL);
763 DBPRINTF ("failed to alloc memory for clone probe %p!", rp->kp.addr);
766 memcpy(clone, rp, sizeof(struct kretprobe));
767 clone->kp.pre_handler = pre_handler_kretprobe;
768 clone->kp.post_handler = NULL;
769 clone->kp.fault_handler = NULL;
770 clone->kp.break_handler = NULL;
771 old_p = get_kprobe(rp->kp.addr);
773 ret = register_aggr_kprobe(old_p, &clone->kp);
778 atomic_inc(&kprobe_count);
783 EXPORT_SYMBOL_GPL(clone_kretprobe);
785 static void inline set_task_trampoline(struct task_struct *p, struct kretprobe_instance *ri, unsigned long tramp_addr)
787 unsigned long pc = arch_get_task_pc(p);
788 if (pc == tramp_addr)
789 panic("[%d] %s (%d/%d): pc = %08lx --- [%d] %s (%d/%d)\n",
790 task_cpu(p), p->comm, p->tgid, p->pid, pc,
791 task_cpu(current), current->comm, current->tgid, current->pid);
792 ri->ret_addr = (kprobe_opcode_t *)pc;
793 arch_set_task_pc(p, tramp_addr);
796 static void inline rm_task_trampoline(struct task_struct *p, struct kretprobe_instance *ri)
798 arch_set_task_pc(p, (unsigned long)ri->ret_addr);
801 static int dbi_disarm_krp_inst(struct kretprobe_instance *ri)
803 kprobe_opcode_t *tramp = (kprobe_opcode_t *)&kretprobe_trampoline;
804 kprobe_opcode_t *sp = ri->sp;
805 kprobe_opcode_t *found = NULL;
806 int retval = -ENOENT;
809 unsigned long pc = arch_get_task_pc(ri->task);
811 printk("---> [%d] %s (%d/%d): pc = %08lx, ra = %08lx, tramp= %08lx (%08lx)\n",
813 ri->task->comm, ri->task->tgid, ri->task->pid,
814 pc, (unsigned long)ri->ret_addr,
815 (unsigned long)tramp,
816 (unsigned long)(ri->rp ? ri->rp->kp.addr: NULL));
818 /* __switch_to retprobe handling */
819 if (pc == (unsigned long)tramp) {
820 rm_task_trampoline(ri->task, ri);
827 while (sp > ri->sp - RETPROBE_STACK_DEPTH) {
828 if ((unsigned long)*sp == (unsigned long)tramp) {
836 printk("---> [%d] %s (%d/%d): tramp (%08lx) found at %08lx (%08lx /%+d) - %p\n",
838 ri->task->comm, ri->task->tgid, ri->task->pid,
839 (unsigned long)tramp,
840 (unsigned long)found, (unsigned long)ri->sp, found - ri->sp,
841 ri->rp ? ri->rp->kp.addr: NULL);
842 *found = (unsigned long)ri->ret_addr;
845 printk("---> [%d] %s (%d/%d): tramp (%08lx) NOT found at sp = %08lx - %p\n",
847 ri->task->comm, ri->task->tgid, ri->task->pid,
848 (unsigned long)tramp,
849 (unsigned long)ri->sp, ri->rp ? ri->rp->kp.addr: NULL);
855 int patch_suspended_task(struct kretprobe *rp, struct task_struct *task)
857 struct kretprobe_instance *ri;
859 kprobe_opcode_t *tramp = (kprobe_opcode_t *)&kretprobe_trampoline;
861 spin_lock_irqsave(&kretprobe_lock, flags);
863 ri = get_free_rp_inst(rp);
870 set_task_trampoline(task, ri, (unsigned long)tramp);
873 spin_unlock_irqrestore(&kretprobe_lock, flags);
877 static int init_module_deps(void)
881 sched_addr = swap_ksyms("__switch_to");
882 fork_addr = swap_ksyms("do_fork");
883 exit_addr = swap_ksyms("do_exit");
885 if (sched_addr == 0 || fork_addr == 0 || exit_addr == 0) {
889 ret = init_module_dependencies();
894 return arch_init_module_deps();
897 static int __init init_kprobes(void)
903 /* FIXME allocate the probe table, currently defined statically */
904 /* initialize all list heads */
905 for (i = 0; i < KPROBE_TABLE_SIZE; ++i) {
906 INIT_HLIST_HEAD(&kprobe_table[i]);
907 INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
909 atomic_set(&kprobe_count, 0);
911 err = init_module_deps();
916 err = arch_init_kprobes();
918 DBPRINTF ("init_kprobes: arch_init_kprobes - %d", err);
923 static void __exit exit_kprobes(void)
929 module_init(init_kprobes);
930 module_exit(exit_kprobes);
932 EXPORT_SYMBOL_GPL(dbi_register_kprobe);
933 EXPORT_SYMBOL_GPL(dbi_unregister_kprobe);
934 EXPORT_SYMBOL_GPL(dbi_register_jprobe);
935 EXPORT_SYMBOL_GPL(dbi_unregister_jprobe);
936 EXPORT_SYMBOL_GPL(dbi_jprobe_return);
937 EXPORT_SYMBOL_GPL(dbi_register_kretprobe);
938 EXPORT_SYMBOL_GPL(dbi_unregister_kretprobe);
940 MODULE_LICENSE("Dual BSD/GPL");