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 DEFINE_SPINLOCK(kprobe_lock);
  47 static struct kprobe *curr_kprobe;
  48
  49 /* Locks kprobe: irqs must be disabled */
  50 void lock_kprobes(void)
  51 {
  52         spin_lock(&kprobe_lock);
  53         kprobe_cpu = smp_processor_id();
  54 }
  55
  56 void unlock_kprobes(void)
  57 {
  58         kprobe_cpu = NR_CPUS;
  59         spin_unlock(&kprobe_lock);
  60 }
  61
  62 /* You have to be holding the kprobe_lock */
  63 struct kprobe *get_kprobe(void *addr)
  64 {
  65         struct hlist_head *head;
  66         struct hlist_node *node;
  67
  68         head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)];
  69         hlist_for_each(node, head) {
  70                 struct kprobe *p = hlist_entry(node, struct kprobe, hlist);
  71                 if (p->addr == addr)
  72                         return p;
  73         }
  74         return NULL;
  75 }
  76
  77 /*
  78  * Aggregate handlers for multiple kprobes support - these handlers
  79  * take care of invoking the individual kprobe handlers on p->list
  80  */
  81 int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs)
  82 {
  83         struct kprobe *kp;
  84
  85         list_for_each_entry(kp, &p->list, list) {
  86                 if (kp->pre_handler) {
  87                         curr_kprobe = kp;
  88                         kp->pre_handler(kp, regs);
  89                         curr_kprobe = NULL;
  90                 }
  91         }
  92         return 0;
  93 }
  94
  95 void aggr_post_handler(struct kprobe *p, struct pt_regs *regs,
  96                 unsigned long flags)
  97 {
  98         struct kprobe *kp;
  99
 100         list_for_each_entry(kp, &p->list, list) {
 101                 if (kp->post_handler) {
 102                         curr_kprobe = kp;
 103                         kp->post_handler(kp, regs, flags);
 104                         curr_kprobe = NULL;
 105                 }
 106         }
 107         return;
 108 }
 109
 110 int aggr_fault_handler(struct kprobe *p, struct pt_regs *regs, int trapnr)
 111 {
 112         /*
 113          * if we faulted "during" the execution of a user specified
 114          * probe handler, invoke just that probe's fault handler
 115          */
 116         if (curr_kprobe && curr_kprobe->fault_handler) {
 117                 if (curr_kprobe->fault_handler(curr_kprobe, regs, trapnr))
 118                         return 1;
 119         }
 120         return 0;
 121 }
 122
 123 /*
 124  * Fill in the required fields of the "manager kprobe". Replace the
 125  * earlier kprobe in the hlist with the manager kprobe
 126  */
 127 static inline void add_aggr_kprobe(struct kprobe *ap, struct kprobe *p)
 128 {
 129         ap->addr = p->addr;
 130         ap->opcode = p->opcode;
 131         memcpy(&ap->ainsn, &p->ainsn, sizeof(struct arch_specific_insn));
 132
 133         ap->pre_handler = aggr_pre_handler;
 134         ap->post_handler = aggr_post_handler;
 135         ap->fault_handler = aggr_fault_handler;
 136
 137         INIT_LIST_HEAD(&ap->list);
 138         list_add(&p->list, &ap->list);
 139
 140         INIT_HLIST_NODE(&ap->hlist);
 141         hlist_del(&p->hlist);
 142         hlist_add_head(&ap->hlist,
 143                 &kprobe_table[hash_ptr(ap->addr, KPROBE_HASH_BITS)]);
 144 }
 145
 146 /*
 147  * This is the second or subsequent kprobe at the address - handle
 148  * the intricacies
 149  * TODO: Move kcalloc outside the spinlock
 150  */
 151 static int register_aggr_kprobe(struct kprobe *old_p, struct kprobe *p)
 152 {
 153         int ret = 0;
 154         struct kprobe *ap;
 155
 156         if (old_p->break_handler || p->break_handler) {
 157                 ret = -EEXIST;  /* kprobe and jprobe can't (yet) coexist */
 158         } else if (old_p->pre_handler == aggr_pre_handler) {
 159                 list_add(&p->list, &old_p->list);
 160         } else {
 161                 ap = kcalloc(1, sizeof(struct kprobe), GFP_ATOMIC);
 162                 if (!ap)
 163                         return -ENOMEM;
 164                 add_aggr_kprobe(ap, old_p);
 165                 list_add(&p->list, &ap->list);
 166         }
 167         return ret;
 168 }
 169
 170 /* kprobe removal house-keeping routines */
 171 static inline void cleanup_kprobe(struct kprobe *p, unsigned long flags)
 172 {
 173         *p->addr = p->opcode;
 174         hlist_del(&p->hlist);
 175         flush_icache_range((unsigned long) p->addr,
 176                    (unsigned long) p->addr + sizeof(kprobe_opcode_t));
 177         spin_unlock_irqrestore(&kprobe_lock, flags);
 178         arch_remove_kprobe(p);
 179 }
 180
 181 static inline void cleanup_aggr_kprobe(struct kprobe *old_p,
 182                 struct kprobe *p, unsigned long flags)
 183 {
 184         list_del(&p->list);
 185         if (list_empty(&old_p->list)) {
 186                 cleanup_kprobe(old_p, flags);
 187                 kfree(old_p);
 188         } else
 189                 spin_unlock_irqrestore(&kprobe_lock, flags);
 190 }
 191
 192 int register_kprobe(struct kprobe *p)
 193 {
 194         int ret = 0;
 195         unsigned long flags = 0;
 196         struct kprobe *old_p;
 197
 198         if ((ret = arch_prepare_kprobe(p)) != 0) {
 199                 goto rm_kprobe;
 200         }
 201         spin_lock_irqsave(&kprobe_lock, flags);
 202         old_p = get_kprobe(p->addr);
 203         if (old_p) {
 204                 ret = register_aggr_kprobe(old_p, p);
 205                 goto out;
 206         }
 207
 208         arch_copy_kprobe(p);
 209         INIT_HLIST_NODE(&p->hlist);
 210         hlist_add_head(&p->hlist,
 211                        &kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
 212
 213         p->opcode = *p->addr;
 214         *p->addr = BREAKPOINT_INSTRUCTION;
 215         flush_icache_range((unsigned long) p->addr,
 216                            (unsigned long) p->addr + sizeof(kprobe_opcode_t));
 217 out:
 218         spin_unlock_irqrestore(&kprobe_lock, flags);
 219 rm_kprobe:
 220         if (ret == -EEXIST)
 221                 arch_remove_kprobe(p);
 222         return ret;
 223 }
 224
 225 void unregister_kprobe(struct kprobe *p)
 226 {
 227         unsigned long flags;
 228         struct kprobe *old_p;
 229
 230         spin_lock_irqsave(&kprobe_lock, flags);
 231         old_p = get_kprobe(p->addr);
 232         if (old_p) {
 233                 if (old_p->pre_handler == aggr_pre_handler)
 234                         cleanup_aggr_kprobe(old_p, p, flags);
 235                 else
 236                         cleanup_kprobe(p, flags);
 237         } else
 238                 spin_unlock_irqrestore(&kprobe_lock, flags);
 239 }
 240
 241 static struct notifier_block kprobe_exceptions_nb = {
 242         .notifier_call = kprobe_exceptions_notify,
 243         .priority = 0x7fffffff /* we need to notified first */
 244 };
 245
 246 int register_jprobe(struct jprobe *jp)
 247 {
 248         /* Todo: Verify probepoint is a function entry point */
 249         jp->kp.pre_handler = setjmp_pre_handler;
 250         jp->kp.break_handler = longjmp_break_handler;
 251
 252         return register_kprobe(&jp->kp);
 253 }
 254
 255 void unregister_jprobe(struct jprobe *jp)
 256 {
 257         unregister_kprobe(&jp->kp);
 258 }
 259
 260 static int __init init_kprobes(void)
 261 {
 262         int i, err = 0;
 263
 264         /* FIXME allocate the probe table, currently defined statically */
 265         /* initialize all list heads */
 266         for (i = 0; i < KPROBE_TABLE_SIZE; i++)
 267                 INIT_HLIST_HEAD(&kprobe_table[i]);
 268
 269         err = register_die_notifier(&kprobe_exceptions_nb);
 270         return err;
 271 }
 272
 273 __initcall(init_kprobes);
 274
 275 EXPORT_SYMBOL_GPL(register_kprobe);
 276 EXPORT_SYMBOL_GPL(unregister_kprobe);
 277 EXPORT_SYMBOL_GPL(register_jprobe);
 278 EXPORT_SYMBOL_GPL(unregister_jprobe);
 279 EXPORT_SYMBOL_GPL(jprobe_return);