2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
* 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.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/hash.h>
|
|
|
|
#include <linux/init.h>
|
2005-10-30 23:03:48 +00:00
|
|
|
#include <linux/slab.h>
|
2007-05-08 07:27:01 +00:00
|
|
|
#include <linux/stddef.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/module.h>
|
2005-06-27 22:17:01 +00:00
|
|
|
#include <linux/moduleloader.h>
|
2006-10-02 09:17:30 +00:00
|
|
|
#include <linux/kallsyms.h>
|
2006-12-07 04:38:11 +00:00
|
|
|
#include <linux/freezer.h>
|
2007-02-20 21:57:54 +00:00
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/debugfs.h>
|
2007-05-08 07:27:03 +00:00
|
|
|
#include <linux/kdebug.h>
|
2009-03-06 15:36:38 +00:00
|
|
|
#include <linux/memory.h>
|
2007-05-08 07:34:16 +00:00
|
|
|
|
2005-09-06 22:19:26 +00:00
|
|
|
#include <asm-generic/sections.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/cacheflush.h>
|
|
|
|
#include <asm/errno.h>
|
2007-05-08 07:34:16 +00:00
|
|
|
#include <asm/uaccess.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define KPROBE_HASH_BITS 6
|
|
|
|
#define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS)
|
|
|
|
|
2006-10-02 09:17:30 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
|
2008-07-25 08:46:04 +00:00
|
|
|
static int kprobes_initialized;
|
2005-04-16 22:20:36 +00:00
|
|
|
static struct hlist_head kprobe_table[KPROBE_TABLE_SIZE];
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-08 07:34:16 +00:00
|
|
|
/* NOTE: change this value only with kprobe_mutex held */
|
2009-04-07 02:01:01 +00:00
|
|
|
static bool kprobes_all_disarmed;
|
2007-05-08 07:34:16 +00:00
|
|
|
|
2009-01-06 22:41:50 +00:00
|
|
|
static DEFINE_MUTEX(kprobe_mutex); /* Protects kprobe_table */
|
2005-11-07 09:00:07 +00:00
|
|
|
static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
|
2008-07-25 08:46:04 +00:00
|
|
|
static struct {
|
2008-11-12 21:26:57 +00:00
|
|
|
spinlock_t lock ____cacheline_aligned_in_smp;
|
2008-07-25 08:46:04 +00:00
|
|
|
} kretprobe_table_locks[KPROBE_TABLE_SIZE];
|
|
|
|
|
|
|
|
static spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
|
|
|
|
{
|
|
|
|
return &(kretprobe_table_locks[hash].lock);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-28 09:14:26 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2008-07-10 16:38:19 +00:00
|
|
|
static struct kprobe_blackpoint kprobe_blacklist[] = {
|
2008-04-28 09:14:26 +00:00
|
|
|
{"preempt_schedule",},
|
|
|
|
{NULL} /* Terminator */
|
|
|
|
};
|
|
|
|
|
2006-01-10 04:52:41 +00:00
|
|
|
#ifdef __ARCH_WANT_KPROBES_INSN_SLOT
|
2005-06-27 22:17:01 +00:00
|
|
|
/*
|
|
|
|
* 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 {
|
2009-06-30 21:08:14 +00:00
|
|
|
struct list_head list;
|
2005-06-27 22:17:01 +00:00
|
|
|
kprobe_opcode_t *insns; /* Page of instruction slots */
|
|
|
|
char slot_used[INSNS_PER_PAGE];
|
|
|
|
int nused;
|
2006-12-07 04:38:11 +00:00
|
|
|
int ngarbage;
|
2005-06-27 22:17:01 +00:00
|
|
|
};
|
|
|
|
|
2007-01-30 22:36:06 +00:00
|
|
|
enum kprobe_slot_state {
|
|
|
|
SLOT_CLEAN = 0,
|
|
|
|
SLOT_DIRTY = 1,
|
|
|
|
SLOT_USED = 2,
|
|
|
|
};
|
|
|
|
|
2009-01-06 22:41:50 +00:00
|
|
|
static DEFINE_MUTEX(kprobe_insn_mutex); /* Protects kprobe_insn_pages */
|
2009-06-30 21:08:14 +00:00
|
|
|
static LIST_HEAD(kprobe_insn_pages);
|
2006-12-07 04:38:11 +00:00
|
|
|
static int kprobe_garbage_slots;
|
|
|
|
static int collect_garbage_slots(void);
|
|
|
|
|
|
|
|
static int __kprobes check_safety(void)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
2009-01-06 20:15:32 +00:00
|
|
|
#if defined(CONFIG_PREEMPT) && defined(CONFIG_FREEZER)
|
2006-12-07 04:38:11 +00:00
|
|
|
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\n",p->comm);
|
|
|
|
ret = -1;
|
|
|
|
goto loop_end;
|
|
|
|
}
|
|
|
|
} while_each_thread(p, q);
|
|
|
|
}
|
|
|
|
loop_end:
|
|
|
|
thaw_processes();
|
|
|
|
#else
|
|
|
|
synchronize_sched();
|
|
|
|
#endif
|
|
|
|
return ret;
|
|
|
|
}
|
2005-06-27 22:17:01 +00:00
|
|
|
|
|
|
|
/**
|
2009-01-06 22:41:50 +00:00
|
|
|
* __get_insn_slot() - Find a slot on an executable page for an instruction.
|
2005-06-27 22:17:01 +00:00
|
|
|
* We allocate an executable page if there's no room on existing ones.
|
|
|
|
*/
|
2009-01-06 22:41:50 +00:00
|
|
|
static kprobe_opcode_t __kprobes *__get_insn_slot(void)
|
2005-06-27 22:17:01 +00:00
|
|
|
{
|
|
|
|
struct kprobe_insn_page *kip;
|
|
|
|
|
2007-05-08 07:34:13 +00:00
|
|
|
retry:
|
2009-06-30 21:08:14 +00:00
|
|
|
list_for_each_entry(kip, &kprobe_insn_pages, list) {
|
2005-06-27 22:17:01 +00:00
|
|
|
if (kip->nused < INSNS_PER_PAGE) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < INSNS_PER_PAGE; i++) {
|
2007-01-30 22:36:06 +00:00
|
|
|
if (kip->slot_used[i] == SLOT_CLEAN) {
|
|
|
|
kip->slot_used[i] = SLOT_USED;
|
2005-06-27 22:17:01 +00:00
|
|
|
kip->nused++;
|
|
|
|
return kip->insns + (i * MAX_INSN_SIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Surprise! No unused slots. Fix kip->nused. */
|
|
|
|
kip->nused = INSNS_PER_PAGE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-07 04:38:11 +00:00
|
|
|
/* 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. */
|
2005-06-27 22:17:01 +00:00
|
|
|
kip = kmalloc(sizeof(struct kprobe_insn_page), GFP_KERNEL);
|
2007-05-08 07:34:13 +00:00
|
|
|
if (!kip)
|
2005-06-27 22:17:01 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
2009-06-30 21:08:14 +00:00
|
|
|
INIT_LIST_HEAD(&kip->list);
|
|
|
|
list_add(&kip->list, &kprobe_insn_pages);
|
2007-01-30 22:36:06 +00:00
|
|
|
memset(kip->slot_used, SLOT_CLEAN, INSNS_PER_PAGE);
|
|
|
|
kip->slot_used[0] = SLOT_USED;
|
2005-06-27 22:17:01 +00:00
|
|
|
kip->nused = 1;
|
2006-12-07 04:38:11 +00:00
|
|
|
kip->ngarbage = 0;
|
2005-06-27 22:17:01 +00:00
|
|
|
return kip->insns;
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:50 +00:00
|
|
|
kprobe_opcode_t __kprobes *get_insn_slot(void)
|
|
|
|
{
|
|
|
|
kprobe_opcode_t *ret;
|
|
|
|
mutex_lock(&kprobe_insn_mutex);
|
|
|
|
ret = __get_insn_slot();
|
|
|
|
mutex_unlock(&kprobe_insn_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-12-07 04:38:11 +00:00
|
|
|
/* Return 1 if all garbages are collected, otherwise 0. */
|
|
|
|
static int __kprobes collect_one_slot(struct kprobe_insn_page *kip, int idx)
|
|
|
|
{
|
2007-01-30 22:36:06 +00:00
|
|
|
kip->slot_used[idx] = SLOT_CLEAN;
|
2006-12-07 04:38:11 +00:00
|
|
|
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.
|
|
|
|
*/
|
2009-06-30 21:08:14 +00:00
|
|
|
if (!list_is_singular(&kprobe_insn_pages)) {
|
|
|
|
list_del(&kip->list);
|
2006-12-07 04:38:11 +00:00
|
|
|
module_free(NULL, kip->insns);
|
|
|
|
kfree(kip);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __kprobes collect_garbage_slots(void)
|
|
|
|
{
|
2009-06-30 21:08:14 +00:00
|
|
|
struct kprobe_insn_page *kip, *next;
|
2006-12-07 04:38:11 +00:00
|
|
|
|
|
|
|
/* Ensure no-one is preepmted on the garbages */
|
2009-06-30 21:08:09 +00:00
|
|
|
if (check_safety())
|
2006-12-07 04:38:11 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2009-06-30 21:08:14 +00:00
|
|
|
list_for_each_entry_safe(kip, next, &kprobe_insn_pages, list) {
|
2006-12-07 04:38:11 +00:00
|
|
|
int i;
|
|
|
|
if (kip->ngarbage == 0)
|
|
|
|
continue;
|
|
|
|
kip->ngarbage = 0; /* we will collect all garbages */
|
|
|
|
for (i = 0; i < INSNS_PER_PAGE; i++) {
|
2007-01-30 22:36:06 +00:00
|
|
|
if (kip->slot_used[i] == SLOT_DIRTY &&
|
2006-12-07 04:38:11 +00:00
|
|
|
collect_one_slot(kip, i))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kprobe_garbage_slots = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __kprobes free_insn_slot(kprobe_opcode_t * slot, int dirty)
|
2005-06-27 22:17:01 +00:00
|
|
|
{
|
|
|
|
struct kprobe_insn_page *kip;
|
|
|
|
|
2009-01-06 22:41:50 +00:00
|
|
|
mutex_lock(&kprobe_insn_mutex);
|
2009-06-30 21:08:14 +00:00
|
|
|
list_for_each_entry(kip, &kprobe_insn_pages, list) {
|
2005-06-27 22:17:01 +00:00
|
|
|
if (kip->insns <= slot &&
|
|
|
|
slot < kip->insns + (INSNS_PER_PAGE * MAX_INSN_SIZE)) {
|
|
|
|
int i = (slot - kip->insns) / MAX_INSN_SIZE;
|
2006-12-07 04:38:11 +00:00
|
|
|
if (dirty) {
|
2007-01-30 22:36:06 +00:00
|
|
|
kip->slot_used[i] = SLOT_DIRTY;
|
2006-12-07 04:38:11 +00:00
|
|
|
kip->ngarbage++;
|
2009-06-30 21:08:14 +00:00
|
|
|
} else
|
2006-12-07 04:38:11 +00:00
|
|
|
collect_one_slot(kip, i);
|
|
|
|
break;
|
2005-06-27 22:17:01 +00:00
|
|
|
}
|
|
|
|
}
|
2007-05-08 07:34:13 +00:00
|
|
|
|
|
|
|
if (dirty && ++kprobe_garbage_slots > INSNS_PER_PAGE)
|
2006-12-07 04:38:11 +00:00
|
|
|
collect_garbage_slots();
|
2009-01-06 22:41:50 +00:00
|
|
|
|
|
|
|
mutex_unlock(&kprobe_insn_mutex);
|
2005-06-27 22:17:01 +00:00
|
|
|
}
|
2006-01-10 04:52:41 +00:00
|
|
|
#endif
|
2005-06-27 22:17:01 +00:00
|
|
|
|
2005-11-07 09:00:07 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2005-11-07 09:00:13 +00:00
|
|
|
/*
|
|
|
|
* This routine is called either:
|
2006-01-10 04:52:43 +00:00
|
|
|
* - under the kprobe_mutex - during kprobe_[un]register()
|
2005-11-07 09:00:13 +00:00
|
|
|
* OR
|
2005-11-07 09:00:14 +00:00
|
|
|
* - with preemption disabled - from arch/xxx/kernel/kprobes.c
|
2005-11-07 09:00:13 +00:00
|
|
|
*/
|
2005-09-06 22:19:26 +00:00
|
|
|
struct kprobe __kprobes *get_kprobe(void *addr)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct hlist_node *node;
|
2005-11-07 09:00:13 +00:00
|
|
|
struct kprobe *p;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)];
|
2005-11-07 09:00:13 +00:00
|
|
|
hlist_for_each_entry_rcu(p, node, head, hlist) {
|
2005-04-16 22:20:36 +00:00
|
|
|
if (p->addr == addr)
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-05-07 20:31:26 +00:00
|
|
|
/* Arm a kprobe with text_mutex */
|
|
|
|
static void __kprobes arm_kprobe(struct kprobe *kp)
|
|
|
|
{
|
|
|
|
mutex_lock(&text_mutex);
|
|
|
|
arch_arm_kprobe(kp);
|
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Disarm a kprobe with text_mutex */
|
|
|
|
static void __kprobes disarm_kprobe(struct kprobe *kp)
|
|
|
|
{
|
|
|
|
mutex_lock(&text_mutex);
|
|
|
|
arch_disarm_kprobe(kp);
|
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
}
|
|
|
|
|
2005-05-05 23:15:42 +00:00
|
|
|
/*
|
|
|
|
* Aggregate handlers for multiple kprobes support - these handlers
|
|
|
|
* take care of invoking the individual kprobe handlers on p->list
|
|
|
|
*/
|
2005-09-06 22:19:26 +00:00
|
|
|
static int __kprobes aggr_pre_handler(struct kprobe *p, struct pt_regs *regs)
|
2005-05-05 23:15:42 +00:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
|
|
|
|
2005-11-07 09:00:13 +00:00
|
|
|
list_for_each_entry_rcu(kp, &p->list, list) {
|
2009-04-07 02:01:02 +00:00
|
|
|
if (kp->pre_handler && likely(!kprobe_disabled(kp))) {
|
2005-11-07 09:00:07 +00:00
|
|
|
set_kprobe_instance(kp);
|
2005-06-23 07:09:41 +00:00
|
|
|
if (kp->pre_handler(kp, regs))
|
|
|
|
return 1;
|
2005-05-05 23:15:42 +00:00
|
|
|
}
|
2005-11-07 09:00:07 +00:00
|
|
|
reset_kprobe_instance();
|
2005-05-05 23:15:42 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-09-06 22:19:26 +00:00
|
|
|
static void __kprobes aggr_post_handler(struct kprobe *p, struct pt_regs *regs,
|
|
|
|
unsigned long flags)
|
2005-05-05 23:15:42 +00:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
|
|
|
|
2005-11-07 09:00:13 +00:00
|
|
|
list_for_each_entry_rcu(kp, &p->list, list) {
|
2009-04-07 02:01:02 +00:00
|
|
|
if (kp->post_handler && likely(!kprobe_disabled(kp))) {
|
2005-11-07 09:00:07 +00:00
|
|
|
set_kprobe_instance(kp);
|
2005-05-05 23:15:42 +00:00
|
|
|
kp->post_handler(kp, regs, flags);
|
2005-11-07 09:00:07 +00:00
|
|
|
reset_kprobe_instance();
|
2005-05-05 23:15:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-09-06 22:19:26 +00:00
|
|
|
static int __kprobes aggr_fault_handler(struct kprobe *p, struct pt_regs *regs,
|
|
|
|
int trapnr)
|
2005-05-05 23:15:42 +00:00
|
|
|
{
|
2005-11-07 09:00:07 +00:00
|
|
|
struct kprobe *cur = __get_cpu_var(kprobe_instance);
|
|
|
|
|
2005-05-05 23:15:42 +00:00
|
|
|
/*
|
|
|
|
* if we faulted "during" the execution of a user specified
|
|
|
|
* probe handler, invoke just that probe's fault handler
|
|
|
|
*/
|
2005-11-07 09:00:07 +00:00
|
|
|
if (cur && cur->fault_handler) {
|
|
|
|
if (cur->fault_handler(cur, regs, trapnr))
|
2005-05-05 23:15:42 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-09-06 22:19:26 +00:00
|
|
|
static int __kprobes aggr_break_handler(struct kprobe *p, struct pt_regs *regs)
|
2005-06-23 07:09:41 +00:00
|
|
|
{
|
2005-11-07 09:00:07 +00:00
|
|
|
struct kprobe *cur = __get_cpu_var(kprobe_instance);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (cur && cur->break_handler) {
|
|
|
|
if (cur->break_handler(cur, regs))
|
|
|
|
ret = 1;
|
2005-06-23 07:09:41 +00:00
|
|
|
}
|
2005-11-07 09:00:07 +00:00
|
|
|
reset_kprobe_instance();
|
|
|
|
return ret;
|
2005-06-23 07:09:41 +00:00
|
|
|
}
|
|
|
|
|
2005-12-12 08:37:34 +00:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2006-10-02 09:17:35 +00:00
|
|
|
void __kprobes recycle_rp_inst(struct kretprobe_instance *ri,
|
|
|
|
struct hlist_head *head)
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
{
|
2008-07-25 08:46:04 +00:00
|
|
|
struct kretprobe *rp = ri->rp;
|
|
|
|
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
/* remove rp inst off the rprobe_inst_table */
|
|
|
|
hlist_del(&ri->hlist);
|
2008-07-25 08:46:04 +00:00
|
|
|
INIT_HLIST_NODE(&ri->hlist);
|
|
|
|
if (likely(rp)) {
|
|
|
|
spin_lock(&rp->lock);
|
|
|
|
hlist_add_head(&ri->hlist, &rp->free_instances);
|
|
|
|
spin_unlock(&rp->lock);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
} else
|
|
|
|
/* Unregistering */
|
2006-10-02 09:17:35 +00:00
|
|
|
hlist_add_head(&ri->hlist, head);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:51 +00:00
|
|
|
void __kprobes kretprobe_hash_lock(struct task_struct *tsk,
|
2008-07-25 08:46:04 +00:00
|
|
|
struct hlist_head **head, unsigned long *flags)
|
|
|
|
{
|
|
|
|
unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
|
|
|
|
spinlock_t *hlist_lock;
|
|
|
|
|
|
|
|
*head = &kretprobe_inst_table[hash];
|
|
|
|
hlist_lock = kretprobe_table_lock_ptr(hash);
|
|
|
|
spin_lock_irqsave(hlist_lock, *flags);
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:51 +00:00
|
|
|
static void __kprobes kretprobe_table_lock(unsigned long hash,
|
|
|
|
unsigned long *flags)
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
{
|
2008-07-25 08:46:04 +00:00
|
|
|
spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
|
|
|
|
spin_lock_irqsave(hlist_lock, *flags);
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:51 +00:00
|
|
|
void __kprobes kretprobe_hash_unlock(struct task_struct *tsk,
|
|
|
|
unsigned long *flags)
|
2008-07-25 08:46:04 +00:00
|
|
|
{
|
|
|
|
unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
|
|
|
|
spinlock_t *hlist_lock;
|
|
|
|
|
|
|
|
hlist_lock = kretprobe_table_lock_ptr(hash);
|
|
|
|
spin_unlock_irqrestore(hlist_lock, *flags);
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:51 +00:00
|
|
|
void __kprobes kretprobe_table_unlock(unsigned long hash, unsigned long *flags)
|
2008-07-25 08:46:04 +00:00
|
|
|
{
|
|
|
|
spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
|
|
|
|
spin_unlock_irqrestore(hlist_lock, *flags);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-03-26 09:38:20 +00:00
|
|
|
* 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.
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
*/
|
2005-09-06 22:19:26 +00:00
|
|
|
void __kprobes kprobe_flush_task(struct task_struct *tk)
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
{
|
2006-10-02 09:17:33 +00:00
|
|
|
struct kretprobe_instance *ri;
|
2006-10-02 09:17:35 +00:00
|
|
|
struct hlist_head *head, empty_rp;
|
[PATCH] Return probe redesign: architecture independent changes
The following is the second version of the function return probe patches
I sent out earlier this week. Changes since my last submission include:
* Fix in ppc64 code removing an unneeded call to re-enable preemption
* Fix a build problem in ia64 when kprobes was turned off
* Added another BUG_ON check to each of the architecture trampoline
handlers
My initial patch description ==>
From my experiences with adding return probes to x86_64 and ia64, and the
feedback on LKML to those patches, I think we can simplify the design
for return probes.
The following patch tweaks the original design such that:
* Instead of storing the stack address in the return probe instance, the
task pointer is stored. This gives us all we need in order to:
- find the correct return probe instance when we enter the trampoline
(even if we are recursing)
- find all left-over return probe instances when the task is going away
This has the side effect of simplifying the implementation since more
work can be done in kernel/kprobes.c since architecture specific knowledge
of the stack layout is no longer required. Specifically, we no longer have:
- arch_get_kprobe_task()
- arch_kprobe_flush_task()
- get_rp_inst_tsk()
- get_rp_inst()
- trampoline_post_handler() <see next bullet>
* Instead of splitting the return probe handling and cleanup logic across
the pre and post trampoline handlers, all the work is pushed into the
pre function (trampoline_probe_handler), and then we skip single stepping
the original function. In this case the original instruction to be single
stepped was just a NOP, and we can do without the extra interruption.
The new flow of events to having a return probe handler execute when a target
function exits is:
* At system initialization time, a kprobe is inserted at the beginning of
kretprobe_trampoline. kernel/kprobes.c use to handle this on it's own,
but ia64 needed to do this a little differently (i.e. a function pointer
is really a pointer to a structure containing the instruction pointer and
a global pointer), so I added the notion of arch_init(), so that
kernel/kprobes.c:init_kprobes() now allows architecture specific
initialization by calling arch_init() before exiting. Each architecture
now registers a kprobe on it's own trampoline function.
* register_kretprobe() will insert a kprobe at the beginning of the targeted
function with the kprobe pre_handler set to arch_prepare_kretprobe
(still no change)
* When the target function is entered, the kprobe is fired, calling
arch_prepare_kretprobe (still no change)
* In arch_prepare_kretprobe() we try to get a free instance and if one is
available then we fill out the instance with a pointer to the return probe,
the original return address, and a pointer to the task structure (instead
of the stack address.) Just like before we change the return address
to the trampoline function and mark the instance as used.
If multiple return probes are registered for a given target function,
then arch_prepare_kretprobe() will get called multiple times for the same
task (since our kprobe implementation is able to handle multiple kprobes
at the same address.) Past the first call to arch_prepare_kretprobe,
we end up with the original address stored in the return probe instance
pointing to our trampoline function. (This is a significant difference
from the original arch_prepare_kretprobe design.)
* Target function executes like normal and then returns to kretprobe_trampoline.
* kprobe inserted on the first instruction of kretprobe_trampoline is fired
and calls trampoline_probe_handler() (no change here)
* trampoline_probe_handler() consumes each of the instances associated with
the current task by calling the registered handler function and marking
the instance as unused until an instance is found that has a return address
different then the trampoline function.
(change similar to my previous ia64 RFC)
* If the task is killed with some left-over return probe instances (meaning
that a target function was entered, but never returned), then we just
free any instances associated with the task. (Not much different other
then we can handle this without calling architecture specific functions.)
There is a known problem that this patch does not yet solve where
registering a return probe flush_old_exec or flush_thread will put us
in a bad state. Most likely the best way to handle this is to not allow
registering return probes on these two functions.
(Significant change)
This patch series applies to the 2.6.12-rc6-mm1 kernel, and provides:
* kernel/kprobes.c changes
* i386 patch of existing return probes implementation
* x86_64 patch of existing return probe implementation
* ia64 implementation
* ppc64 implementation (provided by Ananth)
This patch implements the architecture independant changes for a reworking
of the kprobes based function return probes design. Changes include:
* Removing functions for querying a return probe instance off a stack address
* Removing the stack_addr field from the kretprobe_instance definition,
and adding a task pointer
* Adding architecture specific initialization via arch_init()
* Removing extern definitions for the architecture trampoline functions
(this isn't needed anymore since the architecture handles the
initialization of the kprobe in the return probe trampoline function.)
Signed-off-by: Rusty Lynch <rusty.lynch@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-27 22:17:08 +00:00
|
|
|
struct hlist_node *node, *tmp;
|
2008-07-25 08:46:04 +00:00
|
|
|
unsigned long hash, flags = 0;
|
[PATCH] Return probe redesign: architecture independent changes
The following is the second version of the function return probe patches
I sent out earlier this week. Changes since my last submission include:
* Fix in ppc64 code removing an unneeded call to re-enable preemption
* Fix a build problem in ia64 when kprobes was turned off
* Added another BUG_ON check to each of the architecture trampoline
handlers
My initial patch description ==>
From my experiences with adding return probes to x86_64 and ia64, and the
feedback on LKML to those patches, I think we can simplify the design
for return probes.
The following patch tweaks the original design such that:
* Instead of storing the stack address in the return probe instance, the
task pointer is stored. This gives us all we need in order to:
- find the correct return probe instance when we enter the trampoline
(even if we are recursing)
- find all left-over return probe instances when the task is going away
This has the side effect of simplifying the implementation since more
work can be done in kernel/kprobes.c since architecture specific knowledge
of the stack layout is no longer required. Specifically, we no longer have:
- arch_get_kprobe_task()
- arch_kprobe_flush_task()
- get_rp_inst_tsk()
- get_rp_inst()
- trampoline_post_handler() <see next bullet>
* Instead of splitting the return probe handling and cleanup logic across
the pre and post trampoline handlers, all the work is pushed into the
pre function (trampoline_probe_handler), and then we skip single stepping
the original function. In this case the original instruction to be single
stepped was just a NOP, and we can do without the extra interruption.
The new flow of events to having a return probe handler execute when a target
function exits is:
* At system initialization time, a kprobe is inserted at the beginning of
kretprobe_trampoline. kernel/kprobes.c use to handle this on it's own,
but ia64 needed to do this a little differently (i.e. a function pointer
is really a pointer to a structure containing the instruction pointer and
a global pointer), so I added the notion of arch_init(), so that
kernel/kprobes.c:init_kprobes() now allows architecture specific
initialization by calling arch_init() before exiting. Each architecture
now registers a kprobe on it's own trampoline function.
* register_kretprobe() will insert a kprobe at the beginning of the targeted
function with the kprobe pre_handler set to arch_prepare_kretprobe
(still no change)
* When the target function is entered, the kprobe is fired, calling
arch_prepare_kretprobe (still no change)
* In arch_prepare_kretprobe() we try to get a free instance and if one is
available then we fill out the instance with a pointer to the return probe,
the original return address, and a pointer to the task structure (instead
of the stack address.) Just like before we change the return address
to the trampoline function and mark the instance as used.
If multiple return probes are registered for a given target function,
then arch_prepare_kretprobe() will get called multiple times for the same
task (since our kprobe implementation is able to handle multiple kprobes
at the same address.) Past the first call to arch_prepare_kretprobe,
we end up with the original address stored in the return probe instance
pointing to our trampoline function. (This is a significant difference
from the original arch_prepare_kretprobe design.)
* Target function executes like normal and then returns to kretprobe_trampoline.
* kprobe inserted on the first instruction of kretprobe_trampoline is fired
and calls trampoline_probe_handler() (no change here)
* trampoline_probe_handler() consumes each of the instances associated with
the current task by calling the registered handler function and marking
the instance as unused until an instance is found that has a return address
different then the trampoline function.
(change similar to my previous ia64 RFC)
* If the task is killed with some left-over return probe instances (meaning
that a target function was entered, but never returned), then we just
free any instances associated with the task. (Not much different other
then we can handle this without calling architecture specific functions.)
There is a known problem that this patch does not yet solve where
registering a return probe flush_old_exec or flush_thread will put us
in a bad state. Most likely the best way to handle this is to not allow
registering return probes on these two functions.
(Significant change)
This patch series applies to the 2.6.12-rc6-mm1 kernel, and provides:
* kernel/kprobes.c changes
* i386 patch of existing return probes implementation
* x86_64 patch of existing return probe implementation
* ia64 implementation
* ppc64 implementation (provided by Ananth)
This patch implements the architecture independant changes for a reworking
of the kprobes based function return probes design. Changes include:
* Removing functions for querying a return probe instance off a stack address
* Removing the stack_addr field from the kretprobe_instance definition,
and adding a task pointer
* Adding architecture specific initialization via arch_init()
* Removing extern definitions for the architecture trampoline functions
(this isn't needed anymore since the architecture handles the
initialization of the kprobe in the return probe trampoline function.)
Signed-off-by: Rusty Lynch <rusty.lynch@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-27 22:17:08 +00:00
|
|
|
|
2008-07-25 08:46:04 +00:00
|
|
|
if (unlikely(!kprobes_initialized))
|
|
|
|
/* Early boot. kretprobe_table_locks not yet initialized. */
|
|
|
|
return;
|
|
|
|
|
|
|
|
hash = hash_ptr(tk, KPROBE_HASH_BITS);
|
|
|
|
head = &kretprobe_inst_table[hash];
|
|
|
|
kretprobe_table_lock(hash, &flags);
|
2006-10-02 09:17:33 +00:00
|
|
|
hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
|
|
|
|
if (ri->task == tk)
|
2006-10-02 09:17:35 +00:00
|
|
|
recycle_rp_inst(ri, &empty_rp);
|
2006-10-02 09:17:33 +00:00
|
|
|
}
|
2008-07-25 08:46:04 +00:00
|
|
|
kretprobe_table_unlock(hash, &flags);
|
|
|
|
INIT_HLIST_HEAD(&empty_rp);
|
2006-10-02 09:17:35 +00:00
|
|
|
hlist_for_each_entry_safe(ri, node, tmp, &empty_rp, hlist) {
|
|
|
|
hlist_del(&ri->hlist);
|
|
|
|
kfree(ri);
|
|
|
|
}
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void free_rp_inst(struct kretprobe *rp)
|
|
|
|
{
|
|
|
|
struct kretprobe_instance *ri;
|
2007-05-08 07:34:14 +00:00
|
|
|
struct hlist_node *pos, *next;
|
|
|
|
|
2008-07-25 08:46:04 +00:00
|
|
|
hlist_for_each_entry_safe(ri, pos, next, &rp->free_instances, hlist) {
|
|
|
|
hlist_del(&ri->hlist);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
kfree(ri);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
static void __kprobes cleanup_rp_inst(struct kretprobe *rp)
|
|
|
|
{
|
2008-07-25 08:46:04 +00:00
|
|
|
unsigned long flags, hash;
|
2008-04-28 09:14:29 +00:00
|
|
|
struct kretprobe_instance *ri;
|
|
|
|
struct hlist_node *pos, *next;
|
2008-07-25 08:46:04 +00:00
|
|
|
struct hlist_head *head;
|
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
/* No race here */
|
2008-07-25 08:46:04 +00:00
|
|
|
for (hash = 0; hash < KPROBE_TABLE_SIZE; hash++) {
|
|
|
|
kretprobe_table_lock(hash, &flags);
|
|
|
|
head = &kretprobe_inst_table[hash];
|
|
|
|
hlist_for_each_entry_safe(ri, pos, next, head, hlist) {
|
|
|
|
if (ri->rp == rp)
|
|
|
|
ri->rp = NULL;
|
|
|
|
}
|
|
|
|
kretprobe_table_unlock(hash, &flags);
|
2008-04-28 09:14:29 +00:00
|
|
|
}
|
|
|
|
free_rp_inst(rp);
|
|
|
|
}
|
|
|
|
|
2005-06-23 07:09:41 +00:00
|
|
|
/*
|
|
|
|
* 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));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-04-07 02:00:58 +00:00
|
|
|
* Add the new probe to ap->list. Fail if this is the
|
2005-06-23 07:09:41 +00:00
|
|
|
* second jprobe at the address - two jprobes can't coexist
|
|
|
|
*/
|
2009-04-07 02:00:58 +00:00
|
|
|
static int __kprobes add_new_kprobe(struct kprobe *ap, struct kprobe *p)
|
2005-06-23 07:09:41 +00:00
|
|
|
{
|
2009-04-07 02:01:02 +00:00
|
|
|
BUG_ON(kprobe_gone(ap) || kprobe_gone(p));
|
2005-06-23 07:09:41 +00:00
|
|
|
if (p->break_handler) {
|
2009-04-07 02:00:58 +00:00
|
|
|
if (ap->break_handler)
|
2006-06-26 07:25:22 +00:00
|
|
|
return -EEXIST;
|
2009-04-07 02:00:58 +00:00
|
|
|
list_add_tail_rcu(&p->list, &ap->list);
|
|
|
|
ap->break_handler = aggr_break_handler;
|
2005-06-23 07:09:41 +00:00
|
|
|
} else
|
2009-04-07 02:00:58 +00:00
|
|
|
list_add_rcu(&p->list, &ap->list);
|
|
|
|
if (p->post_handler && !ap->post_handler)
|
|
|
|
ap->post_handler = aggr_post_handler;
|
2009-04-07 02:01:02 +00:00
|
|
|
|
|
|
|
if (kprobe_disabled(ap) && !kprobe_disabled(p)) {
|
|
|
|
ap->flags &= ~KPROBE_FLAG_DISABLED;
|
|
|
|
if (!kprobes_all_disarmed)
|
|
|
|
/* Arm the breakpoint again. */
|
2009-05-07 20:31:26 +00:00
|
|
|
arm_kprobe(ap);
|
2009-04-07 02:01:02 +00:00
|
|
|
}
|
2005-06-23 07:09:41 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-05-05 23:15:42 +00:00
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
2005-06-23 07:09:41 +00:00
|
|
|
copy_kprobe(p, ap);
|
2006-07-30 10:03:26 +00:00
|
|
|
flush_insn_slot(ap);
|
2005-05-05 23:15:42 +00:00
|
|
|
ap->addr = p->addr;
|
2009-04-07 02:00:58 +00:00
|
|
|
ap->flags = p->flags;
|
2005-05-05 23:15:42 +00:00
|
|
|
ap->pre_handler = aggr_pre_handler;
|
|
|
|
ap->fault_handler = aggr_fault_handler;
|
2009-01-06 22:41:52 +00:00
|
|
|
/* We don't care the kprobe which has gone. */
|
|
|
|
if (p->post_handler && !kprobe_gone(p))
|
2006-06-26 07:25:22 +00:00
|
|
|
ap->post_handler = aggr_post_handler;
|
2009-01-06 22:41:52 +00:00
|
|
|
if (p->break_handler && !kprobe_gone(p))
|
2006-06-26 07:25:22 +00:00
|
|
|
ap->break_handler = aggr_break_handler;
|
2005-05-05 23:15:42 +00:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&ap->list);
|
2005-11-07 09:00:13 +00:00
|
|
|
list_add_rcu(&p->list, &ap->list);
|
2005-05-05 23:15:42 +00:00
|
|
|
|
2005-12-12 08:37:12 +00:00
|
|
|
hlist_replace_rcu(&p->hlist, &ap->hlist);
|
2005-05-05 23:15:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the second or subsequent kprobe at the address - handle
|
|
|
|
* the intricacies
|
|
|
|
*/
|
2005-09-06 22:19:26 +00:00
|
|
|
static int __kprobes register_aggr_kprobe(struct kprobe *old_p,
|
|
|
|
struct kprobe *p)
|
2005-05-05 23:15:42 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2009-04-07 02:00:58 +00:00
|
|
|
struct kprobe *ap = old_p;
|
2005-05-05 23:15:42 +00:00
|
|
|
|
2009-04-07 02:00:58 +00:00
|
|
|
if (old_p->pre_handler != aggr_pre_handler) {
|
|
|
|
/* If old_p is not an aggr_probe, create new aggr_kprobe. */
|
|
|
|
ap = kzalloc(sizeof(struct kprobe), GFP_KERNEL);
|
|
|
|
if (!ap)
|
|
|
|
return -ENOMEM;
|
|
|
|
add_aggr_kprobe(ap, old_p);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (kprobe_gone(ap)) {
|
2009-01-06 22:41:52 +00:00
|
|
|
/*
|
|
|
|
* Attempting to insert new probe at the same location that
|
|
|
|
* had a probe in the module vaddr area which already
|
|
|
|
* freed. So, the instruction slot has already been
|
|
|
|
* released. We need a new slot for the new probe.
|
|
|
|
*/
|
2009-04-07 02:00:58 +00:00
|
|
|
ret = arch_prepare_kprobe(ap);
|
2009-01-06 22:41:52 +00:00
|
|
|
if (ret)
|
2009-04-07 02:00:58 +00:00
|
|
|
/*
|
|
|
|
* Even if fail to allocate new slot, don't need to
|
|
|
|
* free aggr_probe. It will be used next time, or
|
|
|
|
* freed by unregister_kprobe.
|
|
|
|
*/
|
2009-01-06 22:41:52 +00:00
|
|
|
return ret;
|
2009-04-07 02:01:02 +00:00
|
|
|
|
2009-01-06 22:41:52 +00:00
|
|
|
/*
|
2009-04-07 02:01:02 +00:00
|
|
|
* Clear gone flag to prevent allocating new slot again, and
|
|
|
|
* set disabled flag because it is not armed yet.
|
2009-01-06 22:41:52 +00:00
|
|
|
*/
|
2009-04-07 02:01:02 +00:00
|
|
|
ap->flags = (ap->flags & ~KPROBE_FLAG_GONE)
|
|
|
|
| KPROBE_FLAG_DISABLED;
|
2009-01-06 22:41:52 +00:00
|
|
|
}
|
2009-04-07 02:00:58 +00:00
|
|
|
|
|
|
|
copy_kprobe(ap, p);
|
|
|
|
return add_new_kprobe(ap, p);
|
2005-05-05 23:15:42 +00:00
|
|
|
}
|
|
|
|
|
2009-04-07 02:01:02 +00:00
|
|
|
/* Try to disable aggr_kprobe, and return 1 if succeeded.*/
|
|
|
|
static int __kprobes try_to_disable_aggr_kprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(kp, &p->list, list) {
|
|
|
|
if (!kprobe_disabled(kp))
|
|
|
|
/*
|
|
|
|
* There is an active probe on the list.
|
|
|
|
* We can't disable aggr_kprobe.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
p->flags |= KPROBE_FLAG_DISABLED;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-09-06 22:19:26 +00:00
|
|
|
static int __kprobes in_kprobes_functions(unsigned long addr)
|
|
|
|
{
|
2008-04-28 09:14:26 +00:00
|
|
|
struct kprobe_blackpoint *kb;
|
|
|
|
|
2007-05-08 07:34:13 +00:00
|
|
|
if (addr >= (unsigned long)__kprobes_text_start &&
|
|
|
|
addr < (unsigned long)__kprobes_text_end)
|
2005-09-06 22:19:26 +00:00
|
|
|
return -EINVAL;
|
2008-04-28 09:14:26 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
}
|
2005-09-06 22:19:26 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-04 22:29:44 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:53 +00:00
|
|
|
int __kprobes register_kprobe(struct kprobe *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2005-05-05 23:15:42 +00:00
|
|
|
struct kprobe *old_p;
|
2006-01-11 20:17:41 +00:00
|
|
|
struct module *probed_mod;
|
2008-03-04 22:29:44 +00:00
|
|
|
kprobe_opcode_t *addr;
|
2005-12-12 08:37:00 +00:00
|
|
|
|
2008-03-04 22:29:44 +00:00
|
|
|
addr = kprobe_addr(p);
|
|
|
|
if (!addr)
|
2006-10-02 09:17:30 +00:00
|
|
|
return -EINVAL;
|
2008-03-04 22:29:44 +00:00
|
|
|
p->addr = addr;
|
2006-10-02 09:17:30 +00:00
|
|
|
|
2008-11-12 21:26:51 +00:00
|
|
|
preempt_disable();
|
|
|
|
if (!__kernel_text_address((unsigned long) p->addr) ||
|
|
|
|
in_kprobes_functions((unsigned long) p->addr)) {
|
|
|
|
preempt_enable();
|
2005-12-12 08:37:00 +00:00
|
|
|
return -EINVAL;
|
2008-11-12 21:26:51 +00:00
|
|
|
}
|
2005-12-12 08:37:00 +00:00
|
|
|
|
2009-04-07 02:01:02 +00:00
|
|
|
/* User can pass only KPROBE_FLAG_DISABLED to register_kprobe */
|
|
|
|
p->flags &= KPROBE_FLAG_DISABLED;
|
|
|
|
|
2007-05-08 07:34:13 +00:00
|
|
|
/*
|
|
|
|
* Check if are we probing a module.
|
|
|
|
*/
|
2008-11-12 21:26:51 +00:00
|
|
|
probed_mod = __module_text_address((unsigned long) p->addr);
|
2007-05-08 07:34:13 +00:00
|
|
|
if (probed_mod) {
|
|
|
|
/*
|
2009-01-06 22:41:52 +00:00
|
|
|
* We must hold a refcount of the probed module while updating
|
|
|
|
* its code to prohibit unexpected unloading.
|
2006-01-11 20:17:41 +00:00
|
|
|
*/
|
2009-01-06 22:41:53 +00:00
|
|
|
if (unlikely(!try_module_get(probed_mod))) {
|
|
|
|
preempt_enable();
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-01-06 22:41:55 +00:00
|
|
|
/*
|
|
|
|
* If the module freed .init.text, we couldn't insert
|
|
|
|
* kprobes in there.
|
|
|
|
*/
|
|
|
|
if (within_module_init((unsigned long)p->addr, probed_mod) &&
|
|
|
|
probed_mod->state != MODULE_STATE_COMING) {
|
|
|
|
module_put(probed_mod);
|
|
|
|
preempt_enable();
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2006-01-11 20:17:41 +00:00
|
|
|
}
|
2008-11-12 21:26:51 +00:00
|
|
|
preempt_enable();
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-11-07 09:00:13 +00:00
|
|
|
p->nmissed = 0;
|
2008-04-28 09:14:28 +00:00
|
|
|
INIT_LIST_HEAD(&p->list);
|
2006-03-23 11:00:35 +00:00
|
|
|
mutex_lock(&kprobe_mutex);
|
2005-05-05 23:15:42 +00:00
|
|
|
old_p = get_kprobe(p->addr);
|
|
|
|
if (old_p) {
|
|
|
|
ret = register_aggr_kprobe(old_p, p);
|
2005-04-16 22:20:36 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-03-06 15:36:38 +00:00
|
|
|
mutex_lock(&text_mutex);
|
2007-05-08 07:34:13 +00:00
|
|
|
ret = arch_prepare_kprobe(p);
|
|
|
|
if (ret)
|
2009-03-06 15:36:38 +00:00
|
|
|
goto out_unlock_text;
|
2006-01-10 04:52:43 +00:00
|
|
|
|
2005-05-05 23:15:42 +00:00
|
|
|
INIT_HLIST_NODE(&p->hlist);
|
2005-11-07 09:00:13 +00:00
|
|
|
hlist_add_head_rcu(&p->hlist,
|
2005-04-16 22:20:36 +00:00
|
|
|
&kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
|
|
|
|
|
2009-04-07 02:01:02 +00:00
|
|
|
if (!kprobes_all_disarmed && !kprobe_disabled(p))
|
2007-05-08 07:34:16 +00:00
|
|
|
arch_arm_kprobe(p);
|
2007-10-16 08:24:07 +00:00
|
|
|
|
2009-03-06 15:36:38 +00:00
|
|
|
out_unlock_text:
|
|
|
|
mutex_unlock(&text_mutex);
|
2005-04-16 22:20:36 +00:00
|
|
|
out:
|
2006-03-23 11:00:35 +00:00
|
|
|
mutex_unlock(&kprobe_mutex);
|
2006-01-10 04:52:43 +00:00
|
|
|
|
2009-01-06 22:41:52 +00:00
|
|
|
if (probed_mod)
|
2006-01-11 20:17:41 +00:00
|
|
|
module_put(probed_mod);
|
2009-01-06 22:41:52 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_kprobe);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-07 02:01:02 +00:00
|
|
|
/* Check passed kprobe is valid and return kprobe in kprobe_table. */
|
|
|
|
static struct kprobe * __kprobes __get_valid_kprobe(struct kprobe *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-01-10 04:52:44 +00:00
|
|
|
struct kprobe *old_p, *list_p;
|
2005-05-05 23:15:42 +00:00
|
|
|
|
|
|
|
old_p = get_kprobe(p->addr);
|
2008-04-28 09:14:28 +00:00
|
|
|
if (unlikely(!old_p))
|
2009-04-07 02:01:02 +00:00
|
|
|
return NULL;
|
2008-04-28 09:14:28 +00:00
|
|
|
|
2006-01-10 04:52:44 +00:00
|
|
|
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 */
|
2009-04-07 02:01:02 +00:00
|
|
|
goto valid;
|
|
|
|
return NULL;
|
2006-01-10 04:52:44 +00:00
|
|
|
}
|
2009-04-07 02:01:02 +00:00
|
|
|
valid:
|
|
|
|
return old_p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Unregister a kprobe without a scheduler synchronization.
|
|
|
|
*/
|
|
|
|
static int __kprobes __unregister_kprobe_top(struct kprobe *p)
|
|
|
|
{
|
|
|
|
struct kprobe *old_p, *list_p;
|
|
|
|
|
|
|
|
old_p = __get_valid_kprobe(p);
|
|
|
|
if (old_p == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2007-05-08 07:34:13 +00:00
|
|
|
if (old_p == p ||
|
|
|
|
(old_p->pre_handler == aggr_pre_handler &&
|
2008-04-28 09:14:28 +00:00
|
|
|
list_is_singular(&old_p->list))) {
|
2007-05-08 07:34:16 +00:00
|
|
|
/*
|
|
|
|
* Only probe on the hash list. Disarm only if kprobes are
|
2009-01-06 22:41:52 +00:00
|
|
|
* enabled and not gone - otherwise, the breakpoint would
|
|
|
|
* already have been removed. We save on flushing icache.
|
2007-05-08 07:34:16 +00:00
|
|
|
*/
|
2009-05-07 20:31:26 +00:00
|
|
|
if (!kprobes_all_disarmed && !kprobe_disabled(old_p))
|
|
|
|
disarm_kprobe(p);
|
2006-01-10 04:52:43 +00:00
|
|
|
hlist_del_rcu(&old_p->hlist);
|
|
|
|
} else {
|
2009-01-06 22:41:52 +00:00
|
|
|
if (p->break_handler && !kprobe_gone(p))
|
2008-04-28 09:14:28 +00:00
|
|
|
old_p->break_handler = NULL;
|
2009-01-06 22:41:52 +00:00
|
|
|
if (p->post_handler && !kprobe_gone(p)) {
|
2008-04-28 09:14:28 +00:00
|
|
|
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:
|
2006-01-10 04:52:43 +00:00
|
|
|
list_del_rcu(&p->list);
|
2009-04-07 02:01:02 +00:00
|
|
|
if (!kprobe_disabled(old_p)) {
|
|
|
|
try_to_disable_aggr_kprobe(old_p);
|
|
|
|
if (!kprobes_all_disarmed && kprobe_disabled(old_p))
|
2009-05-07 20:31:26 +00:00
|
|
|
disarm_kprobe(old_p);
|
2009-04-07 02:01:02 +00:00
|
|
|
}
|
2006-01-10 04:52:43 +00:00
|
|
|
}
|
2008-04-28 09:14:28 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2005-11-07 09:00:13 +00:00
|
|
|
|
2008-04-28 09:14:28 +00:00
|
|
|
static void __kprobes __unregister_kprobe_bottom(struct kprobe *p)
|
|
|
|
{
|
|
|
|
struct kprobe *old_p;
|
2005-12-12 08:37:00 +00:00
|
|
|
|
2009-01-06 22:41:52 +00:00
|
|
|
if (list_empty(&p->list))
|
2006-01-10 04:52:46 +00:00
|
|
|
arch_remove_kprobe(p);
|
2009-01-06 22:41:52 +00:00
|
|
|
else if (list_is_singular(&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);
|
|
|
|
arch_remove_kprobe(old_p);
|
|
|
|
kfree(old_p);
|
2008-04-28 09:14:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:53 +00:00
|
|
|
int __kprobes register_kprobes(struct kprobe **kps, int num)
|
2008-04-28 09:14:28 +00:00
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
if (num <= 0)
|
|
|
|
return -EINVAL;
|
|
|
|
for (i = 0; i < num; i++) {
|
2009-01-06 22:41:53 +00:00
|
|
|
ret = register_kprobe(kps[i]);
|
2008-06-12 22:21:35 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (i > 0)
|
|
|
|
unregister_kprobes(kps, i);
|
2008-04-28 09:14:28 +00:00
|
|
|
break;
|
2006-06-26 07:25:22 +00:00
|
|
|
}
|
2006-01-10 04:52:43 +00:00
|
|
|
}
|
2008-04-28 09:14:28 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_kprobes);
|
2008-04-28 09:14:28 +00:00
|
|
|
|
|
|
|
void __kprobes unregister_kprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
unregister_kprobes(&p, 1);
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kprobe);
|
2008-04-28 09:14:28 +00:00
|
|
|
|
|
|
|
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]);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kprobes);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static struct notifier_block kprobe_exceptions_nb = {
|
2006-06-26 07:25:28 +00:00
|
|
|
.notifier_call = kprobe_exceptions_notify,
|
|
|
|
.priority = 0x7fffffff /* we need to be notified first */
|
|
|
|
};
|
|
|
|
|
2007-07-19 08:48:11 +00:00
|
|
|
unsigned long __weak arch_deref_entry_point(void *entry)
|
|
|
|
{
|
|
|
|
return (unsigned long)entry;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-01-06 22:41:53 +00:00
|
|
|
int __kprobes register_jprobes(struct jprobe **jps, int num)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-28 09:14:29 +00:00
|
|
|
struct jprobe *jp;
|
|
|
|
int ret = 0, i;
|
2007-07-19 08:48:11 +00:00
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
if (num <= 0)
|
2007-07-19 08:48:11 +00:00
|
|
|
return -EINVAL;
|
2008-04-28 09:14:29 +00:00
|
|
|
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;
|
2009-01-06 22:41:53 +00:00
|
|
|
ret = register_kprobe(&jp->kp);
|
2008-04-28 09:14:29 +00:00
|
|
|
}
|
2008-06-12 22:21:35 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (i > 0)
|
|
|
|
unregister_jprobes(jps, i);
|
2008-04-28 09:14:29 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_jprobes);
|
2007-07-19 08:48:11 +00:00
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
int __kprobes register_jprobe(struct jprobe *jp)
|
|
|
|
{
|
2009-01-06 22:41:53 +00:00
|
|
|
return register_jprobes(&jp, 1);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_jprobe);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-06 22:19:26 +00:00
|
|
|
void __kprobes unregister_jprobe(struct jprobe *jp)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2008-04-28 09:14:29 +00:00
|
|
|
unregister_jprobes(&jp, 1);
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_jprobe);
|
2008-04-28 09:14:29 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_jprobes);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-03-04 22:28:37 +00:00
|
|
|
#ifdef CONFIG_KRETPROBES
|
2006-02-03 11:03:42 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
2008-07-25 08:46:04 +00:00
|
|
|
unsigned long hash, flags = 0;
|
|
|
|
struct kretprobe_instance *ri;
|
2006-02-03 11:03:42 +00:00
|
|
|
|
|
|
|
/*TODO: consider to only swap the RA after the last pre_handler fired */
|
2008-07-25 08:46:04 +00:00
|
|
|
hash = hash_ptr(current, KPROBE_HASH_BITS);
|
|
|
|
spin_lock_irqsave(&rp->lock, flags);
|
2007-05-08 07:34:14 +00:00
|
|
|
if (!hlist_empty(&rp->free_instances)) {
|
|
|
|
ri = hlist_entry(rp->free_instances.first,
|
2008-07-25 08:46:04 +00:00
|
|
|
struct kretprobe_instance, hlist);
|
|
|
|
hlist_del(&ri->hlist);
|
|
|
|
spin_unlock_irqrestore(&rp->lock, flags);
|
|
|
|
|
2007-05-08 07:34:14 +00:00
|
|
|
ri->rp = rp;
|
|
|
|
ri->task = current;
|
2008-02-06 09:38:22 +00:00
|
|
|
|
2009-03-18 11:36:21 +00:00
|
|
|
if (rp->entry_handler && rp->entry_handler(ri, regs))
|
2008-02-06 09:38:22 +00:00
|
|
|
return 0;
|
|
|
|
|
2007-05-08 07:34:14 +00:00
|
|
|
arch_prepare_kretprobe(ri, regs);
|
|
|
|
|
|
|
|
/* XXX(hch): why is there no hlist_move_head? */
|
2008-07-25 08:46:04 +00:00
|
|
|
INIT_HLIST_NODE(&ri->hlist);
|
|
|
|
kretprobe_table_lock(hash, &flags);
|
|
|
|
hlist_add_head(&ri->hlist, &kretprobe_inst_table[hash]);
|
|
|
|
kretprobe_table_unlock(hash, &flags);
|
|
|
|
} else {
|
2007-05-08 07:34:14 +00:00
|
|
|
rp->nmissed++;
|
2008-07-25 08:46:04 +00:00
|
|
|
spin_unlock_irqrestore(&rp->lock, flags);
|
|
|
|
}
|
2006-02-03 11:03:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:41:53 +00:00
|
|
|
int __kprobes register_kretprobe(struct kretprobe *rp)
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct kretprobe_instance *inst;
|
|
|
|
int i;
|
2008-03-04 22:29:44 +00:00
|
|
|
void *addr;
|
2007-10-16 08:27:49 +00:00
|
|
|
|
|
|
|
if (kretprobe_blacklist_size) {
|
2008-03-04 22:29:44 +00:00
|
|
|
addr = kprobe_addr(&rp->kp);
|
|
|
|
if (!addr)
|
|
|
|
return -EINVAL;
|
2007-10-16 08:27:49 +00:00
|
|
|
|
|
|
|
for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
|
|
|
|
if (kretprobe_blacklist[i].addr == addr)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
|
|
|
|
rp->kp.pre_handler = pre_handler_kretprobe;
|
2006-04-20 09:43:11 +00:00
|
|
|
rp->kp.post_handler = NULL;
|
|
|
|
rp->kp.fault_handler = NULL;
|
|
|
|
rp->kp.break_handler = NULL;
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
|
|
|
|
/* 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
|
|
|
|
}
|
2008-07-25 08:46:04 +00:00
|
|
|
spin_lock_init(&rp->lock);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
INIT_HLIST_HEAD(&rp->free_instances);
|
|
|
|
for (i = 0; i < rp->maxactive; i++) {
|
2008-02-06 09:38:22 +00:00
|
|
|
inst = kmalloc(sizeof(struct kretprobe_instance) +
|
|
|
|
rp->data_size, GFP_KERNEL);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
if (inst == NULL) {
|
|
|
|
free_rp_inst(rp);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-07-25 08:46:04 +00:00
|
|
|
INIT_HLIST_NODE(&inst->hlist);
|
|
|
|
hlist_add_head(&inst->hlist, &rp->free_instances);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rp->nmissed = 0;
|
|
|
|
/* Establish function entry probe point */
|
2009-01-06 22:41:53 +00:00
|
|
|
ret = register_kprobe(&rp->kp);
|
2008-04-28 09:14:29 +00:00
|
|
|
if (ret != 0)
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
free_rp_inst(rp);
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_kretprobe);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
|
2009-01-06 22:41:53 +00:00
|
|
|
int __kprobes register_kretprobes(struct kretprobe **rps, int num)
|
2008-04-28 09:14:29 +00:00
|
|
|
{
|
|
|
|
int ret = 0, i;
|
|
|
|
|
|
|
|
if (num <= 0)
|
|
|
|
return -EINVAL;
|
|
|
|
for (i = 0; i < num; i++) {
|
2009-01-06 22:41:53 +00:00
|
|
|
ret = register_kretprobe(rps[i]);
|
2008-06-12 22:21:35 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
if (i > 0)
|
|
|
|
unregister_kretprobes(rps, i);
|
2008-04-28 09:14:29 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_kretprobes);
|
2008-04-28 09:14:29 +00:00
|
|
|
|
|
|
|
void __kprobes unregister_kretprobe(struct kretprobe *rp)
|
|
|
|
{
|
|
|
|
unregister_kretprobes(&rp, 1);
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kretprobe);
|
2008-04-28 09:14:29 +00:00
|
|
|
|
|
|
|
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]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kretprobes);
|
2008-04-28 09:14:29 +00:00
|
|
|
|
2008-03-04 22:28:37 +00:00
|
|
|
#else /* CONFIG_KRETPROBES */
|
2005-09-06 22:19:26 +00:00
|
|
|
int __kprobes register_kretprobe(struct kretprobe *rp)
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_kretprobe);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
int __kprobes register_kretprobes(struct kretprobe **rps, int num)
|
2007-02-20 21:57:54 +00:00
|
|
|
{
|
2008-04-28 09:14:29 +00:00
|
|
|
return -ENOSYS;
|
2007-02-20 21:57:54 +00:00
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(register_kretprobes);
|
|
|
|
|
2005-09-06 22:19:26 +00:00
|
|
|
void __kprobes unregister_kretprobe(struct kretprobe *rp)
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
{
|
2008-04-28 09:14:29 +00:00
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kretprobe);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
void __kprobes unregister_kretprobes(struct kretprobe **rps, int num)
|
|
|
|
{
|
|
|
|
}
|
2009-04-07 02:00:59 +00:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kretprobes);
|
2007-05-08 07:34:14 +00:00
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
static int __kprobes pre_handler_kretprobe(struct kprobe *p,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
return 0;
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
}
|
|
|
|
|
2008-04-28 09:14:29 +00:00
|
|
|
#endif /* CONFIG_KRETPROBES */
|
|
|
|
|
2009-01-06 22:41:52 +00:00
|
|
|
/* Set the kprobe gone and remove its instruction buffer. */
|
|
|
|
static void __kprobes kill_kprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
2009-04-07 02:01:02 +00:00
|
|
|
|
2009-01-06 22:41:52 +00:00
|
|
|
p->flags |= KPROBE_FLAG_GONE;
|
|
|
|
if (p->pre_handler == aggr_pre_handler) {
|
|
|
|
/*
|
|
|
|
* If this is an aggr_kprobe, we have to list all the
|
|
|
|
* chained probes and mark them GONE.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_rcu(kp, &p->list, list)
|
|
|
|
kp->flags |= KPROBE_FLAG_GONE;
|
|
|
|
p->post_handler = NULL;
|
|
|
|
p->break_handler = NULL;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Here, we can remove insn_slot safely, because no thread calls
|
|
|
|
* the original probed function (which will be freed soon) any more.
|
|
|
|
*/
|
|
|
|
arch_remove_kprobe(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Module notifier call back, checking kprobes on the module */
|
|
|
|
static int __kprobes kprobes_module_callback(struct notifier_block *nb,
|
|
|
|
unsigned long val, void *data)
|
|
|
|
{
|
|
|
|
struct module *mod = data;
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct hlist_node *node;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
2009-01-06 22:41:55 +00:00
|
|
|
int checkcore = (val == MODULE_STATE_GOING);
|
2009-01-06 22:41:52 +00:00
|
|
|
|
2009-01-06 22:41:55 +00:00
|
|
|
if (val != MODULE_STATE_GOING && val != MODULE_STATE_LIVE)
|
2009-01-06 22:41:52 +00:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
/*
|
2009-01-06 22:41:55 +00:00
|
|
|
* When MODULE_STATE_GOING was notified, both of module .text and
|
|
|
|
* .init.text sections would be freed. When MODULE_STATE_LIVE was
|
|
|
|
* notified, only .init.text section would be freed. We need to
|
|
|
|
* disable kprobes which have been inserted in the sections.
|
2009-01-06 22:41:52 +00:00
|
|
|
*/
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
|
|
|
hlist_for_each_entry_rcu(p, node, head, hlist)
|
2009-01-06 22:41:55 +00:00
|
|
|
if (within_module_init((unsigned long)p->addr, mod) ||
|
|
|
|
(checkcore &&
|
|
|
|
within_module_core((unsigned long)p->addr, mod))) {
|
2009-01-06 22:41:52 +00:00
|
|
|
/*
|
|
|
|
* The vaddr this probe is installed will soon
|
|
|
|
* be vfreed buy not synced to disk. Hence,
|
|
|
|
* disarming the breakpoint isn't needed.
|
|
|
|
*/
|
|
|
|
kill_kprobe(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block kprobe_module_nb = {
|
|
|
|
.notifier_call = kprobes_module_callback,
|
|
|
|
.priority = 0
|
|
|
|
};
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
static int __init init_kprobes(void)
|
|
|
|
{
|
|
|
|
int i, err = 0;
|
2008-04-28 09:14:26 +00:00
|
|
|
unsigned long offset = 0, size = 0;
|
|
|
|
char *modname, namebuf[128];
|
|
|
|
const char *symbol_name;
|
|
|
|
void *addr;
|
|
|
|
struct kprobe_blackpoint *kb;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* FIXME allocate the probe table, currently defined statically */
|
|
|
|
/* initialize all list heads */
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
INIT_HLIST_HEAD(&kprobe_table[i]);
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
|
2008-07-25 08:46:04 +00:00
|
|
|
spin_lock_init(&(kretprobe_table_locks[i].lock));
|
[PATCH] kprobes: function-return probes
This patch adds function-return probes to kprobes for the i386
architecture. This enables you to establish a handler to be run when a
function returns.
1. API
Two new functions are added to kprobes:
int register_kretprobe(struct kretprobe *rp);
void unregister_kretprobe(struct kretprobe *rp);
2. Registration and unregistration
2.1 Register
To register a function-return probe, the user populates the following
fields in a kretprobe object and calls register_kretprobe() with the
kretprobe address as an argument:
kp.addr - the function's address
handler - this function is run after the ret instruction executes, but
before control returns to the return address in the caller.
maxactive - The maximum number of instances of the probed function that
can be active concurrently. For example, if the function is non-
recursive and is called with a spinlock or mutex held, maxactive = 1
should be enough. If the function is non-recursive and can never
relinquish the CPU (e.g., via a semaphore or preemption), NR_CPUS should
be enough. maxactive is used to determine how many kretprobe_instance
objects to allocate for this particular probed function. If maxactive <=
0, it is set to a default value (if CONFIG_PREEMPT maxactive=max(10, 2 *
NR_CPUS) else maxactive=NR_CPUS)
For example:
struct kretprobe rp;
rp.kp.addr = /* entrypoint address */
rp.handler = /*return probe handler */
rp.maxactive = /* e.g., 1 or NR_CPUS or 0, see the above explanation */
register_kretprobe(&rp);
The following field may also be of interest:
nmissed - Initialized to zero when the function-return probe is
registered, and incremented every time the probed function is entered but
there is no kretprobe_instance object available for establishing the
function-return probe (i.e., because maxactive was set too low).
2.2 Unregister
To unregiter a function-return probe, the user calls
unregister_kretprobe() with the same kretprobe object as registered
previously. If a probed function is running when the return probe is
unregistered, the function will return as expected, but the handler won't
be run.
3. Limitations
3.1 This patch supports only the i386 architecture, but patches for
x86_64 and ppc64 are anticipated soon.
3.2 Return probes operates by replacing the return address in the stack
(or in a known register, such as the lr register for ppc). This may
cause __builtin_return_address(0), when invoked from the return-probed
function, to return the address of the return-probes trampoline.
3.3 This implementation uses the "Multiprobes at an address" feature in
2.6.12-rc3-mm3.
3.4 Due to a limitation in multi-probes, you cannot currently establish
a return probe and a jprobe on the same function. A patch to remove
this limitation is being tested.
This feature is required by SystemTap (http://sourceware.org/systemtap),
and reflects ideas contributed by several SystemTap developers, including
Will Cohen and Ananth Mavinakayanahalli.
Signed-off-by: Hien Nguyen <hien@us.ibm.com>
Signed-off-by: Prasanna S Panchamukhi <prasanna@in.ibm.com>
Signed-off-by: Frederik Deweerdt <frederik.deweerdt@laposte.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-23 07:09:19 +00:00
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-04-28 09:14:26 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
2007-10-16 08:27:49 +00:00
|
|
|
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\n",
|
|
|
|
kretprobe_blacklist[i].name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
/* By default, kprobes are armed */
|
|
|
|
kprobes_all_disarmed = false;
|
2007-05-08 07:34:16 +00:00
|
|
|
|
2005-07-06 01:54:50 +00:00
|
|
|
err = arch_init_kprobes();
|
[PATCH] Return probe redesign: architecture independent changes
The following is the second version of the function return probe patches
I sent out earlier this week. Changes since my last submission include:
* Fix in ppc64 code removing an unneeded call to re-enable preemption
* Fix a build problem in ia64 when kprobes was turned off
* Added another BUG_ON check to each of the architecture trampoline
handlers
My initial patch description ==>
From my experiences with adding return probes to x86_64 and ia64, and the
feedback on LKML to those patches, I think we can simplify the design
for return probes.
The following patch tweaks the original design such that:
* Instead of storing the stack address in the return probe instance, the
task pointer is stored. This gives us all we need in order to:
- find the correct return probe instance when we enter the trampoline
(even if we are recursing)
- find all left-over return probe instances when the task is going away
This has the side effect of simplifying the implementation since more
work can be done in kernel/kprobes.c since architecture specific knowledge
of the stack layout is no longer required. Specifically, we no longer have:
- arch_get_kprobe_task()
- arch_kprobe_flush_task()
- get_rp_inst_tsk()
- get_rp_inst()
- trampoline_post_handler() <see next bullet>
* Instead of splitting the return probe handling and cleanup logic across
the pre and post trampoline handlers, all the work is pushed into the
pre function (trampoline_probe_handler), and then we skip single stepping
the original function. In this case the original instruction to be single
stepped was just a NOP, and we can do without the extra interruption.
The new flow of events to having a return probe handler execute when a target
function exits is:
* At system initialization time, a kprobe is inserted at the beginning of
kretprobe_trampoline. kernel/kprobes.c use to handle this on it's own,
but ia64 needed to do this a little differently (i.e. a function pointer
is really a pointer to a structure containing the instruction pointer and
a global pointer), so I added the notion of arch_init(), so that
kernel/kprobes.c:init_kprobes() now allows architecture specific
initialization by calling arch_init() before exiting. Each architecture
now registers a kprobe on it's own trampoline function.
* register_kretprobe() will insert a kprobe at the beginning of the targeted
function with the kprobe pre_handler set to arch_prepare_kretprobe
(still no change)
* When the target function is entered, the kprobe is fired, calling
arch_prepare_kretprobe (still no change)
* In arch_prepare_kretprobe() we try to get a free instance and if one is
available then we fill out the instance with a pointer to the return probe,
the original return address, and a pointer to the task structure (instead
of the stack address.) Just like before we change the return address
to the trampoline function and mark the instance as used.
If multiple return probes are registered for a given target function,
then arch_prepare_kretprobe() will get called multiple times for the same
task (since our kprobe implementation is able to handle multiple kprobes
at the same address.) Past the first call to arch_prepare_kretprobe,
we end up with the original address stored in the return probe instance
pointing to our trampoline function. (This is a significant difference
from the original arch_prepare_kretprobe design.)
* Target function executes like normal and then returns to kretprobe_trampoline.
* kprobe inserted on the first instruction of kretprobe_trampoline is fired
and calls trampoline_probe_handler() (no change here)
* trampoline_probe_handler() consumes each of the instances associated with
the current task by calling the registered handler function and marking
the instance as unused until an instance is found that has a return address
different then the trampoline function.
(change similar to my previous ia64 RFC)
* If the task is killed with some left-over return probe instances (meaning
that a target function was entered, but never returned), then we just
free any instances associated with the task. (Not much different other
then we can handle this without calling architecture specific functions.)
There is a known problem that this patch does not yet solve where
registering a return probe flush_old_exec or flush_thread will put us
in a bad state. Most likely the best way to handle this is to not allow
registering return probes on these two functions.
(Significant change)
This patch series applies to the 2.6.12-rc6-mm1 kernel, and provides:
* kernel/kprobes.c changes
* i386 patch of existing return probes implementation
* x86_64 patch of existing return probe implementation
* ia64 implementation
* ppc64 implementation (provided by Ananth)
This patch implements the architecture independant changes for a reworking
of the kprobes based function return probes design. Changes include:
* Removing functions for querying a return probe instance off a stack address
* Removing the stack_addr field from the kretprobe_instance definition,
and adding a task pointer
* Adding architecture specific initialization via arch_init()
* Removing extern definitions for the architecture trampoline functions
(this isn't needed anymore since the architecture handles the
initialization of the kprobe in the return probe trampoline function.)
Signed-off-by: Rusty Lynch <rusty.lynch@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-27 22:17:08 +00:00
|
|
|
if (!err)
|
|
|
|
err = register_die_notifier(&kprobe_exceptions_nb);
|
2009-01-06 22:41:52 +00:00
|
|
|
if (!err)
|
|
|
|
err = register_module_notifier(&kprobe_module_nb);
|
|
|
|
|
2008-07-25 08:46:04 +00:00
|
|
|
kprobes_initialized = (err == 0);
|
[PATCH] Return probe redesign: architecture independent changes
The following is the second version of the function return probe patches
I sent out earlier this week. Changes since my last submission include:
* Fix in ppc64 code removing an unneeded call to re-enable preemption
* Fix a build problem in ia64 when kprobes was turned off
* Added another BUG_ON check to each of the architecture trampoline
handlers
My initial patch description ==>
From my experiences with adding return probes to x86_64 and ia64, and the
feedback on LKML to those patches, I think we can simplify the design
for return probes.
The following patch tweaks the original design such that:
* Instead of storing the stack address in the return probe instance, the
task pointer is stored. This gives us all we need in order to:
- find the correct return probe instance when we enter the trampoline
(even if we are recursing)
- find all left-over return probe instances when the task is going away
This has the side effect of simplifying the implementation since more
work can be done in kernel/kprobes.c since architecture specific knowledge
of the stack layout is no longer required. Specifically, we no longer have:
- arch_get_kprobe_task()
- arch_kprobe_flush_task()
- get_rp_inst_tsk()
- get_rp_inst()
- trampoline_post_handler() <see next bullet>
* Instead of splitting the return probe handling and cleanup logic across
the pre and post trampoline handlers, all the work is pushed into the
pre function (trampoline_probe_handler), and then we skip single stepping
the original function. In this case the original instruction to be single
stepped was just a NOP, and we can do without the extra interruption.
The new flow of events to having a return probe handler execute when a target
function exits is:
* At system initialization time, a kprobe is inserted at the beginning of
kretprobe_trampoline. kernel/kprobes.c use to handle this on it's own,
but ia64 needed to do this a little differently (i.e. a function pointer
is really a pointer to a structure containing the instruction pointer and
a global pointer), so I added the notion of arch_init(), so that
kernel/kprobes.c:init_kprobes() now allows architecture specific
initialization by calling arch_init() before exiting. Each architecture
now registers a kprobe on it's own trampoline function.
* register_kretprobe() will insert a kprobe at the beginning of the targeted
function with the kprobe pre_handler set to arch_prepare_kretprobe
(still no change)
* When the target function is entered, the kprobe is fired, calling
arch_prepare_kretprobe (still no change)
* In arch_prepare_kretprobe() we try to get a free instance and if one is
available then we fill out the instance with a pointer to the return probe,
the original return address, and a pointer to the task structure (instead
of the stack address.) Just like before we change the return address
to the trampoline function and mark the instance as used.
If multiple return probes are registered for a given target function,
then arch_prepare_kretprobe() will get called multiple times for the same
task (since our kprobe implementation is able to handle multiple kprobes
at the same address.) Past the first call to arch_prepare_kretprobe,
we end up with the original address stored in the return probe instance
pointing to our trampoline function. (This is a significant difference
from the original arch_prepare_kretprobe design.)
* Target function executes like normal and then returns to kretprobe_trampoline.
* kprobe inserted on the first instruction of kretprobe_trampoline is fired
and calls trampoline_probe_handler() (no change here)
* trampoline_probe_handler() consumes each of the instances associated with
the current task by calling the registered handler function and marking
the instance as unused until an instance is found that has a return address
different then the trampoline function.
(change similar to my previous ia64 RFC)
* If the task is killed with some left-over return probe instances (meaning
that a target function was entered, but never returned), then we just
free any instances associated with the task. (Not much different other
then we can handle this without calling architecture specific functions.)
There is a known problem that this patch does not yet solve where
registering a return probe flush_old_exec or flush_thread will put us
in a bad state. Most likely the best way to handle this is to not allow
registering return probes on these two functions.
(Significant change)
This patch series applies to the 2.6.12-rc6-mm1 kernel, and provides:
* kernel/kprobes.c changes
* i386 patch of existing return probes implementation
* x86_64 patch of existing return probe implementation
* ia64 implementation
* ppc64 implementation (provided by Ananth)
This patch implements the architecture independant changes for a reworking
of the kprobes based function return probes design. Changes include:
* Removing functions for querying a return probe instance off a stack address
* Removing the stack_addr field from the kretprobe_instance definition,
and adding a task pointer
* Adding architecture specific initialization via arch_init()
* Removing extern definitions for the architecture trampoline functions
(this isn't needed anymore since the architecture handles the
initialization of the kprobe in the return probe trampoline function.)
Signed-off-by: Rusty Lynch <rusty.lynch@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-27 22:17:08 +00:00
|
|
|
|
2008-01-30 12:32:53 +00:00
|
|
|
if (!err)
|
|
|
|
init_test_probes();
|
2005-04-16 22:20:36 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-02-20 21:57:54 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
static void __kprobes report_probe(struct seq_file *pi, struct kprobe *p,
|
2007-05-08 07:34:16 +00:00
|
|
|
const char *sym, int offset,char *modname)
|
2007-02-20 21:57:54 +00:00
|
|
|
{
|
|
|
|
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)
|
2009-04-07 02:01:02 +00:00
|
|
|
seq_printf(pi, "%p %s %s+0x%x %s %s%s\n",
|
|
|
|
p->addr, kprobe_type, sym, offset,
|
|
|
|
(modname ? modname : " "),
|
|
|
|
(kprobe_gone(p) ? "[GONE]" : ""),
|
|
|
|
((kprobe_disabled(p) && !kprobe_gone(p)) ?
|
|
|
|
"[DISABLED]" : ""));
|
2007-02-20 21:57:54 +00:00
|
|
|
else
|
2009-04-07 02:01:02 +00:00
|
|
|
seq_printf(pi, "%p %s %p %s%s\n",
|
|
|
|
p->addr, kprobe_type, p->addr,
|
|
|
|
(kprobe_gone(p) ? "[GONE]" : ""),
|
|
|
|
((kprobe_disabled(p) && !kprobe_gone(p)) ?
|
|
|
|
"[DISABLED]" : ""));
|
2007-02-20 21:57:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2007-05-08 07:28:41 +00:00
|
|
|
unsigned long offset = 0;
|
2007-02-20 21:57:54 +00:00
|
|
|
char *modname, namebuf[128];
|
|
|
|
|
|
|
|
head = &kprobe_table[i];
|
|
|
|
preempt_disable();
|
|
|
|
hlist_for_each_entry_rcu(p, node, head, hlist) {
|
2007-05-08 07:28:41 +00:00
|
|
|
sym = kallsyms_lookup((unsigned long)p->addr, NULL,
|
2007-02-20 21:57:54 +00:00
|
|
|
&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,
|
|
|
|
};
|
|
|
|
|
2009-04-07 02:01:02 +00:00
|
|
|
/* Disable one kprobe */
|
|
|
|
int __kprobes disable_kprobe(struct kprobe *kp)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct kprobe *p;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
|
|
|
/* Check whether specified probe is valid. */
|
|
|
|
p = __get_valid_kprobe(kp);
|
|
|
|
if (unlikely(p == NULL)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the probe is already disabled (or gone), just return */
|
|
|
|
if (kprobe_disabled(kp))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
kp->flags |= KPROBE_FLAG_DISABLED;
|
|
|
|
if (p != kp)
|
|
|
|
/* When kp != p, p is always enabled. */
|
|
|
|
try_to_disable_aggr_kprobe(p);
|
|
|
|
|
|
|
|
if (!kprobes_all_disarmed && kprobe_disabled(p))
|
2009-05-07 20:31:26 +00:00
|
|
|
disarm_kprobe(p);
|
2009-04-07 02:01:02 +00:00
|
|
|
out:
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(disable_kprobe);
|
|
|
|
|
|
|
|
/* Enable one kprobe */
|
|
|
|
int __kprobes enable_kprobe(struct kprobe *kp)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct kprobe *p;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
|
|
|
/* Check whether specified probe is valid. */
|
|
|
|
p = __get_valid_kprobe(kp);
|
|
|
|
if (unlikely(p == NULL)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (kprobe_gone(kp)) {
|
|
|
|
/* This kprobe has gone, we couldn't enable it. */
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!kprobes_all_disarmed && kprobe_disabled(p))
|
2009-05-07 20:31:26 +00:00
|
|
|
arm_kprobe(p);
|
2009-04-07 02:01:02 +00:00
|
|
|
|
|
|
|
p->flags &= ~KPROBE_FLAG_DISABLED;
|
|
|
|
if (p != kp)
|
|
|
|
kp->flags &= ~KPROBE_FLAG_DISABLED;
|
|
|
|
out:
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(enable_kprobe);
|
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
static void __kprobes arm_all_kprobes(void)
|
2007-05-08 07:34:16 +00:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct hlist_node *node;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
/* If kprobes are armed, just return */
|
|
|
|
if (!kprobes_all_disarmed)
|
2007-05-08 07:34:16 +00:00
|
|
|
goto already_enabled;
|
|
|
|
|
2009-03-06 15:36:38 +00:00
|
|
|
mutex_lock(&text_mutex);
|
2007-05-08 07:34:16 +00:00
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
|
|
|
hlist_for_each_entry_rcu(p, node, head, hlist)
|
2009-04-07 02:01:02 +00:00
|
|
|
if (!kprobe_disabled(p))
|
2009-01-06 22:41:52 +00:00
|
|
|
arch_arm_kprobe(p);
|
2007-05-08 07:34:16 +00:00
|
|
|
}
|
2009-03-06 15:36:38 +00:00
|
|
|
mutex_unlock(&text_mutex);
|
2007-05-08 07:34:16 +00:00
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
kprobes_all_disarmed = false;
|
2007-05-08 07:34:16 +00:00
|
|
|
printk(KERN_INFO "Kprobes globally enabled\n");
|
|
|
|
|
|
|
|
already_enabled:
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
static void __kprobes disarm_all_kprobes(void)
|
2007-05-08 07:34:16 +00:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct hlist_node *node;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
/* If kprobes are already disarmed, just return */
|
|
|
|
if (kprobes_all_disarmed)
|
2007-05-08 07:34:16 +00:00
|
|
|
goto already_disabled;
|
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
kprobes_all_disarmed = true;
|
2007-05-08 07:34:16 +00:00
|
|
|
printk(KERN_INFO "Kprobes globally disabled\n");
|
2009-03-06 15:36:38 +00:00
|
|
|
mutex_lock(&text_mutex);
|
2007-05-08 07:34:16 +00:00
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
|
|
|
hlist_for_each_entry_rcu(p, node, head, hlist) {
|
2009-04-07 02:01:02 +00:00
|
|
|
if (!arch_trampoline_kprobe(p) && !kprobe_disabled(p))
|
2007-05-08 07:34:16 +00:00
|
|
|
arch_disarm_kprobe(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-06 15:36:38 +00:00
|
|
|
mutex_unlock(&text_mutex);
|
2007-05-08 07:34:16 +00:00
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
/* Allow all currently running kprobes to complete */
|
|
|
|
synchronize_sched();
|
2007-10-16 08:24:07 +00:00
|
|
|
return;
|
2007-05-08 07:34:16 +00:00
|
|
|
|
|
|
|
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];
|
|
|
|
|
2009-04-07 02:01:01 +00:00
|
|
|
if (!kprobes_all_disarmed)
|
2007-05-08 07:34:16 +00:00
|
|
|
buf[0] = '1';
|
|
|
|
else
|
|
|
|
buf[0] = '0';
|
|
|
|
buf[1] = '\n';
|
|
|
|
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':
|
2009-04-07 02:01:01 +00:00
|
|
|
arm_all_kprobes();
|
2007-05-08 07:34:16 +00:00
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
case 'N':
|
|
|
|
case '0':
|
2009-04-07 02:01:01 +00:00
|
|
|
disarm_all_kprobes();
|
2007-05-08 07:34:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct file_operations fops_kp = {
|
|
|
|
.read = read_enabled_file_bool,
|
|
|
|
.write = write_enabled_file_bool,
|
|
|
|
};
|
|
|
|
|
2007-02-20 21:57:54 +00:00
|
|
|
static int __kprobes debugfs_kprobe_init(void)
|
|
|
|
{
|
|
|
|
struct dentry *dir, *file;
|
2007-05-08 07:34:16 +00:00
|
|
|
unsigned int value = 1;
|
2007-02-20 21:57:54 +00:00
|
|
|
|
|
|
|
dir = debugfs_create_dir("kprobes", NULL);
|
|
|
|
if (!dir)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-05-08 07:27:01 +00:00
|
|
|
file = debugfs_create_file("list", 0444, dir, NULL,
|
2007-02-20 21:57:54 +00:00
|
|
|
&debugfs_kprobes_operations);
|
|
|
|
if (!file) {
|
|
|
|
debugfs_remove(dir);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2007-05-08 07:34:16 +00:00
|
|
|
file = debugfs_create_file("enabled", 0600, dir,
|
|
|
|
&value, &fops_kp);
|
|
|
|
if (!file) {
|
|
|
|
debugfs_remove(dir);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2007-02-20 21:57:54 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(debugfs_kprobe_init);
|
|
|
|
#endif /* CONFIG_DEBUG_FS */
|
|
|
|
|
|
|
|
module_init(init_kprobes);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-04-07 02:00:59 +00:00
|
|
|
/* defined in arch/.../kernel/kprobes.c */
|
2005-04-16 22:20:36 +00:00
|
|
|
EXPORT_SYMBOL_GPL(jprobe_return);
|