kernel/kprobes.c

   1 /*
   2  *  Kernel Probes (KProbes)
   3  *  kernel/kprobes.c
   4  *
   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.
   9  *
  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.
  14  *
  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.
  18  *
  19  * Copyright (C) IBM Corporation, 2002, 2004
  20  *
  21  * 2002-Oct     Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
  22  *              Probes initial implementation (includes suggestions from
  23  *              Rusty Russell).
  24  * 2004-Aug     Updated by Prasanna S Panchamukhi <prasanna@in.ibm.com> with
  25  *              hlists and exceptions notifier as suggested by Andi Kleen.
  26  * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
  27  *              interface to access function arguments.
  28  * 2004-Sep     Prasanna S Panchamukhi <prasanna@in.ibm.com> Changed Kprobes
  29  *              exceptions notifier to be first on the priority list.
  30  */
  31 #include <linux/kprobes.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/hash.h>
  34 #include <linux/init.h>
  35 #include <linux/module.h>
  36 #include <asm/cacheflush.h>
  37 #include <asm/errno.h>
  38 #include <asm/kdebug.h>
  39
  40 #define KPROBE_HASH_BITS 6
  41 #define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS)
  42
  43 static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
  44
  45 unsigned int kprobe_cpu = NR_CPUS;
  46 static spinlock_t kprobe_lock = SPIN_LOCK_UNLOCKED;
  47
  48 /* Locks kprobe: irqs must be disabled */
  49 void lock_kprobes(void)
  50 {
  51         spin_lock(&kprobe_lock);
  52         kprobe_cpu = smp_processor_id();
  53 }
  54
  55 void unlock_kprobes(void)
  56 {
  57         kprobe_cpu = NR_CPUS;
  58         spin_unlock(&kprobe_lock);
  59 }
  60
  61 /* You have to be holding the kprobe_lock */
  62 struct kprobe *get_kprobe(void *addr)
  63 {
  64         struct hlist_head *head;
  65         struct hlist_node *node;
  66
  67         head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)];
  68         hlist_for_each(node, head) {
  69                 struct kprobe *p = hlist_entry(node, struct kprobe, hlist);
  70                 if (p->addr == addr)
  71                         return p;
  72         }
  73         return NULL;
  74 }
  75
  76 int register_kprobe(struct kprobe *p)
  77 {
  78         int ret = 0;
  79         unsigned long flags;
  80
  81         spin_lock_irqsave(&kprobe_lock, flags);
  82         INIT_HLIST_NODE(&p->hlist);
  83         if (get_kprobe(p->addr)) {
  84                 ret = -EEXIST;
  85                 goto out;
  86         }
  87         hlist_add_head(&p->hlist,
  88                        &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
  89
  90         arch_prepare_kprobe(p);
  91         p->opcode = *p->addr;
  92         *p->addr = BREAKPOINT_INSTRUCTION;
  93         flush_icache_range((unsigned long) p->addr,
  94                            (unsigned long) p->addr + sizeof(kprobe_opcode_t));
  95       out:
  96         spin_unlock_irqrestore(&kprobe_lock, flags);
  97         return ret;
  98 }
  99
 100 void unregister_kprobe(struct kprobe *p)
 101 {
 102         unsigned long flags;
 103         spin_lock_irqsave(&kprobe_lock, flags);
 104         *p->addr = p->opcode;
 105         hlist_del(&p->hlist);
 106         flush_icache_range((unsigned long) p->addr,
 107                            (unsigned long) p->addr + sizeof(kprobe_opcode_t));
 108         spin_unlock_irqrestore(&kprobe_lock, flags);
 109 }
 110
 111 static struct notifier_block kprobe_exceptions_nb = {
 112         .notifier_call = kprobe_exceptions_notify,
 113         .priority = 0x7fffffff /* we need to notified first */
 114 };
 115
 116 int register_jprobe(struct jprobe *jp)
 117 {
 118         /* Todo: Verify probepoint is a function entry point */
 119         jp->kp.pre_handler = setjmp_pre_handler;
 120         jp->kp.break_handler = longjmp_break_handler;
 121
 122         return register_kprobe(&jp->kp);
 123 }
 124
 125 void unregister_jprobe(struct jprobe *jp)
 126 {
 127         unregister_kprobe(&jp->kp);
 128 }
 129
 130 static int __init init_kprobes(void)
 131 {
 132         int i, err = 0;
 133
 134         /* FIXME allocate the probe table, currently defined statically */
 135         /* initialize all list heads */
 136         for (i = 0; i < KPROBE_TABLE_SIZE; i++)
 137                 INIT_HLIST_HEAD(&kprobe_table[i]);
 138
 139         err = register_die_notifier(&kprobe_exceptions_nb);
 140         return err;
 141 }
 142
 143 __initcall(init_kprobes);
 144
 145 EXPORT_SYMBOL_GPL(register_kprobe);
 146 EXPORT_SYMBOL_GPL(unregister_kprobe);
 147 EXPORT_SYMBOL_GPL(register_jprobe);
 148 EXPORT_SYMBOL_GPL(unregister_jprobe);
 149 EXPORT_SYMBOL_GPL(jprobe_return);