Blame view
kernel/kprobes.c
25.8 KB
1da177e4c
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
/* * Kernel Probes (KProbes) * kernel/kprobes.c * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * Copyright (C) IBM Corporation, 2002, 2004 * * 2002-Oct Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel * Probes initial implementation (includes suggestions from * Rusty Russell). * 2004-Aug Updated by Prasanna S Panchamukhi <prasanna@in.ibm.com> with * hlists and exceptions notifier as suggested by Andi Kleen. * 2004-July Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes * interface to access function arguments. * 2004-Sep Prasanna S Panchamukhi <prasanna@in.ibm.com> Changed Kprobes * exceptions notifier to be first on the priority list. |
b94cce926
|
30 31 32 |
* 2005-May Hien Nguyen <hien@us.ibm.com>, Jim Keniston * <jkenisto@us.ibm.com> and Prasanna S Panchamukhi * <prasanna@in.ibm.com> added function-return probes. |
1da177e4c
|
33 34 |
*/ #include <linux/kprobes.h> |
1da177e4c
|
35 36 |
#include <linux/hash.h> #include <linux/init.h> |
4e57b6817
|
37 |
#include <linux/slab.h> |
e38697929
|
38 |
#include <linux/stddef.h> |
1da177e4c
|
39 |
#include <linux/module.h> |
9ec4b1f35
|
40 |
#include <linux/moduleloader.h> |
3a872d89b
|
41 |
#include <linux/kallsyms.h> |
b4c6c34a5
|
42 |
#include <linux/freezer.h> |
346fd59ba
|
43 44 |
#include <linux/seq_file.h> #include <linux/debugfs.h> |
1eeb66a1b
|
45 |
#include <linux/kdebug.h> |
bf8f6e5b3
|
46 |
|
d0aaff979
|
47 |
#include <asm-generic/sections.h> |
1da177e4c
|
48 49 |
#include <asm/cacheflush.h> #include <asm/errno.h> |
bf8f6e5b3
|
50 |
#include <asm/uaccess.h> |
1da177e4c
|
51 52 53 |
#define KPROBE_HASH_BITS 6 #define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS) |
3a872d89b
|
54 55 56 57 58 59 60 61 62 |
/* * Some oddball architectures like 64bit powerpc have function descriptors * so this must be overridable. */ #ifndef kprobe_lookup_name #define kprobe_lookup_name(name, addr) \ addr = ((kprobe_opcode_t *)(kallsyms_lookup_name(name))) #endif |
1da177e4c
|
63 |
static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE]; |
b94cce926
|
64 |
static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE]; |
1da177e4c
|
65 |
|
bf8f6e5b3
|
66 67 |
/* NOTE: change this value only with kprobe_mutex held */ static bool kprobe_enabled; |
7a7d1cf95
|
68 |
DEFINE_MUTEX(kprobe_mutex); /* Protects kprobe_table */ |
3516a4604
|
69 |
DEFINE_SPINLOCK(kretprobe_lock); /* Protects kretprobe_inst_table */ |
e65845235
|
70 |
static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL; |
1da177e4c
|
71 |
|
2d14e39da
|
72 |
#ifdef __ARCH_WANT_KPROBES_INSN_SLOT |
9ec4b1f35
|
73 74 75 76 77 78 79 80 81 82 83 84 85 |
/* * kprobe->ainsn.insn points to the copy of the instruction to be * single-stepped. x86_64, POWER4 and above have no-exec support and * stepping on the instruction on a vmalloced/kmalloced/data page * is a recipe for disaster */ #define INSNS_PER_PAGE (PAGE_SIZE/(MAX_INSN_SIZE * sizeof(kprobe_opcode_t))) struct kprobe_insn_page { struct hlist_node hlist; kprobe_opcode_t *insns; /* Page of instruction slots */ char slot_used[INSNS_PER_PAGE]; int nused; |
b4c6c34a5
|
86 |
int ngarbage; |
9ec4b1f35
|
87 |
}; |
ab40c5c6b
|
88 89 90 91 92 |
enum kprobe_slot_state { SLOT_CLEAN = 0, SLOT_DIRTY = 1, SLOT_USED = 2, }; |
9ec4b1f35
|
93 |
static struct hlist_head kprobe_insn_pages; |
b4c6c34a5
|
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 |
static int kprobe_garbage_slots; static int collect_garbage_slots(void); static int __kprobes check_safety(void) { int ret = 0; #if defined(CONFIG_PREEMPT) && defined(CONFIG_PM) ret = freeze_processes(); if (ret == 0) { struct task_struct *p, *q; do_each_thread(p, q) { if (p != current && p->state == TASK_RUNNING && p->pid != 0) { printk("Check failed: %s is running ",p->comm); ret = -1; goto loop_end; } } while_each_thread(p, q); } loop_end: thaw_processes(); #else synchronize_sched(); #endif return ret; } |
9ec4b1f35
|
121 122 123 124 125 |
/** * get_insn_slot() - Find a slot on an executable page for an instruction. * We allocate an executable page if there's no room on existing ones. */ |
d0aaff979
|
126 |
kprobe_opcode_t __kprobes *get_insn_slot(void) |
9ec4b1f35
|
127 128 129 |
{ struct kprobe_insn_page *kip; struct hlist_node *pos; |
6f716acd5
|
130 |
retry: |
b0bb50165
|
131 |
hlist_for_each_entry(kip, pos, &kprobe_insn_pages, hlist) { |
9ec4b1f35
|
132 133 134 |
if (kip->nused < INSNS_PER_PAGE) { int i; for (i = 0; i < INSNS_PER_PAGE; i++) { |
ab40c5c6b
|
135 136 |
if (kip->slot_used[i] == SLOT_CLEAN) { kip->slot_used[i] = SLOT_USED; |
9ec4b1f35
|
137 138 139 140 141 142 143 144 |
kip->nused++; return kip->insns + (i * MAX_INSN_SIZE); } } /* Surprise! No unused slots. Fix kip->nused. */ kip->nused = INSNS_PER_PAGE; } } |
b4c6c34a5
|
145 146 147 148 149 |
/* If there are any garbage slots, collect it and try again. */ if (kprobe_garbage_slots && collect_garbage_slots() == 0) { goto retry; } /* All out of space. Need to allocate a new page. Use slot 0. */ |
9ec4b1f35
|
150 |
kip = kmalloc(sizeof(struct kprobe_insn_page), GFP_KERNEL); |
6f716acd5
|
151 |
if (!kip) |
9ec4b1f35
|
152 |
return NULL; |
9ec4b1f35
|
153 154 155 156 157 158 159 160 161 162 163 164 165 |
/* * Use module_alloc so this page is within +/- 2GB of where the * kernel image and loaded module images reside. This is required * so x86_64 can correctly handle the %rip-relative fixups. */ kip->insns = module_alloc(PAGE_SIZE); if (!kip->insns) { kfree(kip); return NULL; } INIT_HLIST_NODE(&kip->hlist); hlist_add_head(&kip->hlist, &kprobe_insn_pages); |
ab40c5c6b
|
166 167 |
memset(kip->slot_used, SLOT_CLEAN, INSNS_PER_PAGE); kip->slot_used[0] = SLOT_USED; |
9ec4b1f35
|
168 |
kip->nused = 1; |
b4c6c34a5
|
169 |
kip->ngarbage = 0; |
9ec4b1f35
|
170 171 |
return kip->insns; } |
b4c6c34a5
|
172 173 174 |
/* Return 1 if all garbages are collected, otherwise 0. */ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx) { |
ab40c5c6b
|
175 |
kip->slot_used[idx] = SLOT_CLEAN; |
b4c6c34a5
|
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 |
kip->nused--; if (kip->nused == 0) { /* * Page is no longer in use. Free it unless * it's the last one. We keep the last one * so as not to have to set it up again the * next time somebody inserts a probe. */ hlist_del(&kip->hlist); if (hlist_empty(&kprobe_insn_pages)) { INIT_HLIST_NODE(&kip->hlist); hlist_add_head(&kip->hlist, &kprobe_insn_pages); } else { module_free(NULL, kip->insns); kfree(kip); } return 1; } return 0; } static int __kprobes collect_garbage_slots(void) { struct kprobe_insn_page *kip; struct hlist_node *pos, *next; /* Ensure no-one is preepmted on the garbages */ if (check_safety() != 0) return -EAGAIN; |
b0bb50165
|
206 |
hlist_for_each_entry_safe(kip, pos, next, &kprobe_insn_pages, hlist) { |
b4c6c34a5
|
207 |
int i; |
b4c6c34a5
|
208 209 210 211 |
if (kip->ngarbage == 0) continue; kip->ngarbage = 0; /* we will collect all garbages */ for (i = 0; i < INSNS_PER_PAGE; i++) { |
ab40c5c6b
|
212 |
if (kip->slot_used[i] == SLOT_DIRTY && |
b4c6c34a5
|
213 214 215 216 217 218 219 220 221 |
collect_one_slot(kip, i)) break; } } kprobe_garbage_slots = 0; return 0; } void __kprobes free_insn_slot(kprobe_opcode_t * slot, int dirty) |
9ec4b1f35
|
222 223 224 |
{ struct kprobe_insn_page *kip; struct hlist_node *pos; |
b0bb50165
|
225 |
hlist_for_each_entry(kip, pos, &kprobe_insn_pages, hlist) { |
9ec4b1f35
|
226 227 228 |
if (kip->insns <= slot && slot < kip->insns + (INSNS_PER_PAGE * MAX_INSN_SIZE)) { int i = (slot - kip->insns) / MAX_INSN_SIZE; |
b4c6c34a5
|
229 |
if (dirty) { |
ab40c5c6b
|
230 |
kip->slot_used[i] = SLOT_DIRTY; |
b4c6c34a5
|
231 232 233 |
kip->ngarbage++; } else { collect_one_slot(kip, i); |
9ec4b1f35
|
234 |
} |
b4c6c34a5
|
235 |
break; |
9ec4b1f35
|
236 237 |
} } |
6f716acd5
|
238 239 |
if (dirty && ++kprobe_garbage_slots > INSNS_PER_PAGE) |
b4c6c34a5
|
240 |
collect_garbage_slots(); |
9ec4b1f35
|
241 |
} |
2d14e39da
|
242 |
#endif |
9ec4b1f35
|
243 |
|
e65845235
|
244 245 246 247 248 249 250 251 252 253 |
/* We have preemption disabled.. so it is safe to use __ versions */ static inline void set_kprobe_instance(struct kprobe *kp) { __get_cpu_var(kprobe_instance) = kp; } static inline void reset_kprobe_instance(void) { __get_cpu_var(kprobe_instance) = NULL; } |
3516a4604
|
254 255 |
/* * This routine is called either: |
49a2a1b83
|
256 |
* - under the kprobe_mutex - during kprobe_[un]register() |
3516a4604
|
257 |
* OR |
d217d5450
|
258 |
* - with preemption disabled - from arch/xxx/kernel/kprobes.c |
3516a4604
|
259 |
*/ |
d0aaff979
|
260 |
struct kprobe __kprobes *get_kprobe(void *addr) |
1da177e4c
|
261 262 263 |
{ struct hlist_head *head; struct hlist_node *node; |
3516a4604
|
264 |
struct kprobe *p; |
1da177e4c
|
265 266 |
head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)]; |
3516a4604
|
267 |
hlist_for_each_entry_rcu(p, node, head, hlist) { |
1da177e4c
|
268 269 270 271 272 |
if (p->addr == addr) return p; } return NULL; } |
64f562c6d
|
273 274 275 276 |
/* * Aggregate handlers for multiple kprobes support - these handlers * take care of invoking the individual kprobe handlers on p->list */ |
d0aaff979
|
277 |
static int __kprobes aggr_pre_handler(struct kprobe *p, struct pt_regs *regs) |
64f562c6d
|
278 279 |
{ struct kprobe *kp; |
3516a4604
|
280 |
list_for_each_entry_rcu(kp, &p->list, list) { |
64f562c6d
|
281 |
if (kp->pre_handler) { |
e65845235
|
282 |
set_kprobe_instance(kp); |
8b0914ea7
|
283 284 |
if (kp->pre_handler(kp, regs)) return 1; |
64f562c6d
|
285 |
} |
e65845235
|
286 |
reset_kprobe_instance(); |
64f562c6d
|
287 288 289 |
} return 0; } |
d0aaff979
|
290 291 |
static void __kprobes aggr_post_handler(struct kprobe *p, struct pt_regs *regs, unsigned long flags) |
64f562c6d
|
292 293 |
{ struct kprobe *kp; |
3516a4604
|
294 |
list_for_each_entry_rcu(kp, &p->list, list) { |
64f562c6d
|
295 |
if (kp->post_handler) { |
e65845235
|
296 |
set_kprobe_instance(kp); |
64f562c6d
|
297 |
kp->post_handler(kp, regs, flags); |
e65845235
|
298 |
reset_kprobe_instance(); |
64f562c6d
|
299 300 |
} } |
64f562c6d
|
301 |
} |
d0aaff979
|
302 303 |
static int __kprobes aggr_fault_handler(struct kprobe *p, struct pt_regs *regs, int trapnr) |
64f562c6d
|
304 |
{ |
e65845235
|
305 |
struct kprobe *cur = __get_cpu_var(kprobe_instance); |
64f562c6d
|
306 307 308 309 |
/* * if we faulted "during" the execution of a user specified * probe handler, invoke just that probe's fault handler */ |
e65845235
|
310 311 |
if (cur && cur->fault_handler) { if (cur->fault_handler(cur, regs, trapnr)) |
64f562c6d
|
312 313 314 315 |
return 1; } return 0; } |
d0aaff979
|
316 |
static int __kprobes aggr_break_handler(struct kprobe *p, struct pt_regs *regs) |
8b0914ea7
|
317 |
{ |
e65845235
|
318 319 320 321 322 323 |
struct kprobe *cur = __get_cpu_var(kprobe_instance); int ret = 0; if (cur && cur->break_handler) { if (cur->break_handler(cur, regs)) ret = 1; |
8b0914ea7
|
324 |
} |
e65845235
|
325 326 |
reset_kprobe_instance(); return ret; |
8b0914ea7
|
327 |
} |
bf8d5c52c
|
328 329 330 331 332 333 334 335 336 337 338 339 |
/* Walks the list and increments nmissed count for multiprobe case */ void __kprobes kprobes_inc_nmissed_count(struct kprobe *p) { struct kprobe *kp; if (p->pre_handler != aggr_pre_handler) { p->nmissed++; } else { list_for_each_entry_rcu(kp, &p->list, list) kp->nmissed++; } return; } |
3516a4604
|
340 |
/* Called with kretprobe_lock held */ |
99219a3fb
|
341 342 |
void __kprobes recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head) |
b94cce926
|
343 344 345 346 347 348 349 350 351 352 353 |
{ /* remove rp inst off the rprobe_inst_table */ hlist_del(&ri->hlist); if (ri->rp) { /* remove rp inst off the used list */ hlist_del(&ri->uflist); /* put rp inst back onto the free list */ INIT_HLIST_NODE(&ri->uflist); hlist_add_head(&ri->uflist, &ri->rp->free_instances); } else /* Unregistering */ |
99219a3fb
|
354 |
hlist_add_head(&ri->hlist, head); |
b94cce926
|
355 |
} |
d0aaff979
|
356 |
struct hlist_head __kprobes *kretprobe_inst_table_head(struct task_struct *tsk) |
b94cce926
|
357 358 359 |
{ return &kretprobe_inst_table[hash_ptr(tsk, KPROBE_HASH_BITS)]; } |
b94cce926
|
360 |
/* |
c6fd91f0b
|
361 362 363 364 |
* This function is called from finish_task_switch when task tk becomes dead, * so that we can recycle any function-return probe instances associated * with this task. These left over instances represent probed functions * that have been called but will never return. |
b94cce926
|
365 |
*/ |
d0aaff979
|
366 |
void __kprobes kprobe_flush_task(struct task_struct *tk) |
b94cce926
|
367 |
{ |
62c27be0d
|
368 |
struct kretprobe_instance *ri; |
99219a3fb
|
369 |
struct hlist_head *head, empty_rp; |
802eae7c8
|
370 |
struct hlist_node *node, *tmp; |
0aa55e4d7
|
371 |
unsigned long flags = 0; |
802eae7c8
|
372 |
|
99219a3fb
|
373 |
INIT_HLIST_HEAD(&empty_rp); |
3516a4604
|
374 |
spin_lock_irqsave(&kretprobe_lock, flags); |
62c27be0d
|
375 376 377 |
head = kretprobe_inst_table_head(tk); hlist_for_each_entry_safe(ri, node, tmp, head, hlist) { if (ri->task == tk) |
99219a3fb
|
378 |
recycle_rp_inst(ri, &empty_rp); |
62c27be0d
|
379 |
} |
3516a4604
|
380 |
spin_unlock_irqrestore(&kretprobe_lock, flags); |
99219a3fb
|
381 382 383 384 385 |
hlist_for_each_entry_safe(ri, node, tmp, &empty_rp, hlist) { hlist_del(&ri->hlist); kfree(ri); } |
b94cce926
|
386 |
} |
b94cce926
|
387 388 389 |
static inline void free_rp_inst(struct kretprobe *rp) { struct kretprobe_instance *ri; |
4c4308cb9
|
390 391 392 |
struct hlist_node *pos, *next; hlist_for_each_entry_safe(ri, pos, next, &rp->free_instances, uflist) { |
b94cce926
|
393 394 395 396 |
hlist_del(&ri->uflist); kfree(ri); } } |
64f562c6d
|
397 |
/* |
8b0914ea7
|
398 399 400 401 402 403 404 405 406 407 408 409 |
* Keep all fields in the kprobe consistent */ static inline void copy_kprobe(struct kprobe *old_p, struct kprobe *p) { memcpy(&p->opcode, &old_p->opcode, sizeof(kprobe_opcode_t)); memcpy(&p->ainsn, &old_p->ainsn, sizeof(struct arch_specific_insn)); } /* * Add the new probe to old_p->list. Fail if this is the * second jprobe at the address - two jprobes can't coexist */ |
d0aaff979
|
410 |
static int __kprobes add_new_kprobe(struct kprobe *old_p, struct kprobe *p) |
8b0914ea7
|
411 |
{ |
8b0914ea7
|
412 |
if (p->break_handler) { |
367216567
|
413 414 |
if (old_p->break_handler) return -EEXIST; |
3516a4604
|
415 |
list_add_tail_rcu(&p->list, &old_p->list); |
367216567
|
416 |
old_p->break_handler = aggr_break_handler; |
8b0914ea7
|
417 |
} else |
3516a4604
|
418 |
list_add_rcu(&p->list, &old_p->list); |
367216567
|
419 420 |
if (p->post_handler && !old_p->post_handler) old_p->post_handler = aggr_post_handler; |
8b0914ea7
|
421 422 423 424 |
return 0; } /* |
64f562c6d
|
425 426 427 428 429 |
* Fill in the required fields of the "manager kprobe". Replace the * earlier kprobe in the hlist with the manager kprobe */ static inline void add_aggr_kprobe(struct kprobe *ap, struct kprobe *p) { |
8b0914ea7
|
430 |
copy_kprobe(p, ap); |
a9ad965ea
|
431 |
flush_insn_slot(ap); |
64f562c6d
|
432 |
ap->addr = p->addr; |
64f562c6d
|
433 |
ap->pre_handler = aggr_pre_handler; |
64f562c6d
|
434 |
ap->fault_handler = aggr_fault_handler; |
367216567
|
435 436 437 438 |
if (p->post_handler) ap->post_handler = aggr_post_handler; if (p->break_handler) ap->break_handler = aggr_break_handler; |
64f562c6d
|
439 440 |
INIT_LIST_HEAD(&ap->list); |
3516a4604
|
441 |
list_add_rcu(&p->list, &ap->list); |
64f562c6d
|
442 |
|
adad0f331
|
443 |
hlist_replace_rcu(&p->hlist, &ap->hlist); |
64f562c6d
|
444 445 446 447 448 |
} /* * This is the second or subsequent kprobe at the address - handle * the intricacies |
64f562c6d
|
449 |
*/ |
d0aaff979
|
450 451 |
static int __kprobes register_aggr_kprobe(struct kprobe *old_p, struct kprobe *p) |
64f562c6d
|
452 453 454 |
{ int ret = 0; struct kprobe *ap; |
8b0914ea7
|
455 456 457 |
if (old_p->pre_handler == aggr_pre_handler) { copy_kprobe(old_p, p); ret = add_new_kprobe(old_p, p); |
64f562c6d
|
458 |
} else { |
a0d50069e
|
459 |
ap = kzalloc(sizeof(struct kprobe), GFP_KERNEL); |
64f562c6d
|
460 461 462 |
if (!ap) return -ENOMEM; add_aggr_kprobe(ap, old_p); |
8b0914ea7
|
463 464 |
copy_kprobe(ap, p); ret = add_new_kprobe(ap, p); |
64f562c6d
|
465 466 467 |
} return ret; } |
d0aaff979
|
468 469 |
static int __kprobes in_kprobes_functions(unsigned long addr) { |
6f716acd5
|
470 471 |
if (addr >= (unsigned long)__kprobes_text_start && addr < (unsigned long)__kprobes_text_end) |
d0aaff979
|
472 473 474 |
return -EINVAL; return 0; } |
df019b1d8
|
475 476 |
static int __kprobes __register_kprobe(struct kprobe *p, unsigned long called_from) |
1da177e4c
|
477 478 |
{ int ret = 0; |
64f562c6d
|
479 |
struct kprobe *old_p; |
df019b1d8
|
480 |
struct module *probed_mod; |
b3e55c727
|
481 |
|
3a872d89b
|
482 483 484 485 486 487 488 489 490 491 492 493 494 495 |
/* * If we have a symbol_name argument look it up, * and add it to the address. That way the addr * field can either be global or relative to a symbol. */ if (p->symbol_name) { if (p->addr) return -EINVAL; kprobe_lookup_name(p->symbol_name, p->addr); } if (!p->addr) return -EINVAL; p->addr = (kprobe_opcode_t *)(((char *)p->addr)+ p->offset); |
6f716acd5
|
496 497 |
if (!kernel_text_address((unsigned long) p->addr) || in_kprobes_functions((unsigned long) p->addr)) |
b3e55c727
|
498 |
return -EINVAL; |
df019b1d8
|
499 |
p->mod_refcounted = 0; |
6f716acd5
|
500 501 502 503 504 505 |
/* * Check if are we probing a module. */ probed_mod = module_text_address((unsigned long) p->addr); if (probed_mod) { |
df019b1d8
|
506 |
struct module *calling_mod = module_text_address(called_from); |
6f716acd5
|
507 508 509 510 |
/* * We must allow modules to probe themself and in this case * avoid incrementing the module refcount, so as to allow * unloading of self probing modules. |
df019b1d8
|
511 |
*/ |
6f716acd5
|
512 |
if (calling_mod && calling_mod != probed_mod) { |
df019b1d8
|
513 514 515 516 517 518 |
if (unlikely(!try_module_get(probed_mod))) return -EINVAL; p->mod_refcounted = 1; } else probed_mod = NULL; } |
1da177e4c
|
519 |
|
3516a4604
|
520 |
p->nmissed = 0; |
7a7d1cf95
|
521 |
mutex_lock(&kprobe_mutex); |
64f562c6d
|
522 523 524 |
old_p = get_kprobe(p->addr); if (old_p) { ret = register_aggr_kprobe(old_p, p); |
1da177e4c
|
525 526 |
goto out; } |
1da177e4c
|
527 |
|
6f716acd5
|
528 529 |
ret = arch_prepare_kprobe(p); if (ret) |
49a2a1b83
|
530 |
goto out; |
64f562c6d
|
531 |
INIT_HLIST_NODE(&p->hlist); |
3516a4604
|
532 |
hlist_add_head_rcu(&p->hlist, |
1da177e4c
|
533 |
&kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]); |
74a0b5762
|
534 |
if (kprobe_enabled) |
bf8f6e5b3
|
535 |
arch_arm_kprobe(p); |
74a0b5762
|
536 |
|
1da177e4c
|
537 |
out: |
7a7d1cf95
|
538 |
mutex_unlock(&kprobe_mutex); |
49a2a1b83
|
539 |
|
df019b1d8
|
540 541 |
if (ret && probed_mod) module_put(probed_mod); |
1da177e4c
|
542 543 |
return ret; } |
df019b1d8
|
544 545 |
int __kprobes register_kprobe(struct kprobe *p) { |
6f716acd5
|
546 |
return __register_kprobe(p, (unsigned long)__builtin_return_address(0)); |
df019b1d8
|
547 |
} |
d0aaff979
|
548 |
void __kprobes unregister_kprobe(struct kprobe *p) |
1da177e4c
|
549 |
{ |
b3e55c727
|
550 |
struct module *mod; |
f709b1223
|
551 552 |
struct kprobe *old_p, *list_p; int cleanup_p; |
64f562c6d
|
553 |
|
7a7d1cf95
|
554 |
mutex_lock(&kprobe_mutex); |
64f562c6d
|
555 |
old_p = get_kprobe(p->addr); |
49a2a1b83
|
556 |
if (unlikely(!old_p)) { |
7a7d1cf95
|
557 |
mutex_unlock(&kprobe_mutex); |
49a2a1b83
|
558 559 |
return; } |
f709b1223
|
560 561 562 563 564 |
if (p != old_p) { list_for_each_entry_rcu(list_p, &old_p->list, list) if (list_p == p) /* kprobe p is a valid probe */ goto valid_p; |
7a7d1cf95
|
565 |
mutex_unlock(&kprobe_mutex); |
f709b1223
|
566 567 568 |
return; } valid_p: |
6f716acd5
|
569 570 571 |
if (old_p == p || (old_p->pre_handler == aggr_pre_handler && p->list.next == &old_p->list && p->list.prev == &old_p->list)) { |
bf8f6e5b3
|
572 573 574 575 576 577 578 |
/* * Only probe on the hash list. Disarm only if kprobes are * enabled - otherwise, the breakpoint would already have * been removed. We save on flushing icache. */ if (kprobe_enabled) arch_disarm_kprobe(p); |
49a2a1b83
|
579 |
hlist_del_rcu(&old_p->hlist); |
f709b1223
|
580 |
cleanup_p = 1; |
49a2a1b83
|
581 582 |
} else { list_del_rcu(&p->list); |
f709b1223
|
583 |
cleanup_p = 0; |
49a2a1b83
|
584 |
} |
3516a4604
|
585 |
|
7a7d1cf95
|
586 |
mutex_unlock(&kprobe_mutex); |
b3e55c727
|
587 |
|
49a2a1b83
|
588 |
synchronize_sched(); |
6f716acd5
|
589 590 591 592 593 |
if (p->mod_refcounted) { mod = module_text_address((unsigned long)p->addr); if (mod) module_put(mod); } |
b3e55c727
|
594 |
|
49a2a1b83
|
595 |
if (cleanup_p) { |
f709b1223
|
596 |
if (p != old_p) { |
49a2a1b83
|
597 |
list_del_rcu(&p->list); |
3516a4604
|
598 |
kfree(old_p); |
49a2a1b83
|
599 |
} |
0498b6350
|
600 |
arch_remove_kprobe(p); |
367216567
|
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 |
} else { mutex_lock(&kprobe_mutex); if (p->break_handler) old_p->break_handler = NULL; if (p->post_handler){ list_for_each_entry_rcu(list_p, &old_p->list, list){ if (list_p->post_handler){ cleanup_p = 2; break; } } if (cleanup_p == 0) old_p->post_handler = NULL; } mutex_unlock(&kprobe_mutex); |
49a2a1b83
|
616 |
} |
1da177e4c
|
617 618 619 620 |
} static struct notifier_block kprobe_exceptions_nb = { .notifier_call = kprobe_exceptions_notify, |
3d5631e06
|
621 622 |
.priority = 0x7fffffff /* we need to be notified first */ }; |
3d7e33825
|
623 624 625 626 |
unsigned long __weak arch_deref_entry_point(void *entry) { return (unsigned long)entry; } |
1da177e4c
|
627 |
|
d0aaff979
|
628 |
int __kprobes register_jprobe(struct jprobe *jp) |
1da177e4c
|
629 |
{ |
3d7e33825
|
630 631 632 633 |
unsigned long addr = arch_deref_entry_point(jp->entry); if (!kernel_text_address(addr)) return -EINVAL; |
1da177e4c
|
634 635 636 |
/* Todo: Verify probepoint is a function entry point */ jp->kp.pre_handler = setjmp_pre_handler; jp->kp.break_handler = longjmp_break_handler; |
df019b1d8
|
637 638 |
return __register_kprobe(&jp->kp, (unsigned long)__builtin_return_address(0)); |
1da177e4c
|
639 |
} |
d0aaff979
|
640 |
void __kprobes unregister_jprobe(struct jprobe *jp) |
1da177e4c
|
641 642 643 |
{ unregister_kprobe(&jp->kp); } |
b94cce926
|
644 |
#ifdef ARCH_SUPPORTS_KRETPROBES |
e65cefe87
|
645 646 647 648 649 650 651 652 653 654 655 656 |
/* * This kprobe pre_handler is registered with every kretprobe. When probe * hits it will set up the return probe. */ static int __kprobes pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs) { struct kretprobe *rp = container_of(p, struct kretprobe, kp); unsigned long flags = 0; /*TODO: consider to only swap the RA after the last pre_handler fired */ spin_lock_irqsave(&kretprobe_lock, flags); |
4c4308cb9
|
657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 |
if (!hlist_empty(&rp->free_instances)) { struct kretprobe_instance *ri; ri = hlist_entry(rp->free_instances.first, struct kretprobe_instance, uflist); ri->rp = rp; ri->task = current; arch_prepare_kretprobe(ri, regs); /* XXX(hch): why is there no hlist_move_head? */ hlist_del(&ri->uflist); hlist_add_head(&ri->uflist, &ri->rp->used_instances); hlist_add_head(&ri->hlist, kretprobe_inst_table_head(ri->task)); } else rp->nmissed++; |
e65cefe87
|
672 673 674 |
spin_unlock_irqrestore(&kretprobe_lock, flags); return 0; } |
d0aaff979
|
675 |
int __kprobes register_kretprobe(struct kretprobe *rp) |
b94cce926
|
676 677 678 679 |
{ int ret = 0; struct kretprobe_instance *inst; int i; |
f438d914b
|
680 681 682 683 684 685 686 687 688 689 690 691 |
void *addr = rp->kp.addr; if (kretprobe_blacklist_size) { if (addr == NULL) kprobe_lookup_name(rp->kp.symbol_name, addr); addr += rp->kp.offset; for (i = 0; kretprobe_blacklist[i].name != NULL; i++) { if (kretprobe_blacklist[i].addr == addr) return -EINVAL; } } |
b94cce926
|
692 693 |
rp->kp.pre_handler = pre_handler_kretprobe; |
7522a8423
|
694 695 696 |
rp->kp.post_handler = NULL; rp->kp.fault_handler = NULL; rp->kp.break_handler = NULL; |
b94cce926
|
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 |
/* Pre-allocate memory for max kretprobe instances */ if (rp->maxactive <= 0) { #ifdef CONFIG_PREEMPT rp->maxactive = max(10, 2 * NR_CPUS); #else rp->maxactive = NR_CPUS; #endif } INIT_HLIST_HEAD(&rp->used_instances); INIT_HLIST_HEAD(&rp->free_instances); for (i = 0; i < rp->maxactive; i++) { inst = kmalloc(sizeof(struct kretprobe_instance), GFP_KERNEL); if (inst == NULL) { free_rp_inst(rp); return -ENOMEM; } INIT_HLIST_NODE(&inst->uflist); hlist_add_head(&inst->uflist, &rp->free_instances); } rp->nmissed = 0; /* Establish function entry probe point */ |
df019b1d8
|
720 721 |
if ((ret = __register_kprobe(&rp->kp, (unsigned long)__builtin_return_address(0))) != 0) |
b94cce926
|
722 723 724 725 726 |
free_rp_inst(rp); return ret; } #else /* ARCH_SUPPORTS_KRETPROBES */ |
d0aaff979
|
727 |
int __kprobes register_kretprobe(struct kretprobe *rp) |
b94cce926
|
728 729 730 |
{ return -ENOSYS; } |
346fd59ba
|
731 732 733 734 735 |
static int __kprobes pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs) { return 0; } |
b94cce926
|
736 |
#endif /* ARCH_SUPPORTS_KRETPROBES */ |
d0aaff979
|
737 |
void __kprobes unregister_kretprobe(struct kretprobe *rp) |
b94cce926
|
738 739 740 |
{ unsigned long flags; struct kretprobe_instance *ri; |
4c4308cb9
|
741 |
struct hlist_node *pos, *next; |
b94cce926
|
742 743 |
unregister_kprobe(&rp->kp); |
4c4308cb9
|
744 |
|
b94cce926
|
745 |
/* No race here */ |
3516a4604
|
746 |
spin_lock_irqsave(&kretprobe_lock, flags); |
4c4308cb9
|
747 |
hlist_for_each_entry_safe(ri, pos, next, &rp->used_instances, uflist) { |
b94cce926
|
748 749 750 |
ri->rp = NULL; hlist_del(&ri->uflist); } |
3516a4604
|
751 |
spin_unlock_irqrestore(&kretprobe_lock, flags); |
278ff9537
|
752 |
free_rp_inst(rp); |
b94cce926
|
753 |
} |
1da177e4c
|
754 755 756 757 758 759 |
static int __init init_kprobes(void) { int i, err = 0; /* FIXME allocate the probe table, currently defined statically */ /* initialize all list heads */ |
b94cce926
|
760 |
for (i = 0; i < KPROBE_TABLE_SIZE; i++) { |
1da177e4c
|
761 |
INIT_HLIST_HEAD(&kprobe_table[i]); |
b94cce926
|
762 763 |
INIT_HLIST_HEAD(&kretprobe_inst_table[i]); } |
1da177e4c
|
764 |
|
f438d914b
|
765 766 767 768 769 770 771 772 773 774 775 |
if (kretprobe_blacklist_size) { /* lookup the function address from its name */ for (i = 0; kretprobe_blacklist[i].name != NULL; i++) { kprobe_lookup_name(kretprobe_blacklist[i].name, kretprobe_blacklist[i].addr); if (!kretprobe_blacklist[i].addr) printk("kretprobe: lookup failed: %s ", kretprobe_blacklist[i].name); } } |
bf8f6e5b3
|
776 777 |
/* By default, kprobes are enabled */ kprobe_enabled = true; |
6772926be
|
778 |
err = arch_init_kprobes(); |
802eae7c8
|
779 780 |
if (!err) err = register_die_notifier(&kprobe_exceptions_nb); |
1da177e4c
|
781 782 |
return err; } |
346fd59ba
|
783 784 |
#ifdef CONFIG_DEBUG_FS static void __kprobes report_probe(struct seq_file *pi, struct kprobe *p, |
bf8f6e5b3
|
785 |
const char *sym, int offset,char *modname) |
346fd59ba
|
786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 |
{ char *kprobe_type; if (p->pre_handler == pre_handler_kretprobe) kprobe_type = "r"; else if (p->pre_handler == setjmp_pre_handler) kprobe_type = "j"; else kprobe_type = "k"; if (sym) seq_printf(pi, "%p %s %s+0x%x %s ", p->addr, kprobe_type, sym, offset, (modname ? modname : " ")); else seq_printf(pi, "%p %s %p ", p->addr, kprobe_type, p->addr); } static void __kprobes *kprobe_seq_start(struct seq_file *f, loff_t *pos) { return (*pos < KPROBE_TABLE_SIZE) ? pos : NULL; } static void __kprobes *kprobe_seq_next(struct seq_file *f, void *v, loff_t *pos) { (*pos)++; if (*pos >= KPROBE_TABLE_SIZE) return NULL; return pos; } static void __kprobes kprobe_seq_stop(struct seq_file *f, void *v) { /* Nothing to do */ } static int __kprobes show_kprobe_addr(struct seq_file *pi, void *v) { struct hlist_head *head; struct hlist_node *node; struct kprobe *p, *kp; const char *sym = NULL; unsigned int i = *(loff_t *) v; |
ffb451227
|
829 |
unsigned long offset = 0; |
346fd59ba
|
830 831 832 833 834 |
char *modname, namebuf[128]; head = &kprobe_table[i]; preempt_disable(); hlist_for_each_entry_rcu(p, node, head, hlist) { |
ffb451227
|
835 |
sym = kallsyms_lookup((unsigned long)p->addr, NULL, |
346fd59ba
|
836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 |
&offset, &modname, namebuf); if (p->pre_handler == aggr_pre_handler) { list_for_each_entry_rcu(kp, &p->list, list) report_probe(pi, kp, sym, offset, modname); } else report_probe(pi, p, sym, offset, modname); } preempt_enable(); return 0; } static struct seq_operations kprobes_seq_ops = { .start = kprobe_seq_start, .next = kprobe_seq_next, .stop = kprobe_seq_stop, .show = show_kprobe_addr }; static int __kprobes kprobes_open(struct inode *inode, struct file *filp) { return seq_open(filp, &kprobes_seq_ops); } static struct file_operations debugfs_kprobes_operations = { .open = kprobes_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release, }; |
bf8f6e5b3
|
865 866 867 868 869 870 871 872 873 874 875 876 |
static void __kprobes enable_all_kprobes(void) { struct hlist_head *head; struct hlist_node *node; struct kprobe *p; unsigned int i; mutex_lock(&kprobe_mutex); /* If kprobes are already enabled, just return */ if (kprobe_enabled) goto already_enabled; |
bf8f6e5b3
|
877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 |
for (i = 0; i < KPROBE_TABLE_SIZE; i++) { head = &kprobe_table[i]; hlist_for_each_entry_rcu(p, node, head, hlist) arch_arm_kprobe(p); } kprobe_enabled = true; printk(KERN_INFO "Kprobes globally enabled "); already_enabled: mutex_unlock(&kprobe_mutex); return; } static void __kprobes disable_all_kprobes(void) { struct hlist_head *head; struct hlist_node *node; struct kprobe *p; unsigned int i; mutex_lock(&kprobe_mutex); /* If kprobes are already disabled, just return */ if (!kprobe_enabled) goto already_disabled; kprobe_enabled = false; printk(KERN_INFO "Kprobes globally disabled "); for (i = 0; i < KPROBE_TABLE_SIZE; i++) { head = &kprobe_table[i]; hlist_for_each_entry_rcu(p, node, head, hlist) { if (!arch_trampoline_kprobe(p)) arch_disarm_kprobe(p); } } mutex_unlock(&kprobe_mutex); /* Allow all currently running kprobes to complete */ synchronize_sched(); |
74a0b5762
|
919 |
return; |
bf8f6e5b3
|
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 |
already_disabled: mutex_unlock(&kprobe_mutex); return; } /* * XXX: The debugfs bool file interface doesn't allow for callbacks * when the bool state is switched. We can reuse that facility when * available */ static ssize_t read_enabled_file_bool(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { char buf[3]; if (kprobe_enabled) buf[0] = '1'; else buf[0] = '0'; buf[1] = ' '; buf[2] = 0x00; return simple_read_from_buffer(user_buf, count, ppos, buf, 2); } static ssize_t write_enabled_file_bool(struct file *file, const char __user *user_buf, size_t count, loff_t *ppos) { char buf[32]; int buf_size; buf_size = min(count, (sizeof(buf)-1)); if (copy_from_user(buf, user_buf, buf_size)) return -EFAULT; switch (buf[0]) { case 'y': case 'Y': case '1': enable_all_kprobes(); break; case 'n': case 'N': case '0': disable_all_kprobes(); break; } return count; } static struct file_operations fops_kp = { .read = read_enabled_file_bool, .write = write_enabled_file_bool, }; |
346fd59ba
|
976 977 978 |
static int __kprobes debugfs_kprobe_init(void) { struct dentry *dir, *file; |
bf8f6e5b3
|
979 |
unsigned int value = 1; |
346fd59ba
|
980 981 982 983 |
dir = debugfs_create_dir("kprobes", NULL); if (!dir) return -ENOMEM; |
e38697929
|
984 |
file = debugfs_create_file("list", 0444, dir, NULL, |
346fd59ba
|
985 986 987 988 989 |
&debugfs_kprobes_operations); if (!file) { debugfs_remove(dir); return -ENOMEM; } |
bf8f6e5b3
|
990 991 992 993 994 995 |
file = debugfs_create_file("enabled", 0600, dir, &value, &fops_kp); if (!file) { debugfs_remove(dir); return -ENOMEM; } |
346fd59ba
|
996 997 998 999 1000 1001 1002 |
return 0; } late_initcall(debugfs_kprobe_init); #endif /* CONFIG_DEBUG_FS */ module_init(init_kprobes); |
1da177e4c
|
1003 1004 1005 1006 1007 |
EXPORT_SYMBOL_GPL(register_kprobe); EXPORT_SYMBOL_GPL(unregister_kprobe); EXPORT_SYMBOL_GPL(register_jprobe); EXPORT_SYMBOL_GPL(unregister_jprobe); |
cd5bfea27
|
1008 |
#ifdef CONFIG_KPROBES |
1da177e4c
|
1009 |
EXPORT_SYMBOL_GPL(jprobe_return); |
cd5bfea27
|
1010 1011 1012 |
#endif #ifdef CONFIG_KPROBES |
b94cce926
|
1013 1014 |
EXPORT_SYMBOL_GPL(register_kretprobe); EXPORT_SYMBOL_GPL(unregister_kretprobe); |
cd5bfea27
|
1015 |
#endif |