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