Blame view
kernel/kprobes.c
30.9 KB
1da177e4c Linux-2.6.12-rc2 |
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 [PATCH] kprobes: ... |
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 Linux-2.6.12-rc2 |
33 34 |
*/ #include <linux/kprobes.h> |
1da177e4c Linux-2.6.12-rc2 |
35 36 |
#include <linux/hash.h> #include <linux/init.h> |
4e57b6817 [PATCH] fix missi... |
37 |
#include <linux/slab.h> |
e38697929 kprobes: fix spar... |
38 |
#include <linux/stddef.h> |
1da177e4c Linux-2.6.12-rc2 |
39 |
#include <linux/module.h> |
9ec4b1f35 [PATCH] kprobes: ... |
40 |
#include <linux/moduleloader.h> |
3a872d89b [PATCH] Kprobes: ... |
41 |
#include <linux/kallsyms.h> |
b4c6c34a5 [PATCH] kprobes: ... |
42 |
#include <linux/freezer.h> |
346fd59ba [PATCH] kprobes: ... |
43 44 |
#include <linux/seq_file.h> #include <linux/debugfs.h> |
1eeb66a1b move die notifier... |
45 |
#include <linux/kdebug.h> |
bf8f6e5b3 Kprobes: The ON/O... |
46 |
|
d0aaff979 [PATCH] Kprobes: ... |
47 |
#include <asm-generic/sections.h> |
1da177e4c Linux-2.6.12-rc2 |
48 49 |
#include <asm/cacheflush.h> #include <asm/errno.h> |
bf8f6e5b3 Kprobes: The ON/O... |
50 |
#include <asm/uaccess.h> |
1da177e4c Linux-2.6.12-rc2 |
51 52 53 |
#define KPROBE_HASH_BITS 6 #define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS) |
3a872d89b [PATCH] Kprobes: ... |
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 Linux-2.6.12-rc2 |
63 |
static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE]; |
b94cce926 [PATCH] kprobes: ... |
64 |
static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE]; |
1da177e4c Linux-2.6.12-rc2 |
65 |
|
bf8f6e5b3 Kprobes: The ON/O... |
66 67 |
/* NOTE: change this value only with kprobe_mutex held */ static bool kprobe_enabled; |
7a7d1cf95 [PATCH] sem2mutex... |
68 |
DEFINE_MUTEX(kprobe_mutex); /* Protects kprobe_table */ |
3516a4604 [PATCH] Kprobes: ... |
69 |
DEFINE_SPINLOCK(kretprobe_lock); /* Protects kretprobe_inst_table */ |
e65845235 [PATCH] Kprobes: ... |
70 |
static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL; |
1da177e4c Linux-2.6.12-rc2 |
71 |
|
3d8d996e0 kprobes: prevent ... |
72 73 74 75 76 77 78 |
/* * Normally, functions that we'd want to prohibit kprobes in, are marked * __kprobes. But, there are cases where such functions already belong to * a different section (__sched for preempt_schedule) * * For such cases, we now have a blacklist */ |
544304b20 kernel/kprobes.c:... |
79 |
static struct kprobe_blackpoint kprobe_blacklist[] = { |
3d8d996e0 kprobes: prevent ... |
80 81 82 |
{"preempt_schedule",}, {NULL} /* Terminator */ }; |
2d14e39da [PATCH] kprobes: ... |
83 |
#ifdef __ARCH_WANT_KPROBES_INSN_SLOT |
9ec4b1f35 [PATCH] kprobes: ... |
84 85 86 87 88 89 90 91 92 93 94 95 96 |
/* * 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 [PATCH] kprobes: ... |
97 |
int ngarbage; |
9ec4b1f35 [PATCH] kprobes: ... |
98 |
}; |
ab40c5c6b [PATCH] kprobes: ... |
99 100 101 102 103 |
enum kprobe_slot_state { SLOT_CLEAN = 0, SLOT_DIRTY = 1, SLOT_USED = 2, }; |
9ec4b1f35 [PATCH] kprobes: ... |
104 |
static struct hlist_head kprobe_insn_pages; |
b4c6c34a5 [PATCH] kprobes: ... |
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 |
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 [PATCH] kprobes: ... |
132 133 134 135 136 |
/** * 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 [PATCH] Kprobes: ... |
137 |
kprobe_opcode_t __kprobes *get_insn_slot(void) |
9ec4b1f35 [PATCH] kprobes: ... |
138 139 140 |
{ struct kprobe_insn_page *kip; struct hlist_node *pos; |
6f716acd5 kprobes: codingst... |
141 |
retry: |
b0bb50165 kprobes: use hlis... |
142 |
hlist_for_each_entry(kip, pos, &kprobe_insn_pages, hlist) { |
9ec4b1f35 [PATCH] kprobes: ... |
143 144 145 |
if (kip->nused < INSNS_PER_PAGE) { int i; for (i = 0; i < INSNS_PER_PAGE; i++) { |
ab40c5c6b [PATCH] kprobes: ... |
146 147 |
if (kip->slot_used[i] == SLOT_CLEAN) { kip->slot_used[i] = SLOT_USED; |
9ec4b1f35 [PATCH] kprobes: ... |
148 149 150 151 152 153 154 155 |
kip->nused++; return kip->insns + (i * MAX_INSN_SIZE); } } /* Surprise! No unused slots. Fix kip->nused. */ kip->nused = INSNS_PER_PAGE; } } |
b4c6c34a5 [PATCH] kprobes: ... |
156 157 158 159 160 |
/* 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 [PATCH] kprobes: ... |
161 |
kip = kmalloc(sizeof(struct kprobe_insn_page), GFP_KERNEL); |
6f716acd5 kprobes: codingst... |
162 |
if (!kip) |
9ec4b1f35 [PATCH] kprobes: ... |
163 |
return NULL; |
9ec4b1f35 [PATCH] kprobes: ... |
164 165 166 167 168 169 170 171 172 173 174 175 176 |
/* * 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 [PATCH] kprobes: ... |
177 178 |
memset(kip->slot_used, SLOT_CLEAN, INSNS_PER_PAGE); kip->slot_used[0] = SLOT_USED; |
9ec4b1f35 [PATCH] kprobes: ... |
179 |
kip->nused = 1; |
b4c6c34a5 [PATCH] kprobes: ... |
180 |
kip->ngarbage = 0; |
9ec4b1f35 [PATCH] kprobes: ... |
181 182 |
return kip->insns; } |
b4c6c34a5 [PATCH] kprobes: ... |
183 184 185 |
/* Return 1 if all garbages are collected, otherwise 0. */ static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx) { |
ab40c5c6b [PATCH] kprobes: ... |
186 |
kip->slot_used[idx] = SLOT_CLEAN; |
b4c6c34a5 [PATCH] kprobes: ... |
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 |
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 kprobes: use hlis... |
217 |
hlist_for_each_entry_safe(kip, pos, next, &kprobe_insn_pages, hlist) { |
b4c6c34a5 [PATCH] kprobes: ... |
218 |
int i; |
b4c6c34a5 [PATCH] kprobes: ... |
219 220 221 222 |
if (kip->ngarbage == 0) continue; kip->ngarbage = 0; /* we will collect all garbages */ for (i = 0; i < INSNS_PER_PAGE; i++) { |
ab40c5c6b [PATCH] kprobes: ... |
223 |
if (kip->slot_used[i] == SLOT_DIRTY && |
b4c6c34a5 [PATCH] kprobes: ... |
224 225 226 227 228 229 230 231 232 |
collect_one_slot(kip, i)) break; } } kprobe_garbage_slots = 0; return 0; } void __kprobes free_insn_slot(kprobe_opcode_t * slot, int dirty) |
9ec4b1f35 [PATCH] kprobes: ... |
233 234 235 |
{ struct kprobe_insn_page *kip; struct hlist_node *pos; |
b0bb50165 kprobes: use hlis... |
236 |
hlist_for_each_entry(kip, pos, &kprobe_insn_pages, hlist) { |
9ec4b1f35 [PATCH] kprobes: ... |
237 238 239 |
if (kip->insns <= slot && slot < kip->insns + (INSNS_PER_PAGE * MAX_INSN_SIZE)) { int i = (slot - kip->insns) / MAX_INSN_SIZE; |
b4c6c34a5 [PATCH] kprobes: ... |
240 |
if (dirty) { |
ab40c5c6b [PATCH] kprobes: ... |
241 |
kip->slot_used[i] = SLOT_DIRTY; |
b4c6c34a5 [PATCH] kprobes: ... |
242 243 244 |
kip->ngarbage++; } else { collect_one_slot(kip, i); |
9ec4b1f35 [PATCH] kprobes: ... |
245 |
} |
b4c6c34a5 [PATCH] kprobes: ... |
246 |
break; |
9ec4b1f35 [PATCH] kprobes: ... |
247 248 |
} } |
6f716acd5 kprobes: codingst... |
249 250 |
if (dirty && ++kprobe_garbage_slots > INSNS_PER_PAGE) |
b4c6c34a5 [PATCH] kprobes: ... |
251 |
collect_garbage_slots(); |
9ec4b1f35 [PATCH] kprobes: ... |
252 |
} |
2d14e39da [PATCH] kprobes: ... |
253 |
#endif |
9ec4b1f35 [PATCH] kprobes: ... |
254 |
|
e65845235 [PATCH] Kprobes: ... |
255 256 257 258 259 260 261 262 263 264 |
/* 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 [PATCH] Kprobes: ... |
265 266 |
/* * This routine is called either: |
49a2a1b83 [PATCH] kprobes: ... |
267 |
* - under the kprobe_mutex - during kprobe_[un]register() |
3516a4604 [PATCH] Kprobes: ... |
268 |
* OR |
d217d5450 [PATCH] Kprobes: ... |
269 |
* - with preemption disabled - from arch/xxx/kernel/kprobes.c |
3516a4604 [PATCH] Kprobes: ... |
270 |
*/ |
d0aaff979 [PATCH] Kprobes: ... |
271 |
struct kprobe __kprobes *get_kprobe(void *addr) |
1da177e4c Linux-2.6.12-rc2 |
272 273 274 |
{ struct hlist_head *head; struct hlist_node *node; |
3516a4604 [PATCH] Kprobes: ... |
275 |
struct kprobe *p; |
1da177e4c Linux-2.6.12-rc2 |
276 277 |
head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)]; |
3516a4604 [PATCH] Kprobes: ... |
278 |
hlist_for_each_entry_rcu(p, node, head, hlist) { |
1da177e4c Linux-2.6.12-rc2 |
279 280 281 282 283 |
if (p->addr == addr) return p; } return NULL; } |
64f562c6d [PATCH] kprobes: ... |
284 285 286 287 |
/* * Aggregate handlers for multiple kprobes support - these handlers * take care of invoking the individual kprobe handlers on p->list */ |
d0aaff979 [PATCH] Kprobes: ... |
288 |
static int __kprobes aggr_pre_handler(struct kprobe *p, struct pt_regs *regs) |
64f562c6d [PATCH] kprobes: ... |
289 290 |
{ struct kprobe *kp; |
3516a4604 [PATCH] Kprobes: ... |
291 |
list_for_each_entry_rcu(kp, &p->list, list) { |
64f562c6d [PATCH] kprobes: ... |
292 |
if (kp->pre_handler) { |
e65845235 [PATCH] Kprobes: ... |
293 |
set_kprobe_instance(kp); |
8b0914ea7 [PATCH] jprobes: ... |
294 295 |
if (kp->pre_handler(kp, regs)) return 1; |
64f562c6d [PATCH] kprobes: ... |
296 |
} |
e65845235 [PATCH] Kprobes: ... |
297 |
reset_kprobe_instance(); |
64f562c6d [PATCH] kprobes: ... |
298 299 300 |
} return 0; } |
d0aaff979 [PATCH] Kprobes: ... |
301 302 |
static void __kprobes aggr_post_handler(struct kprobe *p, struct pt_regs *regs, unsigned long flags) |
64f562c6d [PATCH] kprobes: ... |
303 304 |
{ struct kprobe *kp; |
3516a4604 [PATCH] Kprobes: ... |
305 |
list_for_each_entry_rcu(kp, &p->list, list) { |
64f562c6d [PATCH] kprobes: ... |
306 |
if (kp->post_handler) { |
e65845235 [PATCH] Kprobes: ... |
307 |
set_kprobe_instance(kp); |
64f562c6d [PATCH] kprobes: ... |
308 |
kp->post_handler(kp, regs, flags); |
e65845235 [PATCH] Kprobes: ... |
309 |
reset_kprobe_instance(); |
64f562c6d [PATCH] kprobes: ... |
310 311 |
} } |
64f562c6d [PATCH] kprobes: ... |
312 |
} |
d0aaff979 [PATCH] Kprobes: ... |
313 314 |
static int __kprobes aggr_fault_handler(struct kprobe *p, struct pt_regs *regs, int trapnr) |
64f562c6d [PATCH] kprobes: ... |
315 |
{ |
e65845235 [PATCH] Kprobes: ... |
316 |
struct kprobe *cur = __get_cpu_var(kprobe_instance); |
64f562c6d [PATCH] kprobes: ... |
317 318 319 320 |
/* * if we faulted "during" the execution of a user specified * probe handler, invoke just that probe's fault handler */ |
e65845235 [PATCH] Kprobes: ... |
321 322 |
if (cur && cur->fault_handler) { if (cur->fault_handler(cur, regs, trapnr)) |
64f562c6d [PATCH] kprobes: ... |
323 324 325 326 |
return 1; } return 0; } |
d0aaff979 [PATCH] Kprobes: ... |
327 |
static int __kprobes aggr_break_handler(struct kprobe *p, struct pt_regs *regs) |
8b0914ea7 [PATCH] jprobes: ... |
328 |
{ |
e65845235 [PATCH] Kprobes: ... |
329 330 331 332 333 334 |
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 [PATCH] jprobes: ... |
335 |
} |
e65845235 [PATCH] Kprobes: ... |
336 337 |
reset_kprobe_instance(); return ret; |
8b0914ea7 [PATCH] jprobes: ... |
338 |
} |
bf8d5c52c [PATCH] kprobes: ... |
339 340 341 342 343 344 345 346 347 348 349 350 |
/* 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 [PATCH] Kprobes: ... |
351 |
/* Called with kretprobe_lock held */ |
99219a3fb [PATCH] kretprobe... |
352 353 |
void __kprobes recycle_rp_inst(struct kretprobe_instance *ri, struct hlist_head *head) |
b94cce926 [PATCH] kprobes: ... |
354 355 356 357 358 359 360 361 362 363 364 |
{ /* 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 [PATCH] kretprobe... |
365 |
hlist_add_head(&ri->hlist, head); |
b94cce926 [PATCH] kprobes: ... |
366 |
} |
d0aaff979 [PATCH] Kprobes: ... |
367 |
struct hlist_head __kprobes *kretprobe_inst_table_head(struct task_struct *tsk) |
b94cce926 [PATCH] kprobes: ... |
368 369 370 |
{ return &kretprobe_inst_table[hash_ptr(tsk, KPROBE_HASH_BITS)]; } |
b94cce926 [PATCH] kprobes: ... |
371 |
/* |
c6fd91f0b [PATCH] kretprobe... |
372 373 374 375 |
* 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 [PATCH] kprobes: ... |
376 |
*/ |
d0aaff979 [PATCH] Kprobes: ... |
377 |
void __kprobes kprobe_flush_task(struct task_struct *tk) |
b94cce926 [PATCH] kprobes: ... |
378 |
{ |
62c27be0d [PATCH] kprobe wh... |
379 |
struct kretprobe_instance *ri; |
99219a3fb [PATCH] kretprobe... |
380 |
struct hlist_head *head, empty_rp; |
802eae7c8 [PATCH] Return pr... |
381 |
struct hlist_node *node, *tmp; |
0aa55e4d7 [PATCH] kprobes: ... |
382 |
unsigned long flags = 0; |
802eae7c8 [PATCH] Return pr... |
383 |
|
99219a3fb [PATCH] kretprobe... |
384 |
INIT_HLIST_HEAD(&empty_rp); |
3516a4604 [PATCH] Kprobes: ... |
385 |
spin_lock_irqsave(&kretprobe_lock, flags); |
62c27be0d [PATCH] kprobe wh... |
386 387 388 |
head = kretprobe_inst_table_head(tk); hlist_for_each_entry_safe(ri, node, tmp, head, hlist) { if (ri->task == tk) |
99219a3fb [PATCH] kretprobe... |
389 |
recycle_rp_inst(ri, &empty_rp); |
62c27be0d [PATCH] kprobe wh... |
390 |
} |
3516a4604 [PATCH] Kprobes: ... |
391 |
spin_unlock_irqrestore(&kretprobe_lock, flags); |
99219a3fb [PATCH] kretprobe... |
392 393 394 395 396 |
hlist_for_each_entry_safe(ri, node, tmp, &empty_rp, hlist) { hlist_del(&ri->hlist); kfree(ri); } |
b94cce926 [PATCH] kprobes: ... |
397 |
} |
b94cce926 [PATCH] kprobes: ... |
398 399 400 |
static inline void free_rp_inst(struct kretprobe *rp) { struct kretprobe_instance *ri; |
4c4308cb9 kprobes: kretprob... |
401 402 403 |
struct hlist_node *pos, *next; hlist_for_each_entry_safe(ri, pos, next, &rp->free_instances, uflist) { |
b94cce926 [PATCH] kprobes: ... |
404 405 406 407 |
hlist_del(&ri->uflist); kfree(ri); } } |
4a296e07c kprobes: add (un)... |
408 409 410 411 412 413 414 415 416 417 418 419 420 421 |
static void __kprobes cleanup_rp_inst(struct kretprobe *rp) { unsigned long flags; struct kretprobe_instance *ri; struct hlist_node *pos, *next; /* No race here */ spin_lock_irqsave(&kretprobe_lock, flags); hlist_for_each_entry_safe(ri, pos, next, &rp->used_instances, uflist) { ri->rp = NULL; hlist_del(&ri->uflist); } spin_unlock_irqrestore(&kretprobe_lock, flags); free_rp_inst(rp); } |
64f562c6d [PATCH] kprobes: ... |
422 |
/* |
8b0914ea7 [PATCH] jprobes: ... |
423 424 425 426 427 428 429 430 431 432 433 434 |
* 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 [PATCH] Kprobes: ... |
435 |
static int __kprobes add_new_kprobe(struct kprobe *old_p, struct kprobe *p) |
8b0914ea7 [PATCH] jprobes: ... |
436 |
{ |
8b0914ea7 [PATCH] jprobes: ... |
437 |
if (p->break_handler) { |
367216567 [PATCH] Kprobe: m... |
438 439 |
if (old_p->break_handler) return -EEXIST; |
3516a4604 [PATCH] Kprobes: ... |
440 |
list_add_tail_rcu(&p->list, &old_p->list); |
367216567 [PATCH] Kprobe: m... |
441 |
old_p->break_handler = aggr_break_handler; |
8b0914ea7 [PATCH] jprobes: ... |
442 |
} else |
3516a4604 [PATCH] Kprobes: ... |
443 |
list_add_rcu(&p->list, &old_p->list); |
367216567 [PATCH] Kprobe: m... |
444 445 |
if (p->post_handler && !old_p->post_handler) old_p->post_handler = aggr_post_handler; |
8b0914ea7 [PATCH] jprobes: ... |
446 447 448 449 |
return 0; } /* |
64f562c6d [PATCH] kprobes: ... |
450 451 452 453 454 |
* 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 [PATCH] jprobes: ... |
455 |
copy_kprobe(p, ap); |
a9ad965ea [PATCH] IA64: kpr... |
456 |
flush_insn_slot(ap); |
64f562c6d [PATCH] kprobes: ... |
457 |
ap->addr = p->addr; |
64f562c6d [PATCH] kprobes: ... |
458 |
ap->pre_handler = aggr_pre_handler; |
64f562c6d [PATCH] kprobes: ... |
459 |
ap->fault_handler = aggr_fault_handler; |
367216567 [PATCH] Kprobe: m... |
460 461 462 463 |
if (p->post_handler) ap->post_handler = aggr_post_handler; if (p->break_handler) ap->break_handler = aggr_break_handler; |
64f562c6d [PATCH] kprobes: ... |
464 465 |
INIT_LIST_HEAD(&ap->list); |
3516a4604 [PATCH] Kprobes: ... |
466 |
list_add_rcu(&p->list, &ap->list); |
64f562c6d [PATCH] kprobes: ... |
467 |
|
adad0f331 [PATCH] kprobes: ... |
468 |
hlist_replace_rcu(&p->hlist, &ap->hlist); |
64f562c6d [PATCH] kprobes: ... |
469 470 471 472 473 |
} /* * This is the second or subsequent kprobe at the address - handle * the intricacies |
64f562c6d [PATCH] kprobes: ... |
474 |
*/ |
d0aaff979 [PATCH] Kprobes: ... |
475 476 |
static int __kprobes register_aggr_kprobe(struct kprobe *old_p, struct kprobe *p) |
64f562c6d [PATCH] kprobes: ... |
477 478 479 |
{ int ret = 0; struct kprobe *ap; |
8b0914ea7 [PATCH] jprobes: ... |
480 481 482 |
if (old_p->pre_handler == aggr_pre_handler) { copy_kprobe(old_p, p); ret = add_new_kprobe(old_p, p); |
64f562c6d [PATCH] kprobes: ... |
483 |
} else { |
a0d50069e [PATCH] Kprobes: ... |
484 |
ap = kzalloc(sizeof(struct kprobe), GFP_KERNEL); |
64f562c6d [PATCH] kprobes: ... |
485 486 487 |
if (!ap) return -ENOMEM; add_aggr_kprobe(ap, old_p); |
8b0914ea7 [PATCH] jprobes: ... |
488 489 |
copy_kprobe(ap, p); ret = add_new_kprobe(ap, p); |
64f562c6d [PATCH] kprobes: ... |
490 491 492 |
} return ret; } |
d0aaff979 [PATCH] Kprobes: ... |
493 494 |
static int __kprobes in_kprobes_functions(unsigned long addr) { |
3d8d996e0 kprobes: prevent ... |
495 |
struct kprobe_blackpoint *kb; |
6f716acd5 kprobes: codingst... |
496 497 |
if (addr >= (unsigned long)__kprobes_text_start && addr < (unsigned long)__kprobes_text_end) |
d0aaff979 [PATCH] Kprobes: ... |
498 |
return -EINVAL; |
3d8d996e0 kprobes: prevent ... |
499 500 501 502 503 504 505 506 507 508 509 |
/* * If there exists a kprobe_blacklist, verify and * fail any probe registration in the prohibited area */ for (kb = kprobe_blacklist; kb->name != NULL; kb++) { if (kb->start_addr) { if (addr >= kb->start_addr && addr < (kb->start_addr + kb->range)) return -EINVAL; } } |
d0aaff979 [PATCH] Kprobes: ... |
510 511 |
return 0; } |
b2a5cd693 kprobes: fix a nu... |
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 |
/* * If we have a symbol_name argument, look it up and add the offset field * to it. This way, we can specify a relative address to a symbol. */ static kprobe_opcode_t __kprobes *kprobe_addr(struct kprobe *p) { kprobe_opcode_t *addr = p->addr; if (p->symbol_name) { if (addr) return NULL; kprobe_lookup_name(p->symbol_name, addr); } if (!addr) return NULL; return (kprobe_opcode_t *)(((char *)addr) + p->offset); } |
df019b1d8 [PATCH] kprobes: ... |
529 530 |
static int __kprobes __register_kprobe(struct kprobe *p, unsigned long called_from) |
1da177e4c Linux-2.6.12-rc2 |
531 532 |
{ int ret = 0; |
64f562c6d [PATCH] kprobes: ... |
533 |
struct kprobe *old_p; |
df019b1d8 [PATCH] kprobes: ... |
534 |
struct module *probed_mod; |
b2a5cd693 kprobes: fix a nu... |
535 |
kprobe_opcode_t *addr; |
b3e55c727 [PATCH] Kprobes: ... |
536 |
|
b2a5cd693 kprobes: fix a nu... |
537 538 |
addr = kprobe_addr(p); if (!addr) |
3a872d89b [PATCH] Kprobes: ... |
539 |
return -EINVAL; |
b2a5cd693 kprobes: fix a nu... |
540 |
p->addr = addr; |
3a872d89b [PATCH] Kprobes: ... |
541 |
|
6f716acd5 kprobes: codingst... |
542 543 |
if (!kernel_text_address((unsigned long) p->addr) || in_kprobes_functions((unsigned long) p->addr)) |
b3e55c727 [PATCH] Kprobes: ... |
544 |
return -EINVAL; |
df019b1d8 [PATCH] kprobes: ... |
545 |
p->mod_refcounted = 0; |
6f716acd5 kprobes: codingst... |
546 547 548 549 550 551 |
/* * Check if are we probing a module. */ probed_mod = module_text_address((unsigned long) p->addr); if (probed_mod) { |
df019b1d8 [PATCH] kprobes: ... |
552 |
struct module *calling_mod = module_text_address(called_from); |
6f716acd5 kprobes: codingst... |
553 554 555 556 |
/* * 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 [PATCH] kprobes: ... |
557 |
*/ |
6f716acd5 kprobes: codingst... |
558 |
if (calling_mod && calling_mod != probed_mod) { |
df019b1d8 [PATCH] kprobes: ... |
559 560 561 562 563 564 |
if (unlikely(!try_module_get(probed_mod))) return -EINVAL; p->mod_refcounted = 1; } else probed_mod = NULL; } |
1da177e4c Linux-2.6.12-rc2 |
565 |
|
3516a4604 [PATCH] Kprobes: ... |
566 |
p->nmissed = 0; |
9861668f7 kprobes: add (un)... |
567 |
INIT_LIST_HEAD(&p->list); |
7a7d1cf95 [PATCH] sem2mutex... |
568 |
mutex_lock(&kprobe_mutex); |
64f562c6d [PATCH] kprobes: ... |
569 570 571 |
old_p = get_kprobe(p->addr); if (old_p) { ret = register_aggr_kprobe(old_p, p); |
1da177e4c Linux-2.6.12-rc2 |
572 573 |
goto out; } |
1da177e4c Linux-2.6.12-rc2 |
574 |
|
6f716acd5 kprobes: codingst... |
575 576 |
ret = arch_prepare_kprobe(p); if (ret) |
49a2a1b83 [PATCH] kprobes: ... |
577 |
goto out; |
64f562c6d [PATCH] kprobes: ... |
578 |
INIT_HLIST_NODE(&p->hlist); |
3516a4604 [PATCH] Kprobes: ... |
579 |
hlist_add_head_rcu(&p->hlist, |
1da177e4c Linux-2.6.12-rc2 |
580 |
&kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]); |
74a0b5762 x86: optimize pag... |
581 |
if (kprobe_enabled) |
bf8f6e5b3 Kprobes: The ON/O... |
582 |
arch_arm_kprobe(p); |
74a0b5762 x86: optimize pag... |
583 |
|
1da177e4c Linux-2.6.12-rc2 |
584 |
out: |
7a7d1cf95 [PATCH] sem2mutex... |
585 |
mutex_unlock(&kprobe_mutex); |
49a2a1b83 [PATCH] kprobes: ... |
586 |
|
df019b1d8 [PATCH] kprobes: ... |
587 588 |
if (ret && probed_mod) module_put(probed_mod); |
1da177e4c Linux-2.6.12-rc2 |
589 590 |
return ret; } |
9861668f7 kprobes: add (un)... |
591 592 593 594 |
/* * Unregister a kprobe without a scheduler synchronization. */ static int __kprobes __unregister_kprobe_top(struct kprobe *p) |
1da177e4c Linux-2.6.12-rc2 |
595 |
{ |
f709b1223 [PATCH] kprobes-c... |
596 |
struct kprobe *old_p, *list_p; |
64f562c6d [PATCH] kprobes: ... |
597 |
|
64f562c6d [PATCH] kprobes: ... |
598 |
old_p = get_kprobe(p->addr); |
9861668f7 kprobes: add (un)... |
599 600 |
if (unlikely(!old_p)) return -EINVAL; |
f709b1223 [PATCH] kprobes-c... |
601 602 603 604 605 |
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; |
9861668f7 kprobes: add (un)... |
606 |
return -EINVAL; |
f709b1223 [PATCH] kprobes-c... |
607 608 |
} valid_p: |
6f716acd5 kprobes: codingst... |
609 610 |
if (old_p == p || (old_p->pre_handler == aggr_pre_handler && |
9861668f7 kprobes: add (un)... |
611 |
list_is_singular(&old_p->list))) { |
bf8f6e5b3 Kprobes: The ON/O... |
612 613 614 615 616 617 618 |
/* * 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 [PATCH] kprobes: ... |
619 |
hlist_del_rcu(&old_p->hlist); |
49a2a1b83 [PATCH] kprobes: ... |
620 |
} else { |
9861668f7 kprobes: add (un)... |
621 622 623 624 625 626 627 628 629 630 |
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 != p) && (list_p->post_handler)) goto noclean; } old_p->post_handler = NULL; } noclean: |
49a2a1b83 [PATCH] kprobes: ... |
631 |
list_del_rcu(&p->list); |
49a2a1b83 [PATCH] kprobes: ... |
632 |
} |
9861668f7 kprobes: add (un)... |
633 634 |
return 0; } |
3516a4604 [PATCH] Kprobes: ... |
635 |
|
9861668f7 kprobes: add (un)... |
636 637 638 639 |
static void __kprobes __unregister_kprobe_bottom(struct kprobe *p) { struct module *mod; struct kprobe *old_p; |
b3e55c727 [PATCH] Kprobes: ... |
640 |
|
6f716acd5 kprobes: codingst... |
641 642 643 644 645 |
if (p->mod_refcounted) { mod = module_text_address((unsigned long)p->addr); if (mod) module_put(mod); } |
b3e55c727 [PATCH] Kprobes: ... |
646 |
|
9861668f7 kprobes: add (un)... |
647 648 649 650 651 |
if (list_empty(&p->list) || list_is_singular(&p->list)) { if (!list_empty(&p->list)) { /* "p" is the last child of an aggr_kprobe */ old_p = list_entry(p->list.next, struct kprobe, list); list_del(&p->list); |
3516a4604 [PATCH] Kprobes: ... |
652 |
kfree(old_p); |
49a2a1b83 [PATCH] kprobes: ... |
653 |
} |
0498b6350 [PATCH] kprobes: ... |
654 |
arch_remove_kprobe(p); |
9861668f7 kprobes: add (un)... |
655 656 657 658 659 660 661 662 663 664 665 666 |
} } static int __register_kprobes(struct kprobe **kps, int num, unsigned long called_from) { int i, ret = 0; if (num <= 0) return -EINVAL; for (i = 0; i < num; i++) { ret = __register_kprobe(kps[i], called_from); |
67dddaad5 kprobes: fix erro... |
667 668 669 |
if (ret < 0) { if (i > 0) unregister_kprobes(kps, i); |
9861668f7 kprobes: add (un)... |
670 |
break; |
367216567 [PATCH] Kprobe: m... |
671 |
} |
49a2a1b83 [PATCH] kprobes: ... |
672 |
} |
9861668f7 kprobes: add (un)... |
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 |
return ret; } /* * Registration and unregistration functions for kprobe. */ int __kprobes register_kprobe(struct kprobe *p) { return __register_kprobes(&p, 1, (unsigned long)__builtin_return_address(0)); } void __kprobes unregister_kprobe(struct kprobe *p) { unregister_kprobes(&p, 1); } int __kprobes register_kprobes(struct kprobe **kps, int num) { return __register_kprobes(kps, num, (unsigned long)__builtin_return_address(0)); } void __kprobes unregister_kprobes(struct kprobe **kps, int num) { int i; if (num <= 0) return; mutex_lock(&kprobe_mutex); for (i = 0; i < num; i++) if (__unregister_kprobe_top(kps[i]) < 0) kps[i]->addr = NULL; mutex_unlock(&kprobe_mutex); synchronize_sched(); for (i = 0; i < num; i++) if (kps[i]->addr) __unregister_kprobe_bottom(kps[i]); |
1da177e4c Linux-2.6.12-rc2 |
712 713 714 715 |
} static struct notifier_block kprobe_exceptions_nb = { .notifier_call = kprobe_exceptions_notify, |
3d5631e06 [PATCH] Kprobes r... |
716 717 |
.priority = 0x7fffffff /* we need to be notified first */ }; |
3d7e33825 jprobes: make jpr... |
718 719 720 721 |
unsigned long __weak arch_deref_entry_point(void *entry) { return (unsigned long)entry; } |
1da177e4c Linux-2.6.12-rc2 |
722 |
|
26b31c190 kprobes: add (un)... |
723 724 |
static int __register_jprobes(struct jprobe **jps, int num, unsigned long called_from) |
1da177e4c Linux-2.6.12-rc2 |
725 |
{ |
26b31c190 kprobes: add (un)... |
726 727 |
struct jprobe *jp; int ret = 0, i; |
3d7e33825 jprobes: make jpr... |
728 |
|
26b31c190 kprobes: add (un)... |
729 |
if (num <= 0) |
3d7e33825 jprobes: make jpr... |
730 |
return -EINVAL; |
26b31c190 kprobes: add (un)... |
731 732 733 734 735 736 737 738 739 740 741 742 743 |
for (i = 0; i < num; i++) { unsigned long addr; jp = jps[i]; addr = arch_deref_entry_point(jp->entry); if (!kernel_text_address(addr)) ret = -EINVAL; else { /* Todo: Verify probepoint is a function entry point */ jp->kp.pre_handler = setjmp_pre_handler; jp->kp.break_handler = longjmp_break_handler; ret = __register_kprobe(&jp->kp, called_from); } |
67dddaad5 kprobes: fix erro... |
744 745 746 |
if (ret < 0) { if (i > 0) unregister_jprobes(jps, i); |
26b31c190 kprobes: add (un)... |
747 748 749 750 751 |
break; } } return ret; } |
3d7e33825 jprobes: make jpr... |
752 |
|
26b31c190 kprobes: add (un)... |
753 754 755 |
int __kprobes register_jprobe(struct jprobe *jp) { return __register_jprobes(&jp, 1, |
df019b1d8 [PATCH] kprobes: ... |
756 |
(unsigned long)__builtin_return_address(0)); |
1da177e4c Linux-2.6.12-rc2 |
757 |
} |
d0aaff979 [PATCH] Kprobes: ... |
758 |
void __kprobes unregister_jprobe(struct jprobe *jp) |
1da177e4c Linux-2.6.12-rc2 |
759 |
{ |
26b31c190 kprobes: add (un)... |
760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 |
unregister_jprobes(&jp, 1); } int __kprobes register_jprobes(struct jprobe **jps, int num) { return __register_jprobes(jps, num, (unsigned long)__builtin_return_address(0)); } void __kprobes unregister_jprobes(struct jprobe **jps, int num) { int i; if (num <= 0) return; mutex_lock(&kprobe_mutex); for (i = 0; i < num; i++) if (__unregister_kprobe_top(&jps[i]->kp) < 0) jps[i]->kp.addr = NULL; mutex_unlock(&kprobe_mutex); synchronize_sched(); for (i = 0; i < num; i++) { if (jps[i]->kp.addr) __unregister_kprobe_bottom(&jps[i]->kp); } |
1da177e4c Linux-2.6.12-rc2 |
786 |
} |
9edddaa20 Kprobes: indicate... |
787 |
#ifdef CONFIG_KRETPROBES |
e65cefe87 [PATCH] kernel/kp... |
788 789 790 791 792 793 794 795 796 797 798 799 |
/* * 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 kprobes: kretprob... |
800 801 802 803 804 805 806 |
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; |
f47cd9b55 kprobes: kretprob... |
807 808 809 810 811 |
if (rp->entry_handler && rp->entry_handler(ri, regs)) { spin_unlock_irqrestore(&kretprobe_lock, flags); return 0; } |
4c4308cb9 kprobes: kretprob... |
812 813 814 815 816 817 818 819 |
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 [PATCH] kernel/kp... |
820 821 822 |
spin_unlock_irqrestore(&kretprobe_lock, flags); return 0; } |
4a296e07c kprobes: add (un)... |
823 824 |
static int __kprobes __register_kretprobe(struct kretprobe *rp, unsigned long called_from) |
b94cce926 [PATCH] kprobes: ... |
825 826 827 828 |
{ int ret = 0; struct kretprobe_instance *inst; int i; |
b2a5cd693 kprobes: fix a nu... |
829 |
void *addr; |
f438d914b kprobes: support ... |
830 831 |
if (kretprobe_blacklist_size) { |
b2a5cd693 kprobes: fix a nu... |
832 833 834 |
addr = kprobe_addr(&rp->kp); if (!addr) return -EINVAL; |
f438d914b kprobes: support ... |
835 836 837 838 839 840 |
for (i = 0; kretprobe_blacklist[i].name != NULL; i++) { if (kretprobe_blacklist[i].addr == addr) return -EINVAL; } } |
b94cce926 [PATCH] kprobes: ... |
841 842 |
rp->kp.pre_handler = pre_handler_kretprobe; |
7522a8423 [PATCH] kprobes: ... |
843 844 845 |
rp->kp.post_handler = NULL; rp->kp.fault_handler = NULL; rp->kp.break_handler = NULL; |
b94cce926 [PATCH] kprobes: ... |
846 847 848 849 850 851 852 853 854 855 856 857 |
/* 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++) { |
f47cd9b55 kprobes: kretprob... |
858 859 |
inst = kmalloc(sizeof(struct kretprobe_instance) + rp->data_size, GFP_KERNEL); |
b94cce926 [PATCH] kprobes: ... |
860 861 862 863 864 865 866 867 868 869 |
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 */ |
4a296e07c kprobes: add (un)... |
870 871 |
ret = __register_kprobe(&rp->kp, called_from); if (ret != 0) |
b94cce926 [PATCH] kprobes: ... |
872 873 874 |
free_rp_inst(rp); return ret; } |
4a296e07c kprobes: add (un)... |
875 876 877 878 879 880 881 882 883 |
static int __register_kretprobes(struct kretprobe **rps, int num, unsigned long called_from) { int ret = 0, i; if (num <= 0) return -EINVAL; for (i = 0; i < num; i++) { ret = __register_kretprobe(rps[i], called_from); |
67dddaad5 kprobes: fix erro... |
884 885 886 |
if (ret < 0) { if (i > 0) unregister_kretprobes(rps, i); |
4a296e07c kprobes: add (un)... |
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 919 920 921 922 923 924 925 926 927 928 929 |
break; } } return ret; } int __kprobes register_kretprobe(struct kretprobe *rp) { return __register_kretprobes(&rp, 1, (unsigned long)__builtin_return_address(0)); } void __kprobes unregister_kretprobe(struct kretprobe *rp) { unregister_kretprobes(&rp, 1); } int __kprobes register_kretprobes(struct kretprobe **rps, int num) { return __register_kretprobes(rps, num, (unsigned long)__builtin_return_address(0)); } void __kprobes unregister_kretprobes(struct kretprobe **rps, int num) { int i; if (num <= 0) return; mutex_lock(&kprobe_mutex); for (i = 0; i < num; i++) if (__unregister_kprobe_top(&rps[i]->kp) < 0) rps[i]->kp.addr = NULL; mutex_unlock(&kprobe_mutex); synchronize_sched(); for (i = 0; i < num; i++) { if (rps[i]->kp.addr) { __unregister_kprobe_bottom(&rps[i]->kp); cleanup_rp_inst(rps[i]); } } } |
9edddaa20 Kprobes: indicate... |
930 |
#else /* CONFIG_KRETPROBES */ |
d0aaff979 [PATCH] Kprobes: ... |
931 |
int __kprobes register_kretprobe(struct kretprobe *rp) |
b94cce926 [PATCH] kprobes: ... |
932 933 934 |
{ return -ENOSYS; } |
4a296e07c kprobes: add (un)... |
935 |
int __kprobes register_kretprobes(struct kretprobe **rps, int num) |
346fd59ba [PATCH] kprobes: ... |
936 |
{ |
4a296e07c kprobes: add (un)... |
937 |
return -ENOSYS; |
346fd59ba [PATCH] kprobes: ... |
938 |
} |
d0aaff979 [PATCH] Kprobes: ... |
939 |
void __kprobes unregister_kretprobe(struct kretprobe *rp) |
b94cce926 [PATCH] kprobes: ... |
940 |
{ |
4a296e07c kprobes: add (un)... |
941 |
} |
b94cce926 [PATCH] kprobes: ... |
942 |
|
4a296e07c kprobes: add (un)... |
943 944 945 |
void __kprobes unregister_kretprobes(struct kretprobe **rps, int num) { } |
4c4308cb9 kprobes: kretprob... |
946 |
|
4a296e07c kprobes: add (un)... |
947 948 949 950 |
static int __kprobes pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs) { return 0; |
b94cce926 [PATCH] kprobes: ... |
951 |
} |
4a296e07c kprobes: add (un)... |
952 |
#endif /* CONFIG_KRETPROBES */ |
1da177e4c Linux-2.6.12-rc2 |
953 954 955 |
static int __init init_kprobes(void) { int i, err = 0; |
3d8d996e0 kprobes: prevent ... |
956 957 958 959 960 |
unsigned long offset = 0, size = 0; char *modname, namebuf[128]; const char *symbol_name; void *addr; struct kprobe_blackpoint *kb; |
1da177e4c Linux-2.6.12-rc2 |
961 962 963 |
/* FIXME allocate the probe table, currently defined statically */ /* initialize all list heads */ |
b94cce926 [PATCH] kprobes: ... |
964 |
for (i = 0; i < KPROBE_TABLE_SIZE; i++) { |
1da177e4c Linux-2.6.12-rc2 |
965 |
INIT_HLIST_HEAD(&kprobe_table[i]); |
b94cce926 [PATCH] kprobes: ... |
966 967 |
INIT_HLIST_HEAD(&kretprobe_inst_table[i]); } |
1da177e4c Linux-2.6.12-rc2 |
968 |
|
3d8d996e0 kprobes: prevent ... |
969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 |
/* * Lookup and populate the kprobe_blacklist. * * Unlike the kretprobe blacklist, we'll need to determine * the range of addresses that belong to the said functions, * since a kprobe need not necessarily be at the beginning * of a function. */ for (kb = kprobe_blacklist; kb->name != NULL; kb++) { kprobe_lookup_name(kb->name, addr); if (!addr) continue; kb->start_addr = (unsigned long)addr; symbol_name = kallsyms_lookup(kb->start_addr, &size, &offset, &modname, namebuf); if (!symbol_name) kb->range = 0; else kb->range = size; } |
f438d914b kprobes: support ... |
990 991 992 993 994 995 996 997 998 999 1000 |
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 Kprobes: The ON/O... |
1001 1002 |
/* By default, kprobes are enabled */ kprobe_enabled = true; |
6772926be [PATCH] kprobes: ... |
1003 |
err = arch_init_kprobes(); |
802eae7c8 [PATCH] Return pr... |
1004 1005 |
if (!err) err = register_die_notifier(&kprobe_exceptions_nb); |
8c1c93564 x86: kprobes: add... |
1006 1007 |
if (!err) init_test_probes(); |
1da177e4c Linux-2.6.12-rc2 |
1008 1009 |
return err; } |
346fd59ba [PATCH] kprobes: ... |
1010 1011 |
#ifdef CONFIG_DEBUG_FS static void __kprobes report_probe(struct seq_file *pi, struct kprobe *p, |
bf8f6e5b3 Kprobes: The ON/O... |
1012 |
const char *sym, int offset,char *modname) |
346fd59ba [PATCH] kprobes: ... |
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 |
{ 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 Simplify kallsyms... |
1056 |
unsigned long offset = 0; |
346fd59ba [PATCH] kprobes: ... |
1057 1058 1059 1060 1061 |
char *modname, namebuf[128]; head = &kprobe_table[i]; preempt_disable(); hlist_for_each_entry_rcu(p, node, head, hlist) { |
ffb451227 Simplify kallsyms... |
1062 |
sym = kallsyms_lookup((unsigned long)p->addr, NULL, |
346fd59ba [PATCH] kprobes: ... |
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 |
&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 Kprobes: The ON/O... |
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 |
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 Kprobes: The ON/O... |
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 |
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 x86: optimize pag... |
1146 |
return; |
bf8f6e5b3 Kprobes: The ON/O... |
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 |
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 [PATCH] kprobes: ... |
1203 1204 1205 |
static int __kprobes debugfs_kprobe_init(void) { struct dentry *dir, *file; |
bf8f6e5b3 Kprobes: The ON/O... |
1206 |
unsigned int value = 1; |
346fd59ba [PATCH] kprobes: ... |
1207 1208 1209 1210 |
dir = debugfs_create_dir("kprobes", NULL); if (!dir) return -ENOMEM; |
e38697929 kprobes: fix spar... |
1211 |
file = debugfs_create_file("list", 0444, dir, NULL, |
346fd59ba [PATCH] kprobes: ... |
1212 1213 1214 1215 1216 |
&debugfs_kprobes_operations); if (!file) { debugfs_remove(dir); return -ENOMEM; } |
bf8f6e5b3 Kprobes: The ON/O... |
1217 1218 1219 1220 1221 1222 |
file = debugfs_create_file("enabled", 0600, dir, &value, &fops_kp); if (!file) { debugfs_remove(dir); return -ENOMEM; } |
346fd59ba [PATCH] kprobes: ... |
1223 1224 1225 1226 1227 1228 1229 |
return 0; } late_initcall(debugfs_kprobe_init); #endif /* CONFIG_DEBUG_FS */ module_init(init_kprobes); |
1da177e4c Linux-2.6.12-rc2 |
1230 1231 1232 |
EXPORT_SYMBOL_GPL(register_kprobe); EXPORT_SYMBOL_GPL(unregister_kprobe); |
9861668f7 kprobes: add (un)... |
1233 1234 |
EXPORT_SYMBOL_GPL(register_kprobes); EXPORT_SYMBOL_GPL(unregister_kprobes); |
1da177e4c Linux-2.6.12-rc2 |
1235 1236 |
EXPORT_SYMBOL_GPL(register_jprobe); EXPORT_SYMBOL_GPL(unregister_jprobe); |
26b31c190 kprobes: add (un)... |
1237 1238 |
EXPORT_SYMBOL_GPL(register_jprobes); EXPORT_SYMBOL_GPL(unregister_jprobes); |
cd5bfea27 fix compilation w... |
1239 |
#ifdef CONFIG_KPROBES |
1da177e4c Linux-2.6.12-rc2 |
1240 |
EXPORT_SYMBOL_GPL(jprobe_return); |
cd5bfea27 fix compilation w... |
1241 1242 1243 |
#endif #ifdef CONFIG_KPROBES |
b94cce926 [PATCH] kprobes: ... |
1244 1245 |
EXPORT_SYMBOL_GPL(register_kretprobe); EXPORT_SYMBOL_GPL(unregister_kretprobe); |
4a296e07c kprobes: add (un)... |
1246 1247 |
EXPORT_SYMBOL_GPL(register_kretprobes); EXPORT_SYMBOL_GPL(unregister_kretprobes); |
cd5bfea27 fix compilation w... |
1248 |
#endif |