LXR linux/include/linux/kprobes.h

   1#ifndef _LINUX_KPROBES_H
   2#define _LINUX_KPROBES_H
   3/*
   4 *  Kernel Probes (KProbes)
   5 *  include/linux/kprobes.h
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 2 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20 *
  21 * Copyright (C) IBM Corporation, 2002, 2004
  22 *
  23 * 2002-Oct     Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
  24 *              Probes initial implementation ( includes suggestions from
  25 *              Rusty Russell).
  26 * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
  27 *              interface to access function arguments.
  28 * 2005-May     Hien Nguyen <hien@us.ibm.com> and Jim Keniston
  29 *              <jkenisto@us.ibm.com>  and Prasanna S Panchamukhi
  30 *              <prasanna@in.ibm.com> added function-return probes.
  31 */
  32#include <linux/list.h>
  33#include <linux/notifier.h>
  34#include <linux/smp.h>
  35#include <linux/percpu.h>
  36#include <linux/spinlock.h>
  37#include <linux/rcupdate.h>
  38#include <linux/mutex.h>
  39
  40#ifdef CONFIG_KPROBES
  41#include <asm/kprobes.h>
  42
  43/* kprobe_status settings */
  44#define KPROBE_HIT_ACTIVE       0x00000001
  45#define KPROBE_HIT_SS           0x00000002
  46#define KPROBE_REENTER          0x00000004
  47#define KPROBE_HIT_SSDONE       0x00000008
  48
  49/* Attach to insert probes on any functions which should be ignored*/
  50#define __kprobes       __attribute__((__section__(".kprobes.text")))
  51
  52struct kprobe;
  53struct pt_regs;
  54struct kretprobe;
  55struct kretprobe_instance;
  56typedef int (*kprobe_pre_handler_t) (struct kprobe *, struct pt_regs *);
  57typedef int (*kprobe_break_handler_t) (struct kprobe *, struct pt_regs *);
  58typedef void (*kprobe_post_handler_t) (struct kprobe *, struct pt_regs *,
  59                                       unsigned long flags);
  60typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *,
  61                                       int trapnr);
  62typedef int (*kretprobe_handler_t) (struct kretprobe_instance *,
  63                                    struct pt_regs *);
  64
  65struct kprobe {
  66        struct hlist_node hlist;
  67
  68        /* list of kprobes for multi-handler support */
  69        struct list_head list;
  70
  71        /* Indicates that the corresponding module has been ref counted */
  72        unsigned int mod_refcounted;
  73
  74        /*count the number of times this probe was temporarily disarmed */
  75        unsigned long nmissed;
  76
  77        /* location of the probe point */
  78        kprobe_opcode_t *addr;
  79
  80        /* Allow user to indicate symbol name of the probe point */
  81        const char *symbol_name;
  82
  83        /* Offset into the symbol */
  84        unsigned int offset;
  85
  86        /* Called before addr is executed. */
  87        kprobe_pre_handler_t pre_handler;
  88
  89        /* Called after addr is executed, unless... */
  90        kprobe_post_handler_t post_handler;
  91
  92        /* ... called if executing addr causes a fault (eg. page fault).
  93         * Return 1 if it handled fault, otherwise kernel will see it. */
  94        kprobe_fault_handler_t fault_handler;
  95
  96        /* ... called if breakpoint trap occurs in probe handler.
  97         * Return 1 if it handled break, otherwise kernel will see it. */
  98        kprobe_break_handler_t break_handler;
  99
 100        /* Saved opcode (which has been replaced with breakpoint) */
 101        kprobe_opcode_t opcode;
 102
 103        /* copy of the original instruction */
 104        struct arch_specific_insn ainsn;
 105};
 106
 107/*
 108 * Special probe type that uses setjmp-longjmp type tricks to resume
 109 * execution at a specified entry with a matching prototype corresponding
 110 * to the probed function - a trick to enable arguments to become
 111 * accessible seamlessly by probe handling logic.
 112 * Note:
 113 * Because of the way compilers allocate stack space for local variables
 114 * etc upfront, regardless of sub-scopes within a function, this mirroring
 115 * principle currently works only for probes placed on function entry points.
 116 */
 117struct jprobe {
 118        struct kprobe kp;
 119        void *entry;    /* probe handling code to jump to */
 120};
 121
 122/* For backward compatibility with old code using JPROBE_ENTRY() */
 123#define JPROBE_ENTRY(handler)   (handler)
 124
 125DECLARE_PER_CPU(struct kprobe *, current_kprobe);
 126DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
 127
 128#ifdef ARCH_SUPPORTS_KRETPROBES
 129extern void arch_prepare_kretprobe(struct kretprobe_instance *ri,
 130                                   struct pt_regs *regs);
 131extern int arch_trampoline_kprobe(struct kprobe *p);
 132#else /* ARCH_SUPPORTS_KRETPROBES */
 133static inline void arch_prepare_kretprobe(struct kretprobe *rp,
 134                                        struct pt_regs *regs)
 135{
 136}
 137static inline int arch_trampoline_kprobe(struct kprobe *p)
 138{
 139        return 0;
 140}
 141#endif /* ARCH_SUPPORTS_KRETPROBES */
 142/*
 143 * Function-return probe -
 144 * Note:
 145 * User needs to provide a handler function, and initialize maxactive.
 146 * maxactive - The maximum number of instances of the probed function that
 147 * can be active concurrently.
 148 * nmissed - tracks the number of times the probed function's return was
 149 * ignored, due to maxactive being too low.
 150 *
 151 */
 152struct kretprobe {
 153        struct kprobe kp;
 154        kretprobe_handler_t handler;
 155        int maxactive;
 156        int nmissed;
 157        struct hlist_head free_instances;
 158        struct hlist_head used_instances;
 159};
 160
 161struct kretprobe_instance {
 162        struct hlist_node uflist; /* either on free list or used list */
 163        struct hlist_node hlist;
 164        struct kretprobe *rp;
 165        kprobe_opcode_t *ret_addr;
 166        struct task_struct *task;
 167};
 168
 169struct kretprobe_blackpoint {
 170        const char *name;
 171        void *addr;
 172};
 173extern struct kretprobe_blackpoint kretprobe_blacklist[];
 174
 175static inline void kretprobe_assert(struct kretprobe_instance *ri,
 176        unsigned long orig_ret_address, unsigned long trampoline_address)
 177{
 178        if (!orig_ret_address || (orig_ret_address == trampoline_address)) {
 179                printk("kretprobe BUG!: Processing kretprobe %p @ %p\n",
 180                                ri->rp, ri->rp->kp.addr);
 181                BUG();
 182        }
 183}
 184
 185extern spinlock_t kretprobe_lock;
 186extern struct mutex kprobe_mutex;
 187extern int arch_prepare_kprobe(struct kprobe *p);
 188extern void arch_arm_kprobe(struct kprobe *p);
 189extern void arch_disarm_kprobe(struct kprobe *p);
 190extern int arch_init_kprobes(void);
 191extern void show_registers(struct pt_regs *regs);
 192extern kprobe_opcode_t *get_insn_slot(void);
 193extern void free_insn_slot(kprobe_opcode_t *slot, int dirty);
 194extern void kprobes_inc_nmissed_count(struct kprobe *p);
 195
 196/* Get the kprobe at this addr (if any) - called with preemption disabled */
 197struct kprobe *get_kprobe(void *addr);
 198struct hlist_head * kretprobe_inst_table_head(struct task_struct *tsk);
 199
 200/* kprobe_running() will just return the current_kprobe on this CPU */
 201static inline struct kprobe *kprobe_running(void)
 202{
 203        return (__get_cpu_var(current_kprobe));
 204}
 205
 206static inline void reset_current_kprobe(void)
 207{
 208        __get_cpu_var(current_kprobe) = NULL;
 209}
 210
 211static inline struct kprobe_ctlblk *get_kprobe_ctlblk(void)
 212{
 213        return (&__get_cpu_var(kprobe_ctlblk));
 214}
 215
 216int register_kprobe(struct kprobe *p);
 217void unregister_kprobe(struct kprobe *p);
 218int setjmp_pre_handler(struct kprobe *, struct pt_regs *);
 219int longjmp_break_handler(struct kprobe *, struct pt_regs *);
 220int register_jprobe(struct jprobe *p);
 221void unregister_jprobe(struct jprobe *p);
 222void jprobe_return(void);
 223unsigned long arch_deref_entry_point(void *);
 224
 225int register_kretprobe(struct kretprobe *rp);
 226void unregister_kretprobe(struct kretprobe *rp);
 227
 228void kprobe_flush_task(struct task_struct *tk);
 229void recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head);
 230#else /* CONFIG_KPROBES */
 231
 232#define __kprobes       /**/
 233struct jprobe;
 234struct kretprobe;
 235
 236static inline struct kprobe *kprobe_running(void)
 237{
 238        return NULL;
 239}
 240static inline int register_kprobe(struct kprobe *p)
 241{
 242        return -ENOSYS;
 243}
 244static inline void unregister_kprobe(struct kprobe *p)
 245{
 246}
 247static inline int register_jprobe(struct jprobe *p)
 248{
 249        return -ENOSYS;
 250}
 251static inline void unregister_jprobe(struct jprobe *p)
 252{
 253}
 254static inline void jprobe_return(void)
 255{
 256}
 257static inline int register_kretprobe(struct kretprobe *rp)
 258{
 259        return -ENOSYS;
 260}
 261static inline void unregister_kretprobe(struct kretprobe *rp)
 262{
 263}
 264static inline void kprobe_flush_task(struct task_struct *tk)
 265{
 266}
 267#endif                          /* CONFIG_KPROBES */
 268#endif                          /* _LINUX_KPROBES_H */
 269