LXR linux/include/linux/kprobes.h

   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2#ifndef _LINUX_KPROBES_H
   3#define _LINUX_KPROBES_H
   4/*
   5 *  Kernel Probes (KProbes)
   6 *  include/linux/kprobes.h
   7 *
   8 * Copyright (C) IBM Corporation, 2002, 2004
   9 *
  10 * 2002-Oct     Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
  11 *              Probes initial implementation ( includes suggestions from
  12 *              Rusty Russell).
  13 * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
  14 *              interface to access function arguments.
  15 * 2005-May     Hien Nguyen <hien@us.ibm.com> and Jim Keniston
  16 *              <jkenisto@us.ibm.com>  and Prasanna S Panchamukhi
  17 *              <prasanna@in.ibm.com> added function-return probes.
  18 */
  19#include <linux/compiler.h>
  20#include <linux/linkage.h>
  21#include <linux/list.h>
  22#include <linux/notifier.h>
  23#include <linux/smp.h>
  24#include <linux/bug.h>
  25#include <linux/percpu.h>
  26#include <linux/spinlock.h>
  27#include <linux/rcupdate.h>
  28#include <linux/mutex.h>
  29#include <linux/ftrace.h>
  30#include <asm/kprobes.h>
  31
  32#ifdef CONFIG_KPROBES
  33
  34/* kprobe_status settings */
  35#define KPROBE_HIT_ACTIVE       0x00000001
  36#define KPROBE_HIT_SS           0x00000002
  37#define KPROBE_REENTER          0x00000004
  38#define KPROBE_HIT_SSDONE       0x00000008
  39
  40#else /* CONFIG_KPROBES */
  41#include <asm-generic/kprobes.h>
  42typedef int kprobe_opcode_t;
  43struct arch_specific_insn {
  44        int dummy;
  45};
  46#endif /* CONFIG_KPROBES */
  47
  48struct kprobe;
  49struct pt_regs;
  50struct kretprobe;
  51struct kretprobe_instance;
  52typedef int (*kprobe_pre_handler_t) (struct kprobe *, struct pt_regs *);
  53typedef void (*kprobe_post_handler_t) (struct kprobe *, struct pt_regs *,
  54                                       unsigned long flags);
  55typedef int (*kprobe_fault_handler_t) (struct kprobe *, struct pt_regs *,
  56                                       int trapnr);
  57typedef int (*kretprobe_handler_t) (struct kretprobe_instance *,
  58                                    struct pt_regs *);
  59
  60struct kprobe {
  61        struct hlist_node hlist;
  62
  63        /* list of kprobes for multi-handler support */
  64        struct list_head list;
  65
  66        /*count the number of times this probe was temporarily disarmed */
  67        unsigned long nmissed;
  68
  69        /* location of the probe point */
  70        kprobe_opcode_t *addr;
  71
  72        /* Allow user to indicate symbol name of the probe point */
  73        const char *symbol_name;
  74
  75        /* Offset into the symbol */
  76        unsigned int offset;
  77
  78        /* Called before addr is executed. */
  79        kprobe_pre_handler_t pre_handler;
  80
  81        /* Called after addr is executed, unless... */
  82        kprobe_post_handler_t post_handler;
  83
  84        /*
  85         * ... called if executing addr causes a fault (eg. page fault).
  86         * Return 1 if it handled fault, otherwise kernel will see it.
  87         */
  88        kprobe_fault_handler_t fault_handler;
  89
  90        /* Saved opcode (which has been replaced with breakpoint) */
  91        kprobe_opcode_t opcode;
  92
  93        /* copy of the original instruction */
  94        struct arch_specific_insn ainsn;
  95
  96        /*
  97         * Indicates various status flags.
  98         * Protected by kprobe_mutex after this kprobe is registered.
  99         */
 100        u32 flags;
 101};
 102
 103/* Kprobe status flags */
 104#define KPROBE_FLAG_GONE        1 /* breakpoint has already gone */
 105#define KPROBE_FLAG_DISABLED    2 /* probe is temporarily disabled */
 106#define KPROBE_FLAG_OPTIMIZED   4 /*
 107                                   * probe is really optimized.
 108                                   * NOTE:
 109                                   * this flag is only for optimized_kprobe.
 110                                   */
 111#define KPROBE_FLAG_FTRACE      8 /* probe is using ftrace */
 112
 113/* Has this kprobe gone ? */
 114static inline int kprobe_gone(struct kprobe *p)
 115{
 116        return p->flags & KPROBE_FLAG_GONE;
 117}
 118
 119/* Is this kprobe disabled ? */
 120static inline int kprobe_disabled(struct kprobe *p)
 121{
 122        return p->flags & (KPROBE_FLAG_DISABLED | KPROBE_FLAG_GONE);
 123}
 124
 125/* Is this kprobe really running optimized path ? */
 126static inline int kprobe_optimized(struct kprobe *p)
 127{
 128        return p->flags & KPROBE_FLAG_OPTIMIZED;
 129}
 130
 131/* Is this kprobe uses ftrace ? */
 132static inline int kprobe_ftrace(struct kprobe *p)
 133{
 134        return p->flags & KPROBE_FLAG_FTRACE;
 135}
 136
 137/*
 138 * Function-return probe -
 139 * Note:
 140 * User needs to provide a handler function, and initialize maxactive.
 141 * maxactive - The maximum number of instances of the probed function that
 142 * can be active concurrently.
 143 * nmissed - tracks the number of times the probed function's return was
 144 * ignored, due to maxactive being too low.
 145 *
 146 */
 147struct kretprobe {
 148        struct kprobe kp;
 149        kretprobe_handler_t handler;
 150        kretprobe_handler_t entry_handler;
 151        int maxactive;
 152        int nmissed;
 153        size_t data_size;
 154        struct hlist_head free_instances;
 155        raw_spinlock_t lock;
 156};
 157
 158struct kretprobe_instance {
 159        struct hlist_node hlist;
 160        struct kretprobe *rp;
 161        kprobe_opcode_t *ret_addr;
 162        struct task_struct *task;
 163        void *fp;
 164        char data[0];
 165};
 166
 167struct kretprobe_blackpoint {
 168        const char *name;
 169        void *addr;
 170};
 171
 172struct kprobe_blacklist_entry {
 173        struct list_head list;
 174        unsigned long start_addr;
 175        unsigned long end_addr;
 176};
 177
 178#ifdef CONFIG_KPROBES
 179DECLARE_PER_CPU(struct kprobe *, current_kprobe);
 180DECLARE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
 181
 182/*
 183 * For #ifdef avoidance:
 184 */
 185static inline int kprobes_built_in(void)
 186{
 187        return 1;
 188}
 189
 190#ifdef CONFIG_KRETPROBES
 191extern void arch_prepare_kretprobe(struct kretprobe_instance *ri,
 192                                   struct pt_regs *regs);
 193extern int arch_trampoline_kprobe(struct kprobe *p);
 194#else /* CONFIG_KRETPROBES */
 195static inline void arch_prepare_kretprobe(struct kretprobe *rp,
 196                                        struct pt_regs *regs)
 197{
 198}
 199static inline int arch_trampoline_kprobe(struct kprobe *p)
 200{
 201        return 0;
 202}
 203#endif /* CONFIG_KRETPROBES */
 204
 205extern struct kretprobe_blackpoint kretprobe_blacklist[];
 206
 207static inline void kretprobe_assert(struct kretprobe_instance *ri,
 208        unsigned long orig_ret_address, unsigned long trampoline_address)
 209{
 210        if (!orig_ret_address || (orig_ret_address == trampoline_address)) {
 211                printk("kretprobe BUG!: Processing kretprobe %p @ %p\n",
 212                                ri->rp, ri->rp->kp.addr);
 213                BUG();
 214        }
 215}
 216
 217#ifdef CONFIG_KPROBES_SANITY_TEST
 218extern int init_test_probes(void);
 219#else
 220static inline int init_test_probes(void)
 221{
 222        return 0;
 223}
 224#endif /* CONFIG_KPROBES_SANITY_TEST */
 225
 226extern int arch_prepare_kprobe(struct kprobe *p);
 227extern void arch_arm_kprobe(struct kprobe *p);
 228extern void arch_disarm_kprobe(struct kprobe *p);
 229extern int arch_init_kprobes(void);
 230extern void show_registers(struct pt_regs *regs);
 231extern void kprobes_inc_nmissed_count(struct kprobe *p);
 232extern bool arch_within_kprobe_blacklist(unsigned long addr);
 233extern int arch_populate_kprobe_blacklist(void);
 234extern bool arch_kprobe_on_func_entry(unsigned long offset);
 235extern bool kprobe_on_func_entry(kprobe_opcode_t *addr, const char *sym, unsigned long offset);
 236
 237extern bool within_kprobe_blacklist(unsigned long addr);
 238extern int kprobe_add_ksym_blacklist(unsigned long entry);
 239extern int kprobe_add_area_blacklist(unsigned long start, unsigned long end);
 240
 241struct kprobe_insn_cache {
 242        struct mutex mutex;
 243        void *(*alloc)(void);   /* allocate insn page */
 244        void (*free)(void *);   /* free insn page */
 245        struct list_head pages; /* list of kprobe_insn_page */
 246        size_t insn_size;       /* size of instruction slot */
 247        int nr_garbage;
 248};
 249
 250#ifdef __ARCH_WANT_KPROBES_INSN_SLOT
 251extern kprobe_opcode_t *__get_insn_slot(struct kprobe_insn_cache *c);
 252extern void __free_insn_slot(struct kprobe_insn_cache *c,
 253                             kprobe_opcode_t *slot, int dirty);
 254/* sleep-less address checking routine  */
 255extern bool __is_insn_slot_addr(struct kprobe_insn_cache *c,
 256                                unsigned long addr);
 257
 258#define DEFINE_INSN_CACHE_OPS(__name)                                   \
 259extern struct kprobe_insn_cache kprobe_##__name##_slots;                \
 260                                                                        \
 261static inline kprobe_opcode_t *get_##__name##_slot(void)                \
 262{                                                                       \
 263        return __get_insn_slot(&kprobe_##__name##_slots);               \
 264}                                                                       \
 265                                                                        \
 266static inline void free_##__name##_slot(kprobe_opcode_t *slot, int dirty)\
 267{                                                                       \
 268        __free_insn_slot(&kprobe_##__name##_slots, slot, dirty);        \
 269}                                                                       \
 270                                                                        \
 271static inline bool is_kprobe_##__name##_slot(unsigned long addr)        \
 272{                                                                       \
 273        return __is_insn_slot_addr(&kprobe_##__name##_slots, addr);     \
 274}
 275#else /* __ARCH_WANT_KPROBES_INSN_SLOT */
 276#define DEFINE_INSN_CACHE_OPS(__name)                                   \
 277static inline bool is_kprobe_##__name##_slot(unsigned long addr)        \
 278{                                                                       \
 279        return 0;                                                       \
 280}
 281#endif
 282
 283DEFINE_INSN_CACHE_OPS(insn);
 284
 285#ifdef CONFIG_OPTPROBES
 286/*
 287 * Internal structure for direct jump optimized probe
 288 */
 289struct optimized_kprobe {
 290        struct kprobe kp;
 291        struct list_head list;  /* list for optimizing queue */
 292        struct arch_optimized_insn optinsn;
 293};
 294
 295/* Architecture dependent functions for direct jump optimization */
 296extern int arch_prepared_optinsn(struct arch_optimized_insn *optinsn);
 297extern int arch_check_optimized_kprobe(struct optimized_kprobe *op);
 298extern int arch_prepare_optimized_kprobe(struct optimized_kprobe *op,
 299                                         struct kprobe *orig);
 300extern void arch_remove_optimized_kprobe(struct optimized_kprobe *op);
 301extern void arch_optimize_kprobes(struct list_head *oplist);
 302extern void arch_unoptimize_kprobes(struct list_head *oplist,
 303                                    struct list_head *done_list);
 304extern void arch_unoptimize_kprobe(struct optimized_kprobe *op);
 305extern int arch_within_optimized_kprobe(struct optimized_kprobe *op,
 306                                        unsigned long addr);
 307
 308extern void opt_pre_handler(struct kprobe *p, struct pt_regs *regs);
 309
 310DEFINE_INSN_CACHE_OPS(optinsn);
 311
 312#ifdef CONFIG_SYSCTL
 313extern int sysctl_kprobes_optimization;
 314extern int proc_kprobes_optimization_handler(struct ctl_table *table,
 315                                             int write, void __user *buffer,
 316                                             size_t *length, loff_t *ppos);
 317#endif
 318extern void wait_for_kprobe_optimizer(void);
 319#else
 320static inline void wait_for_kprobe_optimizer(void) { }
 321#endif /* CONFIG_OPTPROBES */
 322#ifdef CONFIG_KPROBES_ON_FTRACE
 323extern void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
 324                                  struct ftrace_ops *ops, struct pt_regs *regs);
 325extern int arch_prepare_kprobe_ftrace(struct kprobe *p);
 326#endif
 327
 328int arch_check_ftrace_location(struct kprobe *p);
 329
 330/* Get the kprobe at this addr (if any) - called with preemption disabled */
 331struct kprobe *get_kprobe(void *addr);
 332void kretprobe_hash_lock(struct task_struct *tsk,
 333                         struct hlist_head **head, unsigned long *flags);
 334void kretprobe_hash_unlock(struct task_struct *tsk, unsigned long *flags);
 335struct hlist_head * kretprobe_inst_table_head(struct task_struct *tsk);
 336
 337/* kprobe_running() will just return the current_kprobe on this CPU */
 338static inline struct kprobe *kprobe_running(void)
 339{
 340        return (__this_cpu_read(current_kprobe));
 341}
 342
 343static inline void reset_current_kprobe(void)
 344{
 345        __this_cpu_write(current_kprobe, NULL);
 346}
 347
 348static inline struct kprobe_ctlblk *get_kprobe_ctlblk(void)
 349{
 350        return this_cpu_ptr(&kprobe_ctlblk);
 351}
 352
 353kprobe_opcode_t *kprobe_lookup_name(const char *name, unsigned int offset);
 354int register_kprobe(struct kprobe *p);
 355void unregister_kprobe(struct kprobe *p);
 356int register_kprobes(struct kprobe **kps, int num);
 357void unregister_kprobes(struct kprobe **kps, int num);
 358unsigned long arch_deref_entry_point(void *);
 359
 360int register_kretprobe(struct kretprobe *rp);
 361void unregister_kretprobe(struct kretprobe *rp);
 362int register_kretprobes(struct kretprobe **rps, int num);
 363void unregister_kretprobes(struct kretprobe **rps, int num);
 364
 365void kprobe_flush_task(struct task_struct *tk);
 366void recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head);
 367
 368int disable_kprobe(struct kprobe *kp);
 369int enable_kprobe(struct kprobe *kp);
 370
 371void dump_kprobe(struct kprobe *kp);
 372
 373void *alloc_insn_page(void);
 374void free_insn_page(void *page);
 375
 376#else /* !CONFIG_KPROBES: */
 377
 378static inline int kprobes_built_in(void)
 379{
 380        return 0;
 381}
 382static inline int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
 383{
 384        return 0;
 385}
 386static inline struct kprobe *get_kprobe(void *addr)
 387{
 388        return NULL;
 389}
 390static inline struct kprobe *kprobe_running(void)
 391{
 392        return NULL;
 393}
 394static inline int register_kprobe(struct kprobe *p)
 395{
 396        return -ENOSYS;
 397}
 398static inline int register_kprobes(struct kprobe **kps, int num)
 399{
 400        return -ENOSYS;
 401}
 402static inline void unregister_kprobe(struct kprobe *p)
 403{
 404}
 405static inline void unregister_kprobes(struct kprobe **kps, int num)
 406{
 407}
 408static inline int register_kretprobe(struct kretprobe *rp)
 409{
 410        return -ENOSYS;
 411}
 412static inline int register_kretprobes(struct kretprobe **rps, int num)
 413{
 414        return -ENOSYS;
 415}
 416static inline void unregister_kretprobe(struct kretprobe *rp)
 417{
 418}
 419static inline void unregister_kretprobes(struct kretprobe **rps, int num)
 420{
 421}
 422static inline void kprobe_flush_task(struct task_struct *tk)
 423{
 424}
 425static inline int disable_kprobe(struct kprobe *kp)
 426{
 427        return -ENOSYS;
 428}
 429static inline int enable_kprobe(struct kprobe *kp)
 430{
 431        return -ENOSYS;
 432}
 433
 434static inline bool within_kprobe_blacklist(unsigned long addr)
 435{
 436        return true;
 437}
 438#endif /* CONFIG_KPROBES */
 439static inline int disable_kretprobe(struct kretprobe *rp)
 440{
 441        return disable_kprobe(&rp->kp);
 442}
 443static inline int enable_kretprobe(struct kretprobe *rp)
 444{
 445        return enable_kprobe(&rp->kp);
 446}
 447
 448#ifndef CONFIG_KPROBES
 449static inline bool is_kprobe_insn_slot(unsigned long addr)
 450{
 451        return false;
 452}
 453#endif
 454#ifndef CONFIG_OPTPROBES
 455static inline bool is_kprobe_optinsn_slot(unsigned long addr)
 456{
 457        return false;
 458}
 459#endif
 460
 461#endif /* _LINUX_KPROBES_H */
 462