2005-04-16 16:20:36 -06: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 01:09:19 -06: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 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/hash.h>
|
|
|
|
#include <linux/init.h>
|
2005-10-30 16:03:48 -07:00
|
|
|
#include <linux/slab.h>
|
2007-05-08 01:27:01 -06:00
|
|
|
#include <linux/stddef.h>
|
2011-05-23 12:51:41 -06:00
|
|
|
#include <linux/export.h>
|
2005-06-27 16:17:01 -06:00
|
|
|
#include <linux/moduleloader.h>
|
2006-10-02 03:17:30 -06:00
|
|
|
#include <linux/kallsyms.h>
|
2006-12-06 21:38:11 -07:00
|
|
|
#include <linux/freezer.h>
|
2007-02-20 14:57:54 -07:00
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/debugfs.h>
|
2010-02-25 06:34:15 -07:00
|
|
|
#include <linux/sysctl.h>
|
2007-05-08 01:27:03 -06:00
|
|
|
#include <linux/kdebug.h>
|
2009-03-06 08:36:38 -07:00
|
|
|
#include <linux/memory.h>
|
2010-02-02 14:49:18 -07:00
|
|
|
#include <linux/ftrace.h>
|
2010-02-25 06:34:07 -07:00
|
|
|
#include <linux/cpu.h>
|
2010-09-17 09:09:00 -06:00
|
|
|
#include <linux/jump_label.h>
|
2007-05-08 01:34:16 -06:00
|
|
|
|
2016-10-11 14:52:22 -06:00
|
|
|
#include <asm/sections.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/cacheflush.h>
|
|
|
|
#include <asm/errno.h>
|
2016-12-24 12:46:01 -07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define KPROBE_HASH_BITS 6
|
|
|
|
#define KPROBE_TABLE_SIZE (1 << KPROBE_HASH_BITS)
|
|
|
|
|
2006-10-02 03:17:30 -06:00
|
|
|
|
2008-07-25 02:46:04 -06:00
|
|
|
static int kprobes_initialized;
|
2005-04-16 16:20:36 -06: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 01:09:19 -06:00
|
|
|
static struct hlist_head kretprobe_inst_table[KPROBE_TABLE_SIZE];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-05-08 01:34:16 -06:00
|
|
|
/* NOTE: change this value only with kprobe_mutex held */
|
2009-04-06 20:01:01 -06:00
|
|
|
static bool kprobes_all_disarmed;
|
2007-05-08 01:34:16 -06:00
|
|
|
|
2010-10-25 07:18:01 -06:00
|
|
|
/* This protects kprobe_table and optimizing_list */
|
|
|
|
static DEFINE_MUTEX(kprobe_mutex);
|
2005-11-07 02:00:07 -07:00
|
|
|
static DEFINE_PER_CPU(struct kprobe *, kprobe_instance) = NULL;
|
2008-07-25 02:46:04 -06:00
|
|
|
static struct {
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spinlock_t lock ____cacheline_aligned_in_smp;
|
2008-07-25 02:46:04 -06:00
|
|
|
} kretprobe_table_locks[KPROBE_TABLE_SIZE];
|
|
|
|
|
2017-04-19 06:51:01 -06:00
|
|
|
kprobe_opcode_t * __weak kprobe_lookup_name(const char *name,
|
|
|
|
unsigned int __unused)
|
2017-04-19 06:51:00 -06:00
|
|
|
{
|
|
|
|
return ((kprobe_opcode_t *)(kallsyms_lookup_name(name)));
|
|
|
|
}
|
|
|
|
|
2009-07-25 08:09:17 -06:00
|
|
|
static raw_spinlock_t *kretprobe_table_lock_ptr(unsigned long hash)
|
2008-07-25 02:46:04 -06:00
|
|
|
{
|
|
|
|
return &(kretprobe_table_locks[hash].lock);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-04-17 02:17:05 -06:00
|
|
|
/* Blacklist -- list of struct kprobe_blacklist_entry */
|
|
|
|
static LIST_HEAD(kprobe_blacklist);
|
2008-04-28 03:14:26 -06:00
|
|
|
|
2006-01-09 21:52:41 -07:00
|
|
|
#ifdef __ARCH_WANT_KPROBES_INSN_SLOT
|
2005-06-27 16:17:01 -06: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
|
|
|
|
*/
|
|
|
|
struct kprobe_insn_page {
|
2009-06-30 15:08:14 -06:00
|
|
|
struct list_head list;
|
2005-06-27 16:17:01 -06:00
|
|
|
kprobe_opcode_t *insns; /* Page of instruction slots */
|
2013-09-11 15:24:13 -06:00
|
|
|
struct kprobe_insn_cache *cache;
|
2005-06-27 16:17:01 -06:00
|
|
|
int nused;
|
2006-12-06 21:38:11 -07:00
|
|
|
int ngarbage;
|
2010-02-25 06:33:59 -07:00
|
|
|
char slot_used[];
|
2005-06-27 16:17:01 -06:00
|
|
|
};
|
|
|
|
|
2010-02-25 06:33:59 -07:00
|
|
|
#define KPROBE_INSN_PAGE_SIZE(slots) \
|
|
|
|
(offsetof(struct kprobe_insn_page, slot_used) + \
|
|
|
|
(sizeof(char) * (slots)))
|
|
|
|
|
|
|
|
static int slots_per_page(struct kprobe_insn_cache *c)
|
|
|
|
{
|
|
|
|
return PAGE_SIZE/(c->insn_size * sizeof(kprobe_opcode_t));
|
|
|
|
}
|
|
|
|
|
2007-01-30 15:36:06 -07:00
|
|
|
enum kprobe_slot_state {
|
|
|
|
SLOT_CLEAN = 0,
|
|
|
|
SLOT_DIRTY = 1,
|
|
|
|
SLOT_USED = 2,
|
|
|
|
};
|
|
|
|
|
2013-09-11 15:24:13 -06:00
|
|
|
static void *alloc_insn_page(void)
|
|
|
|
{
|
|
|
|
return module_alloc(PAGE_SIZE);
|
|
|
|
}
|
|
|
|
|
2017-05-25 04:38:17 -06:00
|
|
|
void __weak free_insn_page(void *page)
|
2013-09-11 15:24:13 -06:00
|
|
|
{
|
2015-01-19 15:37:05 -07:00
|
|
|
module_memfree(page);
|
2013-09-11 15:24:13 -06:00
|
|
|
}
|
|
|
|
|
2013-09-11 15:24:11 -06:00
|
|
|
struct kprobe_insn_cache kprobe_insn_slots = {
|
|
|
|
.mutex = __MUTEX_INITIALIZER(kprobe_insn_slots.mutex),
|
2013-09-11 15:24:13 -06:00
|
|
|
.alloc = alloc_insn_page,
|
|
|
|
.free = free_insn_page,
|
2010-02-25 06:33:59 -07:00
|
|
|
.pages = LIST_HEAD_INIT(kprobe_insn_slots.pages),
|
|
|
|
.insn_size = MAX_INSN_SIZE,
|
|
|
|
.nr_garbage = 0,
|
|
|
|
};
|
2014-04-17 02:17:54 -06:00
|
|
|
static int collect_garbage_slots(struct kprobe_insn_cache *c);
|
2006-12-06 21:38:11 -07:00
|
|
|
|
2005-06-27 16:17:01 -06:00
|
|
|
/**
|
2009-01-06 15:41:50 -07:00
|
|
|
* __get_insn_slot() - Find a slot on an executable page for an instruction.
|
2005-06-27 16:17:01 -06:00
|
|
|
* We allocate an executable page if there's no room on existing ones.
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
kprobe_opcode_t *__get_insn_slot(struct kprobe_insn_cache *c)
|
2005-06-27 16:17:01 -06:00
|
|
|
{
|
|
|
|
struct kprobe_insn_page *kip;
|
2013-09-11 15:24:11 -06:00
|
|
|
kprobe_opcode_t *slot = NULL;
|
2005-06-27 16:17:01 -06:00
|
|
|
|
2017-01-08 07:58:09 -07:00
|
|
|
/* Since the slot array is not protected by rcu, we need a mutex */
|
2013-09-11 15:24:11 -06:00
|
|
|
mutex_lock(&c->mutex);
|
2007-05-08 01:34:13 -06:00
|
|
|
retry:
|
2017-01-08 07:58:09 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(kip, &c->pages, list) {
|
2010-02-25 06:33:59 -07:00
|
|
|
if (kip->nused < slots_per_page(c)) {
|
2005-06-27 16:17:01 -06:00
|
|
|
int i;
|
2010-02-25 06:33:59 -07:00
|
|
|
for (i = 0; i < slots_per_page(c); i++) {
|
2007-01-30 15:36:06 -07:00
|
|
|
if (kip->slot_used[i] == SLOT_CLEAN) {
|
|
|
|
kip->slot_used[i] = SLOT_USED;
|
2005-06-27 16:17:01 -06:00
|
|
|
kip->nused++;
|
2013-09-11 15:24:11 -06:00
|
|
|
slot = kip->insns + (i * c->insn_size);
|
2017-01-08 07:58:09 -07:00
|
|
|
rcu_read_unlock();
|
2013-09-11 15:24:11 -06:00
|
|
|
goto out;
|
2005-06-27 16:17:01 -06:00
|
|
|
}
|
|
|
|
}
|
2010-02-25 06:33:59 -07:00
|
|
|
/* kip->nused is broken. Fix it. */
|
|
|
|
kip->nused = slots_per_page(c);
|
|
|
|
WARN_ON(1);
|
2005-06-27 16:17:01 -06:00
|
|
|
}
|
|
|
|
}
|
2017-01-08 07:58:09 -07:00
|
|
|
rcu_read_unlock();
|
2005-06-27 16:17:01 -06:00
|
|
|
|
2006-12-06 21:38:11 -07:00
|
|
|
/* If there are any garbage slots, collect it and try again. */
|
2010-02-25 06:33:59 -07:00
|
|
|
if (c->nr_garbage && collect_garbage_slots(c) == 0)
|
2006-12-06 21:38:11 -07:00
|
|
|
goto retry;
|
2010-02-25 06:33:59 -07:00
|
|
|
|
|
|
|
/* All out of space. Need to allocate a new page. */
|
|
|
|
kip = kmalloc(KPROBE_INSN_PAGE_SIZE(slots_per_page(c)), GFP_KERNEL);
|
2007-05-08 01:34:13 -06:00
|
|
|
if (!kip)
|
2013-09-11 15:24:11 -06:00
|
|
|
goto out;
|
2005-06-27 16:17:01 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2013-09-11 15:24:13 -06:00
|
|
|
kip->insns = c->alloc();
|
2005-06-27 16:17:01 -06:00
|
|
|
if (!kip->insns) {
|
|
|
|
kfree(kip);
|
2013-09-11 15:24:11 -06:00
|
|
|
goto out;
|
2005-06-27 16:17:01 -06:00
|
|
|
}
|
2009-06-30 15:08:14 -06:00
|
|
|
INIT_LIST_HEAD(&kip->list);
|
2010-02-25 06:33:59 -07:00
|
|
|
memset(kip->slot_used, SLOT_CLEAN, slots_per_page(c));
|
2007-01-30 15:36:06 -07:00
|
|
|
kip->slot_used[0] = SLOT_USED;
|
2005-06-27 16:17:01 -06:00
|
|
|
kip->nused = 1;
|
2006-12-06 21:38:11 -07:00
|
|
|
kip->ngarbage = 0;
|
2013-09-11 15:24:13 -06:00
|
|
|
kip->cache = c;
|
2017-01-08 07:58:09 -07:00
|
|
|
list_add_rcu(&kip->list, &c->pages);
|
2013-09-11 15:24:11 -06:00
|
|
|
slot = kip->insns;
|
|
|
|
out:
|
|
|
|
mutex_unlock(&c->mutex);
|
|
|
|
return slot;
|
2009-01-06 15:41:50 -07:00
|
|
|
}
|
|
|
|
|
2006-12-06 21:38:11 -07:00
|
|
|
/* Return 1 if all garbages are collected, otherwise 0. */
|
2014-04-17 02:17:54 -06:00
|
|
|
static int collect_one_slot(struct kprobe_insn_page *kip, int idx)
|
2006-12-06 21:38:11 -07:00
|
|
|
{
|
2007-01-30 15:36:06 -07:00
|
|
|
kip->slot_used[idx] = SLOT_CLEAN;
|
2006-12-06 21:38:11 -07: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.
|
|
|
|
*/
|
2010-02-25 06:33:59 -07:00
|
|
|
if (!list_is_singular(&kip->list)) {
|
2017-01-08 07:58:09 -07:00
|
|
|
list_del_rcu(&kip->list);
|
|
|
|
synchronize_rcu();
|
2013-09-11 15:24:13 -06:00
|
|
|
kip->cache->free(kip->insns);
|
2006-12-06 21:38:11 -07:00
|
|
|
kfree(kip);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static int collect_garbage_slots(struct kprobe_insn_cache *c)
|
2006-12-06 21:38:11 -07:00
|
|
|
{
|
2009-06-30 15:08:14 -06:00
|
|
|
struct kprobe_insn_page *kip, *next;
|
2006-12-06 21:38:11 -07:00
|
|
|
|
2010-02-02 14:49:04 -07:00
|
|
|
/* Ensure no-one is interrupted on the garbages */
|
|
|
|
synchronize_sched();
|
2006-12-06 21:38:11 -07:00
|
|
|
|
2010-02-25 06:33:59 -07:00
|
|
|
list_for_each_entry_safe(kip, next, &c->pages, list) {
|
2006-12-06 21:38:11 -07:00
|
|
|
int i;
|
|
|
|
if (kip->ngarbage == 0)
|
|
|
|
continue;
|
|
|
|
kip->ngarbage = 0; /* we will collect all garbages */
|
2010-02-25 06:33:59 -07:00
|
|
|
for (i = 0; i < slots_per_page(c); i++) {
|
2017-01-08 07:58:09 -07:00
|
|
|
if (kip->slot_used[i] == SLOT_DIRTY && collect_one_slot(kip, i))
|
2006-12-06 21:38:11 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-02-25 06:33:59 -07:00
|
|
|
c->nr_garbage = 0;
|
2006-12-06 21:38:11 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void __free_insn_slot(struct kprobe_insn_cache *c,
|
|
|
|
kprobe_opcode_t *slot, int dirty)
|
2005-06-27 16:17:01 -06:00
|
|
|
{
|
|
|
|
struct kprobe_insn_page *kip;
|
2017-01-08 07:58:09 -07:00
|
|
|
long idx;
|
2005-06-27 16:17:01 -06:00
|
|
|
|
2013-09-11 15:24:11 -06:00
|
|
|
mutex_lock(&c->mutex);
|
2017-01-08 07:58:09 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(kip, &c->pages, list) {
|
|
|
|
idx = ((long)slot - (long)kip->insns) /
|
|
|
|
(c->insn_size * sizeof(kprobe_opcode_t));
|
|
|
|
if (idx >= 0 && idx < slots_per_page(c))
|
2013-09-11 15:24:11 -06:00
|
|
|
goto out;
|
2005-06-27 16:17:01 -06:00
|
|
|
}
|
2017-01-08 07:58:09 -07:00
|
|
|
/* Could not find this slot. */
|
2010-02-25 06:33:59 -07:00
|
|
|
WARN_ON(1);
|
2017-01-08 07:58:09 -07:00
|
|
|
kip = NULL;
|
2013-09-11 15:24:11 -06:00
|
|
|
out:
|
2017-01-08 07:58:09 -07:00
|
|
|
rcu_read_unlock();
|
|
|
|
/* Mark and sweep: this may sleep */
|
|
|
|
if (kip) {
|
|
|
|
/* Check double free */
|
|
|
|
WARN_ON(kip->slot_used[idx] != SLOT_USED);
|
|
|
|
if (dirty) {
|
|
|
|
kip->slot_used[idx] = SLOT_DIRTY;
|
|
|
|
kip->ngarbage++;
|
|
|
|
if (++c->nr_garbage > slots_per_page(c))
|
|
|
|
collect_garbage_slots(c);
|
|
|
|
} else {
|
|
|
|
collect_one_slot(kip, idx);
|
|
|
|
}
|
|
|
|
}
|
2013-09-11 15:24:11 -06:00
|
|
|
mutex_unlock(&c->mutex);
|
2010-02-25 06:33:59 -07:00
|
|
|
}
|
2007-05-08 01:34:13 -06:00
|
|
|
|
2017-01-08 07:58:09 -07:00
|
|
|
/*
|
|
|
|
* Check given address is on the page of kprobe instruction slots.
|
|
|
|
* This will be used for checking whether the address on a stack
|
|
|
|
* is on a text area or not.
|
|
|
|
*/
|
|
|
|
bool __is_insn_slot_addr(struct kprobe_insn_cache *c, unsigned long addr)
|
|
|
|
{
|
|
|
|
struct kprobe_insn_page *kip;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(kip, &c->pages, list) {
|
|
|
|
if (addr >= (unsigned long)kip->insns &&
|
|
|
|
addr < (unsigned long)kip->insns + PAGE_SIZE) {
|
|
|
|
ret = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
#ifdef CONFIG_OPTPROBES
|
|
|
|
/* For optimized_kprobe buffer */
|
2013-09-11 15:24:11 -06:00
|
|
|
struct kprobe_insn_cache kprobe_optinsn_slots = {
|
|
|
|
.mutex = __MUTEX_INITIALIZER(kprobe_optinsn_slots.mutex),
|
2013-09-11 15:24:13 -06:00
|
|
|
.alloc = alloc_insn_page,
|
|
|
|
.free = free_insn_page,
|
2010-02-25 06:34:07 -07:00
|
|
|
.pages = LIST_HEAD_INIT(kprobe_optinsn_slots.pages),
|
|
|
|
/* .insn_size is initialized later */
|
|
|
|
.nr_garbage = 0,
|
|
|
|
};
|
|
|
|
#endif
|
2006-01-09 21:52:41 -07:00
|
|
|
#endif
|
2005-06-27 16:17:01 -06:00
|
|
|
|
2005-11-07 02:00:07 -07:00
|
|
|
/* We have preemption disabled.. so it is safe to use __ versions */
|
|
|
|
static inline void set_kprobe_instance(struct kprobe *kp)
|
|
|
|
{
|
2010-12-06 10:16:25 -07:00
|
|
|
__this_cpu_write(kprobe_instance, kp);
|
2005-11-07 02:00:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void reset_kprobe_instance(void)
|
|
|
|
{
|
2010-12-06 10:16:25 -07:00
|
|
|
__this_cpu_write(kprobe_instance, NULL);
|
2005-11-07 02:00:07 -07:00
|
|
|
}
|
|
|
|
|
2005-11-07 02:00:13 -07:00
|
|
|
/*
|
|
|
|
* This routine is called either:
|
2006-01-09 21:52:43 -07:00
|
|
|
* - under the kprobe_mutex - during kprobe_[un]register()
|
2005-11-07 02:00:13 -07:00
|
|
|
* OR
|
2005-11-07 02:00:14 -07:00
|
|
|
* - with preemption disabled - from arch/xxx/kernel/kprobes.c
|
2005-11-07 02:00:13 -07:00
|
|
|
*/
|
2014-04-17 02:18:21 -06:00
|
|
|
struct kprobe *get_kprobe(void *addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
2005-11-07 02:00:13 -07:00
|
|
|
struct kprobe *p;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(p, head, hlist) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (p->addr == addr)
|
|
|
|
return p;
|
|
|
|
}
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(get_kprobe);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
/* Return true if the kprobe is an aggregator */
|
|
|
|
static inline int kprobe_aggrprobe(struct kprobe *p)
|
|
|
|
{
|
|
|
|
return p->pre_handler == aggr_pre_handler;
|
|
|
|
}
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Return true(!0) if the kprobe is unused */
|
|
|
|
static inline int kprobe_unused(struct kprobe *p)
|
|
|
|
{
|
|
|
|
return kprobe_aggrprobe(p) && kprobe_disabled(p) &&
|
|
|
|
list_empty(&p->list);
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/*
|
|
|
|
* Keep all fields in the kprobe consistent
|
|
|
|
*/
|
2010-12-03 02:53:50 -07:00
|
|
|
static inline void copy_kprobe(struct kprobe *ap, struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
2010-12-03 02:53:50 -07:00
|
|
|
memcpy(&p->opcode, &ap->opcode, sizeof(kprobe_opcode_t));
|
|
|
|
memcpy(&p->ainsn, &ap->ainsn, sizeof(struct arch_specific_insn));
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_OPTPROBES
|
2010-02-25 06:34:15 -07:00
|
|
|
/* NOTE: change this value only with kprobe_mutex held */
|
|
|
|
static bool kprobes_allow_optimization;
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/*
|
|
|
|
* Call all pre_handler on the list, but ignores its return value.
|
|
|
|
* This must be called from arch-dep optimized caller.
|
|
|
|
*/
|
2014-04-17 02:18:21 -06:00
|
|
|
void opt_pre_handler(struct kprobe *p, struct pt_regs *regs)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(kp, &p->list, list) {
|
|
|
|
if (kp->pre_handler && likely(!kprobe_disabled(kp))) {
|
|
|
|
set_kprobe_instance(kp);
|
|
|
|
kp->pre_handler(kp, regs);
|
|
|
|
}
|
|
|
|
reset_kprobe_instance();
|
|
|
|
}
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(opt_pre_handler);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Free optimized instructions and optimized_kprobe */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void free_aggr_kprobe(struct kprobe *p)
|
2010-12-03 02:54:09 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
|
|
|
arch_remove_optimized_kprobe(op);
|
|
|
|
arch_remove_kprobe(p);
|
|
|
|
kfree(op);
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Return true(!0) if the kprobe is ready for optimization. */
|
|
|
|
static inline int kprobe_optready(struct kprobe *p)
|
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
if (kprobe_aggrprobe(p)) {
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
|
|
|
return arch_prepared_optinsn(&op->optinsn);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Return true(!0) if the kprobe is disarmed. Note: p must be on hash list */
|
|
|
|
static inline int kprobe_disarmed(struct kprobe *p)
|
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
/* If kprobe is not aggr/opt probe, just return kprobe is disabled */
|
|
|
|
if (!kprobe_aggrprobe(p))
|
|
|
|
return kprobe_disabled(p);
|
|
|
|
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
|
|
|
|
|
|
|
return kprobe_disabled(p) && list_empty(&op->list);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return true(!0) if the probe is queued on (un)optimizing lists */
|
2014-04-17 02:17:54 -06:00
|
|
|
static int kprobe_queued(struct kprobe *p)
|
2010-12-03 02:54:09 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
if (kprobe_aggrprobe(p)) {
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
|
|
|
if (!list_empty(&op->list))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/*
|
|
|
|
* Return an optimized kprobe whose optimizing code replaces
|
|
|
|
* instructions including addr (exclude breakpoint).
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static struct kprobe *get_optimized_kprobe(unsigned long addr)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct kprobe *p = NULL;
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
/* Don't check i == 0, since that is a breakpoint case. */
|
|
|
|
for (i = 1; !p && i < MAX_OPTIMIZED_LENGTH; i++)
|
|
|
|
p = get_kprobe((void *)(addr - i));
|
|
|
|
|
|
|
|
if (p && kprobe_optready(p)) {
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
|
|
|
if (arch_within_optimized_kprobe(op, addr))
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Optimization staging list, protected by kprobe_mutex */
|
|
|
|
static LIST_HEAD(optimizing_list);
|
2010-12-03 02:54:09 -07:00
|
|
|
static LIST_HEAD(unoptimizing_list);
|
2013-05-22 03:34:09 -06:00
|
|
|
static LIST_HEAD(freeing_list);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
static void kprobe_optimizer(struct work_struct *work);
|
|
|
|
static DECLARE_DELAYED_WORK(optimizing_work, kprobe_optimizer);
|
|
|
|
#define OPTIMIZE_DELAY 5
|
|
|
|
|
2010-12-03 02:54:03 -07:00
|
|
|
/*
|
|
|
|
* Optimize (replace a breakpoint with a jump) kprobes listed on
|
|
|
|
* optimizing_list.
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static void do_optimize_kprobes(void)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Optimization never be done when disarmed */
|
|
|
|
if (kprobes_all_disarmed || !kprobes_allow_optimization ||
|
|
|
|
list_empty(&optimizing_list))
|
|
|
|
return;
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/*
|
|
|
|
* The optimization/unoptimization refers online_cpus via
|
|
|
|
* stop_machine() and cpu-hotplug modifies online_cpus.
|
|
|
|
* And same time, text_mutex will be held in cpu-hotplug and here.
|
|
|
|
* This combination can cause a deadlock (cpu-hotplug try to lock
|
|
|
|
* text_mutex but stop_machine can not be done because online_cpus
|
|
|
|
* has been changed)
|
|
|
|
* To avoid this deadlock, we need to call get_online_cpus()
|
|
|
|
* for preventing cpu-hotplug outside of text_mutex locking.
|
|
|
|
*/
|
|
|
|
get_online_cpus();
|
|
|
|
mutex_lock(&text_mutex);
|
2010-12-03 02:54:28 -07:00
|
|
|
arch_optimize_kprobes(&optimizing_list);
|
2010-02-25 06:34:07 -07:00
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
put_online_cpus();
|
2010-12-03 02:54:03 -07:00
|
|
|
}
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/*
|
|
|
|
* Unoptimize (replace a jump with a breakpoint and remove the breakpoint
|
|
|
|
* if need) kprobes listed on unoptimizing_list.
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static void do_unoptimize_kprobes(void)
|
2010-12-03 02:54:09 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op, *tmp;
|
|
|
|
|
|
|
|
/* Unoptimization must be done anytime */
|
|
|
|
if (list_empty(&unoptimizing_list))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Ditto to do_optimize_kprobes */
|
|
|
|
get_online_cpus();
|
|
|
|
mutex_lock(&text_mutex);
|
2013-05-22 03:34:09 -06:00
|
|
|
arch_unoptimize_kprobes(&unoptimizing_list, &freeing_list);
|
2010-12-03 02:54:34 -07:00
|
|
|
/* Loop free_list for disarming */
|
2013-05-22 03:34:09 -06:00
|
|
|
list_for_each_entry_safe(op, tmp, &freeing_list, list) {
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Disarm probes if marked disabled */
|
|
|
|
if (kprobe_disabled(&op->kp))
|
|
|
|
arch_disarm_kprobe(&op->kp);
|
|
|
|
if (kprobe_unused(&op->kp)) {
|
|
|
|
/*
|
|
|
|
* Remove unused probes from hash list. After waiting
|
|
|
|
* for synchronization, these probes are reclaimed.
|
|
|
|
* (reclaiming is done by do_free_cleaned_kprobes.)
|
|
|
|
*/
|
|
|
|
hlist_del_rcu(&op->kp.hlist);
|
|
|
|
} else
|
|
|
|
list_del_init(&op->list);
|
|
|
|
}
|
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
put_online_cpus();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reclaim all kprobes on the free_list */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void do_free_cleaned_kprobes(void)
|
2010-12-03 02:54:09 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op, *tmp;
|
|
|
|
|
2013-05-22 03:34:09 -06:00
|
|
|
list_for_each_entry_safe(op, tmp, &freeing_list, list) {
|
2010-12-03 02:54:09 -07:00
|
|
|
BUG_ON(!kprobe_unused(&op->kp));
|
|
|
|
list_del_init(&op->list);
|
|
|
|
free_aggr_kprobe(&op->kp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Start optimizer after OPTIMIZE_DELAY passed */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void kick_kprobe_optimizer(void)
|
2010-12-03 02:54:09 -07:00
|
|
|
{
|
2012-12-21 18:57:00 -07:00
|
|
|
schedule_delayed_work(&optimizing_work, OPTIMIZE_DELAY);
|
2010-12-03 02:54:09 -07:00
|
|
|
}
|
|
|
|
|
2010-12-03 02:54:03 -07:00
|
|
|
/* Kprobe jump optimizer */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void kprobe_optimizer(struct work_struct *work)
|
2010-12-03 02:54:03 -07:00
|
|
|
{
|
2012-06-05 04:28:14 -06:00
|
|
|
mutex_lock(&kprobe_mutex);
|
2010-12-03 02:54:03 -07:00
|
|
|
/* Lock modules while optimizing kprobes */
|
|
|
|
mutex_lock(&module_mutex);
|
|
|
|
|
|
|
|
/*
|
2010-12-03 02:54:09 -07:00
|
|
|
* Step 1: Unoptimize kprobes and collect cleaned (unused and disarmed)
|
|
|
|
* kprobes before waiting for quiesence period.
|
|
|
|
*/
|
2013-05-22 03:34:09 -06:00
|
|
|
do_unoptimize_kprobes();
|
2010-12-03 02:54:09 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Step 2: Wait for quiesence period to ensure all running interrupts
|
2010-12-03 02:54:03 -07:00
|
|
|
* are done. Because optprobe may modify multiple instructions
|
|
|
|
* there is a chance that Nth instruction is interrupted. In that
|
|
|
|
* case, running interrupt can return to 2nd-Nth byte of jump
|
|
|
|
* instruction. This wait is for avoiding it.
|
|
|
|
*/
|
|
|
|
synchronize_sched();
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Step 3: Optimize kprobes after quiesence period */
|
2010-12-03 02:54:03 -07:00
|
|
|
do_optimize_kprobes();
|
2010-12-03 02:54:09 -07:00
|
|
|
|
|
|
|
/* Step 4: Free cleaned kprobes after quiesence period */
|
2013-05-22 03:34:09 -06:00
|
|
|
do_free_cleaned_kprobes();
|
2010-12-03 02:54:09 -07:00
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
mutex_unlock(&module_mutex);
|
2012-06-05 04:28:14 -06:00
|
|
|
mutex_unlock(&kprobe_mutex);
|
2010-12-03 02:54:09 -07:00
|
|
|
|
2010-12-03 02:54:28 -07:00
|
|
|
/* Step 5: Kick optimizer again if needed */
|
2010-12-03 02:54:34 -07:00
|
|
|
if (!list_empty(&optimizing_list) || !list_empty(&unoptimizing_list))
|
2010-12-03 02:54:28 -07:00
|
|
|
kick_kprobe_optimizer();
|
2010-12-03 02:54:09 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait for completing optimization and unoptimization */
|
2017-05-17 02:19:49 -06:00
|
|
|
void wait_for_kprobe_optimizer(void)
|
2010-12-03 02:54:09 -07:00
|
|
|
{
|
2012-12-21 18:57:00 -07:00
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
|
|
|
while (!list_empty(&optimizing_list) || !list_empty(&unoptimizing_list)) {
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
|
|
|
|
/* this will also make optimizing_work execute immmediately */
|
|
|
|
flush_delayed_work(&optimizing_work);
|
|
|
|
/* @optimizing_work might not have been queued yet, relax */
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Optimize kprobe if p is ready to be optimized */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void optimize_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
/* Check if the kprobe is disabled or not ready for optimization. */
|
2010-02-25 06:34:15 -07:00
|
|
|
if (!kprobe_optready(p) || !kprobes_allow_optimization ||
|
2010-02-25 06:34:07 -07:00
|
|
|
(kprobe_disabled(p) || kprobes_all_disarmed))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Both of break_handler and post_handler are not supported. */
|
|
|
|
if (p->break_handler || p->post_handler)
|
|
|
|
return;
|
|
|
|
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
|
|
|
|
|
|
|
/* Check there is no other kprobes at the optimized instructions */
|
|
|
|
if (arch_check_optimized_kprobe(op) < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Check if it is already optimized. */
|
|
|
|
if (op->kp.flags & KPROBE_FLAG_OPTIMIZED)
|
|
|
|
return;
|
|
|
|
op->kp.flags |= KPROBE_FLAG_OPTIMIZED;
|
2010-12-03 02:54:09 -07:00
|
|
|
|
|
|
|
if (!list_empty(&op->list))
|
|
|
|
/* This is under unoptimizing. Just dequeue the probe */
|
|
|
|
list_del_init(&op->list);
|
|
|
|
else {
|
|
|
|
list_add(&op->list, &optimizing_list);
|
|
|
|
kick_kprobe_optimizer();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Short cut to direct unoptimizing */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void force_unoptimize_kprobe(struct optimized_kprobe *op)
|
2010-12-03 02:54:09 -07:00
|
|
|
{
|
|
|
|
get_online_cpus();
|
|
|
|
arch_unoptimize_kprobe(op);
|
|
|
|
put_online_cpus();
|
|
|
|
if (kprobe_disabled(&op->kp))
|
|
|
|
arch_disarm_kprobe(&op->kp);
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Unoptimize a kprobe if p is optimized */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void unoptimize_kprobe(struct kprobe *p, bool force)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
if (!kprobe_aggrprobe(p) || kprobe_disarmed(p))
|
|
|
|
return; /* This is not an optprobe nor optimized */
|
|
|
|
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
|
|
|
if (!kprobe_optimized(p)) {
|
|
|
|
/* Unoptimized or unoptimizing case */
|
|
|
|
if (force && !list_empty(&op->list)) {
|
|
|
|
/*
|
|
|
|
* Only if this is unoptimizing kprobe and forced,
|
|
|
|
* forcibly unoptimize it. (No need to unoptimize
|
|
|
|
* unoptimized kprobe again :)
|
|
|
|
*/
|
2010-02-25 06:34:07 -07:00
|
|
|
list_del_init(&op->list);
|
2010-12-03 02:54:09 -07:00
|
|
|
force_unoptimize_kprobe(op);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
|
|
|
|
if (!list_empty(&op->list)) {
|
|
|
|
/* Dequeue from the optimization queue */
|
|
|
|
list_del_init(&op->list);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Optimized kprobe case */
|
|
|
|
if (force)
|
|
|
|
/* Forcibly update the code: this is a special case */
|
|
|
|
force_unoptimize_kprobe(op);
|
|
|
|
else {
|
|
|
|
list_add(&op->list, &unoptimizing_list);
|
|
|
|
kick_kprobe_optimizer();
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-03 02:54:16 -07:00
|
|
|
/* Cancel unoptimizing for reusing */
|
|
|
|
static void reuse_unused_kprobe(struct kprobe *ap)
|
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
BUG_ON(!kprobe_unused(ap));
|
|
|
|
/*
|
|
|
|
* Unused kprobe MUST be on the way of delayed unoptimizing (means
|
|
|
|
* there is still a relative jump) and disabled.
|
|
|
|
*/
|
|
|
|
op = container_of(ap, struct optimized_kprobe, kp);
|
|
|
|
if (unlikely(list_empty(&op->list)))
|
|
|
|
printk(KERN_WARNING "Warning: found a stray unused "
|
|
|
|
"aggrprobe@%p\n", ap->addr);
|
|
|
|
/* Enable the probe again */
|
|
|
|
ap->flags &= ~KPROBE_FLAG_DISABLED;
|
|
|
|
/* Optimize it again (remove from op->list) */
|
|
|
|
BUG_ON(!kprobe_optready(ap));
|
|
|
|
optimize_kprobe(ap);
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Remove optimized instructions */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void kill_optimized_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
2010-12-03 02:54:09 -07:00
|
|
|
if (!list_empty(&op->list))
|
|
|
|
/* Dequeue from the (un)optimization queue */
|
2010-02-25 06:34:07 -07:00
|
|
|
list_del_init(&op->list);
|
2010-12-03 02:54:09 -07:00
|
|
|
op->kp.flags &= ~KPROBE_FLAG_OPTIMIZED;
|
2013-05-22 03:34:09 -06:00
|
|
|
|
|
|
|
if (kprobe_unused(p)) {
|
|
|
|
/* Enqueue if it is unused */
|
|
|
|
list_add(&op->list, &freeing_list);
|
|
|
|
/*
|
|
|
|
* Remove unused probes from the hash list. After waiting
|
|
|
|
* for synchronization, this probe is reclaimed.
|
|
|
|
* (reclaiming is done by do_free_cleaned_kprobes().)
|
|
|
|
*/
|
|
|
|
hlist_del_rcu(&op->kp.hlist);
|
|
|
|
}
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Don't touch the code, because it is already freed. */
|
2010-02-25 06:34:07 -07:00
|
|
|
arch_remove_optimized_kprobe(op);
|
|
|
|
}
|
|
|
|
|
2017-04-19 06:52:25 -06:00
|
|
|
static inline
|
|
|
|
void __prepare_optimized_kprobe(struct optimized_kprobe *op, struct kprobe *p)
|
|
|
|
{
|
|
|
|
if (!kprobe_ftrace(p))
|
|
|
|
arch_prepare_optimized_kprobe(op, p);
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Try to prepare optimized instructions */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void prepare_optimized_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
op = container_of(p, struct optimized_kprobe, kp);
|
2017-04-19 06:52:25 -06:00
|
|
|
__prepare_optimized_kprobe(op, p);
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate new optimized_kprobe and try to prepare optimized instructions */
|
2014-04-17 02:17:54 -06:00
|
|
|
static struct kprobe *alloc_aggr_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
|
|
|
op = kzalloc(sizeof(struct optimized_kprobe), GFP_KERNEL);
|
|
|
|
if (!op)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&op->list);
|
|
|
|
op->kp.addr = p->addr;
|
2017-04-19 06:52:25 -06:00
|
|
|
__prepare_optimized_kprobe(op, p);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
return &op->kp;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void init_aggr_kprobe(struct kprobe *ap, struct kprobe *p);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Prepare an optimized_kprobe and optimize it
|
|
|
|
* NOTE: p must be a normal registered kprobe
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static void try_to_optimize_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
struct kprobe *ap;
|
|
|
|
struct optimized_kprobe *op;
|
|
|
|
|
2012-06-05 04:28:32 -06:00
|
|
|
/* Impossible to optimize ftrace-based kprobe */
|
|
|
|
if (kprobe_ftrace(p))
|
|
|
|
return;
|
|
|
|
|
2012-06-05 04:28:26 -06:00
|
|
|
/* For preparing optimization, jump_label_text_reserved() is called */
|
|
|
|
jump_label_lock();
|
|
|
|
mutex_lock(&text_mutex);
|
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
ap = alloc_aggr_kprobe(p);
|
|
|
|
if (!ap)
|
2012-06-05 04:28:26 -06:00
|
|
|
goto out;
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
op = container_of(ap, struct optimized_kprobe, kp);
|
|
|
|
if (!arch_prepared_optinsn(&op->optinsn)) {
|
|
|
|
/* If failed to setup optimizing, fallback to kprobe */
|
2010-12-03 02:54:09 -07:00
|
|
|
arch_remove_optimized_kprobe(op);
|
|
|
|
kfree(op);
|
2012-06-05 04:28:26 -06:00
|
|
|
goto out;
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
init_aggr_kprobe(ap, p);
|
2012-06-05 04:28:26 -06:00
|
|
|
optimize_kprobe(ap); /* This just kicks optimizer thread */
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
jump_label_unlock();
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:15 -07:00
|
|
|
#ifdef CONFIG_SYSCTL
|
2014-04-17 02:17:54 -06:00
|
|
|
static void optimize_all_kprobes(void)
|
2010-02-25 06:34:15 -07:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
|
|
|
|
2013-04-18 03:33:18 -06:00
|
|
|
mutex_lock(&kprobe_mutex);
|
2010-02-25 06:34:15 -07:00
|
|
|
/* If optimization is already allowed, just return */
|
|
|
|
if (kprobes_allow_optimization)
|
2013-04-18 03:33:18 -06:00
|
|
|
goto out;
|
2010-02-25 06:34:15 -07:00
|
|
|
|
|
|
|
kprobes_allow_optimization = true;
|
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(p, head, hlist)
|
2010-02-25 06:34:15 -07:00
|
|
|
if (!kprobe_disabled(p))
|
|
|
|
optimize_kprobe(p);
|
|
|
|
}
|
|
|
|
printk(KERN_INFO "Kprobes globally optimized\n");
|
2013-04-18 03:33:18 -06:00
|
|
|
out:
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
2010-02-25 06:34:15 -07:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void unoptimize_all_kprobes(void)
|
2010-02-25 06:34:15 -07:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
|
|
|
|
2013-04-18 03:33:18 -06:00
|
|
|
mutex_lock(&kprobe_mutex);
|
2010-02-25 06:34:15 -07:00
|
|
|
/* If optimization is already prohibited, just return */
|
2013-04-18 03:33:18 -06:00
|
|
|
if (!kprobes_allow_optimization) {
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
2010-02-25 06:34:15 -07:00
|
|
|
return;
|
2013-04-18 03:33:18 -06:00
|
|
|
}
|
2010-02-25 06:34:15 -07:00
|
|
|
|
|
|
|
kprobes_allow_optimization = false;
|
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(p, head, hlist) {
|
2010-02-25 06:34:15 -07:00
|
|
|
if (!kprobe_disabled(p))
|
2010-12-03 02:54:09 -07:00
|
|
|
unoptimize_kprobe(p, false);
|
2010-02-25 06:34:15 -07:00
|
|
|
}
|
|
|
|
}
|
2013-04-18 03:33:18 -06:00
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Wait for unoptimizing completion */
|
|
|
|
wait_for_kprobe_optimizer();
|
|
|
|
printk(KERN_INFO "Kprobes globally unoptimized\n");
|
2010-02-25 06:34:15 -07:00
|
|
|
}
|
|
|
|
|
2013-04-18 03:33:18 -06:00
|
|
|
static DEFINE_MUTEX(kprobe_sysctl_mutex);
|
2010-02-25 06:34:15 -07:00
|
|
|
int sysctl_kprobes_optimization;
|
|
|
|
int proc_kprobes_optimization_handler(struct ctl_table *table, int write,
|
|
|
|
void __user *buffer, size_t *length,
|
|
|
|
loff_t *ppos)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2013-04-18 03:33:18 -06:00
|
|
|
mutex_lock(&kprobe_sysctl_mutex);
|
2010-02-25 06:34:15 -07:00
|
|
|
sysctl_kprobes_optimization = kprobes_allow_optimization ? 1 : 0;
|
|
|
|
ret = proc_dointvec_minmax(table, write, buffer, length, ppos);
|
|
|
|
|
|
|
|
if (sysctl_kprobes_optimization)
|
|
|
|
optimize_all_kprobes();
|
|
|
|
else
|
|
|
|
unoptimize_all_kprobes();
|
2013-04-18 03:33:18 -06:00
|
|
|
mutex_unlock(&kprobe_sysctl_mutex);
|
2010-02-25 06:34:15 -07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SYSCTL */
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Put a breakpoint for a probe. Must be called with text_mutex locked */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void __arm_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
2010-12-03 02:53:50 -07:00
|
|
|
struct kprobe *_p;
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
/* Check collision with other optimized kprobes */
|
2010-12-03 02:53:50 -07:00
|
|
|
_p = get_optimized_kprobe((unsigned long)p->addr);
|
|
|
|
if (unlikely(_p))
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Fallback to unoptimized kprobe */
|
|
|
|
unoptimize_kprobe(_p, true);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
arch_arm_kprobe(p);
|
|
|
|
optimize_kprobe(p); /* Try to optimize (add kprobe to a list) */
|
|
|
|
}
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Remove the breakpoint of a probe. Must be called with text_mutex locked */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void __disarm_kprobe(struct kprobe *p, bool reopt)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
2010-12-03 02:53:50 -07:00
|
|
|
struct kprobe *_p;
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2015-02-13 15:40:26 -07:00
|
|
|
/* Try to unoptimize */
|
|
|
|
unoptimize_kprobe(p, kprobes_all_disarmed);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
if (!kprobe_queued(p)) {
|
|
|
|
arch_disarm_kprobe(p);
|
|
|
|
/* If another kprobe was blocked, optimize it. */
|
|
|
|
_p = get_optimized_kprobe((unsigned long)p->addr);
|
|
|
|
if (unlikely(_p) && reopt)
|
|
|
|
optimize_kprobe(_p);
|
|
|
|
}
|
|
|
|
/* TODO: reoptimize others after unoptimized this probe */
|
2010-02-25 06:34:07 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !CONFIG_OPTPROBES */
|
|
|
|
|
|
|
|
#define optimize_kprobe(p) do {} while (0)
|
2010-12-03 02:54:09 -07:00
|
|
|
#define unoptimize_kprobe(p, f) do {} while (0)
|
2010-02-25 06:34:07 -07:00
|
|
|
#define kill_optimized_kprobe(p) do {} while (0)
|
|
|
|
#define prepare_optimized_kprobe(p) do {} while (0)
|
|
|
|
#define try_to_optimize_kprobe(p) do {} while (0)
|
|
|
|
#define __arm_kprobe(p) arch_arm_kprobe(p)
|
2010-12-03 02:54:09 -07:00
|
|
|
#define __disarm_kprobe(p, o) arch_disarm_kprobe(p)
|
|
|
|
#define kprobe_disarmed(p) kprobe_disabled(p)
|
|
|
|
#define wait_for_kprobe_optimizer() do {} while (0)
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2010-12-03 02:54:16 -07:00
|
|
|
/* There should be no unused kprobes can be reused without optimization */
|
|
|
|
static void reuse_unused_kprobe(struct kprobe *ap)
|
|
|
|
{
|
|
|
|
printk(KERN_ERR "Error: There should be no unused kprobe here.\n");
|
|
|
|
BUG_ON(kprobe_unused(ap));
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void free_aggr_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
2010-12-03 02:54:09 -07:00
|
|
|
arch_remove_kprobe(p);
|
2010-02-25 06:34:07 -07:00
|
|
|
kfree(p);
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static struct kprobe *alloc_aggr_kprobe(struct kprobe *p)
|
2010-02-25 06:34:07 -07:00
|
|
|
{
|
|
|
|
return kzalloc(sizeof(struct kprobe), GFP_KERNEL);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_OPTPROBES */
|
|
|
|
|
2012-09-28 02:15:20 -06:00
|
|
|
#ifdef CONFIG_KPROBES_ON_FTRACE
|
2012-06-05 04:28:32 -06:00
|
|
|
static struct ftrace_ops kprobe_ftrace_ops __read_mostly = {
|
2012-06-05 04:28:38 -06:00
|
|
|
.func = kprobe_ftrace_handler,
|
2014-11-21 03:25:23 -07:00
|
|
|
.flags = FTRACE_OPS_FL_SAVE_REGS | FTRACE_OPS_FL_IPMODIFY,
|
2012-06-05 04:28:32 -06:00
|
|
|
};
|
|
|
|
static int kprobe_ftrace_enabled;
|
|
|
|
|
|
|
|
/* Must ensure p->addr is really on ftrace */
|
2014-04-17 02:17:54 -06:00
|
|
|
static int prepare_kprobe(struct kprobe *p)
|
2012-06-05 04:28:32 -06:00
|
|
|
{
|
|
|
|
if (!kprobe_ftrace(p))
|
|
|
|
return arch_prepare_kprobe(p);
|
|
|
|
|
|
|
|
return arch_prepare_kprobe_ftrace(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Caller must lock kprobe_mutex */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void arm_kprobe_ftrace(struct kprobe *p)
|
2012-06-05 04:28:32 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = ftrace_set_filter_ip(&kprobe_ftrace_ops,
|
|
|
|
(unsigned long)p->addr, 0, 0);
|
|
|
|
WARN(ret < 0, "Failed to arm kprobe-ftrace at %p (%d)\n", p->addr, ret);
|
|
|
|
kprobe_ftrace_enabled++;
|
|
|
|
if (kprobe_ftrace_enabled == 1) {
|
|
|
|
ret = register_ftrace_function(&kprobe_ftrace_ops);
|
|
|
|
WARN(ret < 0, "Failed to init kprobe-ftrace (%d)\n", ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Caller must lock kprobe_mutex */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void disarm_kprobe_ftrace(struct kprobe *p)
|
2012-06-05 04:28:32 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
kprobe_ftrace_enabled--;
|
|
|
|
if (kprobe_ftrace_enabled == 0) {
|
|
|
|
ret = unregister_ftrace_function(&kprobe_ftrace_ops);
|
|
|
|
WARN(ret < 0, "Failed to init kprobe-ftrace (%d)\n", ret);
|
|
|
|
}
|
|
|
|
ret = ftrace_set_filter_ip(&kprobe_ftrace_ops,
|
|
|
|
(unsigned long)p->addr, 1, 0);
|
|
|
|
WARN(ret < 0, "Failed to disarm kprobe-ftrace at %p (%d)\n", p->addr, ret);
|
|
|
|
}
|
2012-09-28 02:15:20 -06:00
|
|
|
#else /* !CONFIG_KPROBES_ON_FTRACE */
|
2012-06-05 04:28:32 -06:00
|
|
|
#define prepare_kprobe(p) arch_prepare_kprobe(p)
|
|
|
|
#define arm_kprobe_ftrace(p) do {} while (0)
|
|
|
|
#define disarm_kprobe_ftrace(p) do {} while (0)
|
|
|
|
#endif
|
|
|
|
|
2009-05-07 14:31:26 -06:00
|
|
|
/* Arm a kprobe with text_mutex */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void arm_kprobe(struct kprobe *kp)
|
2009-05-07 14:31:26 -06:00
|
|
|
{
|
2012-06-05 04:28:32 -06:00
|
|
|
if (unlikely(kprobe_ftrace(kp))) {
|
|
|
|
arm_kprobe_ftrace(kp);
|
|
|
|
return;
|
|
|
|
}
|
2010-02-25 06:34:07 -07:00
|
|
|
/*
|
|
|
|
* Here, since __arm_kprobe() doesn't use stop_machine(),
|
|
|
|
* this doesn't cause deadlock on text_mutex. So, we don't
|
|
|
|
* need get_online_cpus().
|
|
|
|
*/
|
2009-05-07 14:31:26 -06:00
|
|
|
mutex_lock(&text_mutex);
|
2010-02-25 06:34:07 -07:00
|
|
|
__arm_kprobe(kp);
|
2009-05-07 14:31:26 -06:00
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Disarm a kprobe with text_mutex */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void disarm_kprobe(struct kprobe *kp, bool reopt)
|
2009-05-07 14:31:26 -06:00
|
|
|
{
|
2012-06-05 04:28:32 -06:00
|
|
|
if (unlikely(kprobe_ftrace(kp))) {
|
|
|
|
disarm_kprobe_ftrace(kp);
|
|
|
|
return;
|
|
|
|
}
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Ditto */
|
2009-05-07 14:31:26 -06:00
|
|
|
mutex_lock(&text_mutex);
|
2012-06-05 04:28:32 -06:00
|
|
|
__disarm_kprobe(kp, reopt);
|
2009-05-07 14:31:26 -06:00
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
}
|
|
|
|
|
2005-05-05 17:15:42 -06:00
|
|
|
/*
|
|
|
|
* Aggregate handlers for multiple kprobes support - these handlers
|
|
|
|
* take care of invoking the individual kprobe handlers on p->list
|
|
|
|
*/
|
2014-04-17 02:18:21 -06:00
|
|
|
static int aggr_pre_handler(struct kprobe *p, struct pt_regs *regs)
|
2005-05-05 17:15:42 -06:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
|
|
|
|
2005-11-07 02:00:13 -07:00
|
|
|
list_for_each_entry_rcu(kp, &p->list, list) {
|
2009-04-06 20:01:02 -06:00
|
|
|
if (kp->pre_handler && likely(!kprobe_disabled(kp))) {
|
2005-11-07 02:00:07 -07:00
|
|
|
set_kprobe_instance(kp);
|
2005-06-23 01:09:41 -06:00
|
|
|
if (kp->pre_handler(kp, regs))
|
|
|
|
return 1;
|
2005-05-05 17:15:42 -06:00
|
|
|
}
|
2005-11-07 02:00:07 -07:00
|
|
|
reset_kprobe_instance();
|
2005-05-05 17:15:42 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(aggr_pre_handler);
|
2005-05-05 17:15:42 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static void aggr_post_handler(struct kprobe *p, struct pt_regs *regs,
|
|
|
|
unsigned long flags)
|
2005-05-05 17:15:42 -06:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
|
|
|
|
2005-11-07 02:00:13 -07:00
|
|
|
list_for_each_entry_rcu(kp, &p->list, list) {
|
2009-04-06 20:01:02 -06:00
|
|
|
if (kp->post_handler && likely(!kprobe_disabled(kp))) {
|
2005-11-07 02:00:07 -07:00
|
|
|
set_kprobe_instance(kp);
|
2005-05-05 17:15:42 -06:00
|
|
|
kp->post_handler(kp, regs, flags);
|
2005-11-07 02:00:07 -07:00
|
|
|
reset_kprobe_instance();
|
2005-05-05 17:15:42 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(aggr_post_handler);
|
2005-05-05 17:15:42 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static int aggr_fault_handler(struct kprobe *p, struct pt_regs *regs,
|
|
|
|
int trapnr)
|
2005-05-05 17:15:42 -06:00
|
|
|
{
|
2010-12-06 10:16:25 -07:00
|
|
|
struct kprobe *cur = __this_cpu_read(kprobe_instance);
|
2005-11-07 02:00:07 -07:00
|
|
|
|
2005-05-05 17:15:42 -06:00
|
|
|
/*
|
|
|
|
* if we faulted "during" the execution of a user specified
|
|
|
|
* probe handler, invoke just that probe's fault handler
|
|
|
|
*/
|
2005-11-07 02:00:07 -07:00
|
|
|
if (cur && cur->fault_handler) {
|
|
|
|
if (cur->fault_handler(cur, regs, trapnr))
|
2005-05-05 17:15:42 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(aggr_fault_handler);
|
2005-05-05 17:15:42 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs)
|
2005-06-23 01:09:41 -06:00
|
|
|
{
|
2010-12-06 10:16:25 -07:00
|
|
|
struct kprobe *cur = __this_cpu_read(kprobe_instance);
|
2005-11-07 02:00:07 -07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (cur && cur->break_handler) {
|
|
|
|
if (cur->break_handler(cur, regs))
|
|
|
|
ret = 1;
|
2005-06-23 01:09:41 -06:00
|
|
|
}
|
2005-11-07 02:00:07 -07:00
|
|
|
reset_kprobe_instance();
|
|
|
|
return ret;
|
2005-06-23 01:09:41 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(aggr_break_handler);
|
2005-06-23 01:09:41 -06:00
|
|
|
|
2005-12-12 01:37:34 -07:00
|
|
|
/* Walks the list and increments nmissed count for multiprobe case */
|
2014-04-17 02:18:21 -06:00
|
|
|
void kprobes_inc_nmissed_count(struct kprobe *p)
|
2005-12-12 01:37:34 -07:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
2010-02-25 06:34:07 -07:00
|
|
|
if (!kprobe_aggrprobe(p)) {
|
2005-12-12 01:37:34 -07:00
|
|
|
p->nmissed++;
|
|
|
|
} else {
|
|
|
|
list_for_each_entry_rcu(kp, &p->list, list)
|
|
|
|
kp->nmissed++;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(kprobes_inc_nmissed_count);
|
2005-12-12 01:37:34 -07:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
void 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 01:09:19 -06:00
|
|
|
{
|
2008-07-25 02:46:04 -06: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 01:09:19 -06:00
|
|
|
/* remove rp inst off the rprobe_inst_table */
|
|
|
|
hlist_del(&ri->hlist);
|
2008-07-25 02:46:04 -06:00
|
|
|
INIT_HLIST_NODE(&ri->hlist);
|
|
|
|
if (likely(rp)) {
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spin_lock(&rp->lock);
|
2008-07-25 02:46:04 -06:00
|
|
|
hlist_add_head(&ri->hlist, &rp->free_instances);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_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 01:09:19 -06:00
|
|
|
} else
|
|
|
|
/* Unregistering */
|
2006-10-02 03:17:35 -06: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 01:09:19 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(recycle_rp_inst);
|
[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 01:09:19 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
void kretprobe_hash_lock(struct task_struct *tsk,
|
2008-07-25 02:46:04 -06:00
|
|
|
struct hlist_head **head, unsigned long *flags)
|
2010-09-14 19:04:30 -06:00
|
|
|
__acquires(hlist_lock)
|
2008-07-25 02:46:04 -06:00
|
|
|
{
|
|
|
|
unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spinlock_t *hlist_lock;
|
2008-07-25 02:46:04 -06:00
|
|
|
|
|
|
|
*head = &kretprobe_inst_table[hash];
|
|
|
|
hlist_lock = kretprobe_table_lock_ptr(hash);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spin_lock_irqsave(hlist_lock, *flags);
|
2008-07-25 02:46:04 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(kretprobe_hash_lock);
|
2008-07-25 02:46:04 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static void kretprobe_table_lock(unsigned long hash,
|
|
|
|
unsigned long *flags)
|
2010-09-14 19:04:30 -06:00
|
|
|
__acquires(hlist_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 01:09:19 -06:00
|
|
|
{
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
|
|
|
|
raw_spin_lock_irqsave(hlist_lock, *flags);
|
2008-07-25 02:46:04 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(kretprobe_table_lock);
|
2008-07-25 02:46:04 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
void kretprobe_hash_unlock(struct task_struct *tsk,
|
|
|
|
unsigned long *flags)
|
2010-09-14 19:04:30 -06:00
|
|
|
__releases(hlist_lock)
|
2008-07-25 02:46:04 -06:00
|
|
|
{
|
|
|
|
unsigned long hash = hash_ptr(tsk, KPROBE_HASH_BITS);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spinlock_t *hlist_lock;
|
2008-07-25 02:46:04 -06:00
|
|
|
|
|
|
|
hlist_lock = kretprobe_table_lock_ptr(hash);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spin_unlock_irqrestore(hlist_lock, *flags);
|
2008-07-25 02:46:04 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(kretprobe_hash_unlock);
|
2008-07-25 02:46:04 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static void kretprobe_table_unlock(unsigned long hash,
|
|
|
|
unsigned long *flags)
|
2010-09-14 19:04:30 -06:00
|
|
|
__releases(hlist_lock)
|
2008-07-25 02:46:04 -06:00
|
|
|
{
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spinlock_t *hlist_lock = kretprobe_table_lock_ptr(hash);
|
|
|
|
raw_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 01:09:19 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(kretprobe_table_unlock);
|
[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 01:09:19 -06:00
|
|
|
|
|
|
|
/*
|
2006-03-26 02:38:20 -07: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 01:09:19 -06:00
|
|
|
*/
|
2014-04-17 02:18:21 -06:00
|
|
|
void 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 01:09:19 -06:00
|
|
|
{
|
2006-10-02 03:17:33 -06:00
|
|
|
struct kretprobe_instance *ri;
|
2006-10-02 03:17:35 -06:00
|
|
|
struct hlist_head *head, empty_rp;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
struct hlist_node *tmp;
|
2008-07-25 02:46:04 -06: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 16:17:08 -06:00
|
|
|
|
2008-07-25 02:46:04 -06:00
|
|
|
if (unlikely(!kprobes_initialized))
|
|
|
|
/* Early boot. kretprobe_table_locks not yet initialized. */
|
|
|
|
return;
|
|
|
|
|
2012-01-20 15:34:04 -07:00
|
|
|
INIT_HLIST_HEAD(&empty_rp);
|
2008-07-25 02:46:04 -06:00
|
|
|
hash = hash_ptr(tk, KPROBE_HASH_BITS);
|
|
|
|
head = &kretprobe_inst_table[hash];
|
|
|
|
kretprobe_table_lock(hash, &flags);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe(ri, tmp, head, hlist) {
|
2006-10-02 03:17:33 -06:00
|
|
|
if (ri->task == tk)
|
2006-10-02 03:17:35 -06:00
|
|
|
recycle_rp_inst(ri, &empty_rp);
|
2006-10-02 03:17:33 -06:00
|
|
|
}
|
2008-07-25 02:46:04 -06:00
|
|
|
kretprobe_table_unlock(hash, &flags);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe(ri, tmp, &empty_rp, hlist) {
|
2006-10-02 03:17:35 -06:00
|
|
|
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 01:09:19 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(kprobe_flush_task);
|
[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 01:09:19 -06:00
|
|
|
|
|
|
|
static inline void free_rp_inst(struct kretprobe *rp)
|
|
|
|
{
|
|
|
|
struct kretprobe_instance *ri;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
struct hlist_node *next;
|
2007-05-08 01:34:14 -06:00
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe(ri, next, &rp->free_instances, hlist) {
|
2008-07-25 02:46:04 -06:00
|
|
|
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 01:09:19 -06:00
|
|
|
kfree(ri);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static void cleanup_rp_inst(struct kretprobe *rp)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
2008-07-25 02:46:04 -06:00
|
|
|
unsigned long flags, hash;
|
2008-04-28 03:14:29 -06:00
|
|
|
struct kretprobe_instance *ri;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
struct hlist_node *next;
|
2008-07-25 02:46:04 -06:00
|
|
|
struct hlist_head *head;
|
|
|
|
|
2008-04-28 03:14:29 -06:00
|
|
|
/* No race here */
|
2008-07-25 02:46:04 -06:00
|
|
|
for (hash = 0; hash < KPROBE_TABLE_SIZE; hash++) {
|
|
|
|
kretprobe_table_lock(hash, &flags);
|
|
|
|
head = &kretprobe_inst_table[hash];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_safe(ri, next, head, hlist) {
|
2008-07-25 02:46:04 -06:00
|
|
|
if (ri->rp == rp)
|
|
|
|
ri->rp = NULL;
|
|
|
|
}
|
|
|
|
kretprobe_table_unlock(hash, &flags);
|
2008-04-28 03:14:29 -06:00
|
|
|
}
|
|
|
|
free_rp_inst(rp);
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(cleanup_rp_inst);
|
2008-04-28 03:14:29 -06:00
|
|
|
|
2005-06-23 01:09:41 -06:00
|
|
|
/*
|
2009-04-06 20:00:58 -06:00
|
|
|
* Add the new probe to ap->list. Fail if this is the
|
2005-06-23 01:09:41 -06:00
|
|
|
* second jprobe at the address - two jprobes can't coexist
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static int add_new_kprobe(struct kprobe *ap, struct kprobe *p)
|
2005-06-23 01:09:41 -06:00
|
|
|
{
|
2009-04-06 20:01:02 -06:00
|
|
|
BUG_ON(kprobe_gone(ap) || kprobe_gone(p));
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
if (p->break_handler || p->post_handler)
|
2010-12-03 02:54:09 -07:00
|
|
|
unoptimize_kprobe(ap, true); /* Fall back to normal kprobe */
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2005-06-23 01:09:41 -06:00
|
|
|
if (p->break_handler) {
|
2009-04-06 20:00:58 -06:00
|
|
|
if (ap->break_handler)
|
2006-06-26 01:25:22 -06:00
|
|
|
return -EEXIST;
|
2009-04-06 20:00:58 -06:00
|
|
|
list_add_tail_rcu(&p->list, &ap->list);
|
|
|
|
ap->break_handler = aggr_break_handler;
|
2005-06-23 01:09:41 -06:00
|
|
|
} else
|
2009-04-06 20:00:58 -06:00
|
|
|
list_add_rcu(&p->list, &ap->list);
|
|
|
|
if (p->post_handler && !ap->post_handler)
|
|
|
|
ap->post_handler = aggr_post_handler;
|
2009-04-06 20:01:02 -06:00
|
|
|
|
2005-06-23 01:09:41 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-05-05 17:15:42 -06:00
|
|
|
/*
|
|
|
|
* Fill in the required fields of the "manager kprobe". Replace the
|
|
|
|
* earlier kprobe in the hlist with the manager kprobe
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static void init_aggr_kprobe(struct kprobe *ap, struct kprobe *p)
|
2005-05-05 17:15:42 -06:00
|
|
|
{
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Copy p's insn slot to ap */
|
2005-06-23 01:09:41 -06:00
|
|
|
copy_kprobe(p, ap);
|
2006-07-30 04:03:26 -06:00
|
|
|
flush_insn_slot(ap);
|
2005-05-05 17:15:42 -06:00
|
|
|
ap->addr = p->addr;
|
2010-02-25 06:34:07 -07:00
|
|
|
ap->flags = p->flags & ~KPROBE_FLAG_OPTIMIZED;
|
2005-05-05 17:15:42 -06:00
|
|
|
ap->pre_handler = aggr_pre_handler;
|
|
|
|
ap->fault_handler = aggr_fault_handler;
|
2009-01-06 15:41:52 -07:00
|
|
|
/* We don't care the kprobe which has gone. */
|
|
|
|
if (p->post_handler && !kprobe_gone(p))
|
2006-06-26 01:25:22 -06:00
|
|
|
ap->post_handler = aggr_post_handler;
|
2009-01-06 15:41:52 -07:00
|
|
|
if (p->break_handler && !kprobe_gone(p))
|
2006-06-26 01:25:22 -06:00
|
|
|
ap->break_handler = aggr_break_handler;
|
2005-05-05 17:15:42 -06:00
|
|
|
|
|
|
|
INIT_LIST_HEAD(&ap->list);
|
2010-02-25 06:34:07 -07:00
|
|
|
INIT_HLIST_NODE(&ap->hlist);
|
2005-05-05 17:15:42 -06:00
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
list_add_rcu(&p->list, &ap->list);
|
2005-12-12 01:37:12 -07:00
|
|
|
hlist_replace_rcu(&p->hlist, &ap->hlist);
|
2005-05-05 17:15:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is the second or subsequent kprobe at the address - handle
|
|
|
|
* the intricacies
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p)
|
2005-05-05 17:15:42 -06:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2010-12-03 02:53:50 -07:00
|
|
|
struct kprobe *ap = orig_p;
|
2005-05-05 17:15:42 -06:00
|
|
|
|
2012-06-05 04:28:26 -06:00
|
|
|
/* For preparing optimization, jump_label_text_reserved() is called */
|
|
|
|
jump_label_lock();
|
|
|
|
/*
|
|
|
|
* Get online CPUs to avoid text_mutex deadlock.with stop machine,
|
|
|
|
* which is invoked by unoptimize_kprobe() in add_new_kprobe()
|
|
|
|
*/
|
|
|
|
get_online_cpus();
|
|
|
|
mutex_lock(&text_mutex);
|
|
|
|
|
2010-12-03 02:53:50 -07:00
|
|
|
if (!kprobe_aggrprobe(orig_p)) {
|
|
|
|
/* If orig_p is not an aggr_kprobe, create new aggr_kprobe. */
|
|
|
|
ap = alloc_aggr_kprobe(orig_p);
|
2012-06-05 04:28:26 -06:00
|
|
|
if (!ap) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-12-03 02:53:50 -07:00
|
|
|
init_aggr_kprobe(ap, orig_p);
|
2010-12-03 02:54:09 -07:00
|
|
|
} else if (kprobe_unused(ap))
|
2010-12-03 02:54:16 -07:00
|
|
|
/* This probe is going to die. Rescue it */
|
|
|
|
reuse_unused_kprobe(ap);
|
2009-04-06 20:00:58 -06:00
|
|
|
|
|
|
|
if (kprobe_gone(ap)) {
|
2009-01-06 15:41:52 -07: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-06 20:00:58 -06:00
|
|
|
ret = arch_prepare_kprobe(ap);
|
2009-01-06 15:41:52 -07:00
|
|
|
if (ret)
|
2009-04-06 20:00:58 -06: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.
|
|
|
|
*/
|
2012-06-05 04:28:26 -06:00
|
|
|
goto out;
|
2009-04-06 20:01:02 -06:00
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Prepare optimized instructions if possible. */
|
|
|
|
prepare_optimized_kprobe(ap);
|
|
|
|
|
2009-01-06 15:41:52 -07:00
|
|
|
/*
|
2009-04-06 20:01:02 -06:00
|
|
|
* Clear gone flag to prevent allocating new slot again, and
|
|
|
|
* set disabled flag because it is not armed yet.
|
2009-01-06 15:41:52 -07:00
|
|
|
*/
|
2009-04-06 20:01:02 -06:00
|
|
|
ap->flags = (ap->flags & ~KPROBE_FLAG_GONE)
|
|
|
|
| KPROBE_FLAG_DISABLED;
|
2009-01-06 15:41:52 -07:00
|
|
|
}
|
2009-04-06 20:00:58 -06:00
|
|
|
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Copy ap's insn slot to p */
|
2009-04-06 20:00:58 -06:00
|
|
|
copy_kprobe(ap, p);
|
2012-06-05 04:28:26 -06:00
|
|
|
ret = add_new_kprobe(ap, p);
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&text_mutex);
|
|
|
|
put_online_cpus();
|
|
|
|
jump_label_unlock();
|
|
|
|
|
|
|
|
if (ret == 0 && kprobe_disabled(ap) && !kprobe_disabled(p)) {
|
|
|
|
ap->flags &= ~KPROBE_FLAG_DISABLED;
|
|
|
|
if (!kprobes_all_disarmed)
|
|
|
|
/* Arm the breakpoint again. */
|
|
|
|
arm_kprobe(ap);
|
|
|
|
}
|
|
|
|
return ret;
|
2005-05-05 17:15:42 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:16:58 -06:00
|
|
|
bool __weak arch_within_kprobe_blacklist(unsigned long addr)
|
|
|
|
{
|
|
|
|
/* The __kprobes marked functions and entry code must not be probed */
|
|
|
|
return addr >= (unsigned long)__kprobes_text_start &&
|
|
|
|
addr < (unsigned long)__kprobes_text_end;
|
|
|
|
}
|
|
|
|
|
2015-07-30 21:32:40 -06:00
|
|
|
bool within_kprobe_blacklist(unsigned long addr)
|
2005-09-06 16:19:26 -06:00
|
|
|
{
|
2014-04-17 02:17:05 -06:00
|
|
|
struct kprobe_blacklist_entry *ent;
|
2008-04-28 03:14:26 -06:00
|
|
|
|
2014-04-17 02:16:58 -06:00
|
|
|
if (arch_within_kprobe_blacklist(addr))
|
2014-04-17 02:17:05 -06:00
|
|
|
return true;
|
2008-04-28 03:14:26 -06:00
|
|
|
/*
|
|
|
|
* If there exists a kprobe_blacklist, verify and
|
|
|
|
* fail any probe registration in the prohibited area
|
|
|
|
*/
|
2014-04-17 02:17:05 -06:00
|
|
|
list_for_each_entry(ent, &kprobe_blacklist, list) {
|
|
|
|
if (addr >= ent->start_addr && addr < ent->end_addr)
|
|
|
|
return true;
|
2008-04-28 03:14:26 -06:00
|
|
|
}
|
2014-04-17 02:17:05 -06:00
|
|
|
|
|
|
|
return false;
|
2005-09-06 16:19:26 -06:00
|
|
|
}
|
|
|
|
|
2008-03-04 15:29:44 -07: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.
|
2011-06-27 01:26:50 -06:00
|
|
|
* This returns encoded errors if it fails to look up symbol or invalid
|
|
|
|
* combination of parameters.
|
2008-03-04 15:29:44 -07:00
|
|
|
*/
|
2017-03-08 01:26:06 -07:00
|
|
|
static kprobe_opcode_t *_kprobe_addr(kprobe_opcode_t *addr,
|
|
|
|
const char *symbol_name, unsigned int offset)
|
2008-03-04 15:29:44 -07:00
|
|
|
{
|
2017-03-08 01:26:06 -07:00
|
|
|
if ((symbol_name && addr) || (!symbol_name && !addr))
|
2011-06-27 01:26:50 -06:00
|
|
|
goto invalid;
|
|
|
|
|
2017-03-08 01:26:06 -07:00
|
|
|
if (symbol_name) {
|
powerpc updates for 4.12 part 1.
Highlights include:
- Larger virtual address space on 64-bit server CPUs. By default we use a 128TB
virtual address space, but a process can request access to the full 512TB by
passing a hint to mmap().
- Support for the new Power9 "XIVE" interrupt controller.
- TLB flushing optimisations for the radix MMU on Power9.
- Support for CAPI cards on Power9, using the "Coherent Accelerator Interface
Architecture 2.0".
- The ability to configure the mmap randomisation limits at build and runtime.
- Several small fixes and cleanups to the kprobes code, as well as support for
KPROBES_ON_FTRACE.
- Major improvements to handling of system reset interrupts, correctly treating
them as NMIs, giving them a dedicated stack and using a new hypervisor call
to trigger them, all of which should aid debugging and robustness.
Many fixes and other minor enhancements.
Thanks to:
Alastair D'Silva, Alexey Kardashevskiy, Alistair Popple, Andrew Donnellan,
Aneesh Kumar K.V, Anshuman Khandual, Anton Blanchard, Balbir Singh, Ben
Hutchings, Benjamin Herrenschmidt, Bhupesh Sharma, Chris Packham, Christian
Zigotzky, Christophe Leroy, Christophe Lombard, Daniel Axtens, David Gibson,
Gautham R. Shenoy, Gavin Shan, Geert Uytterhoeven, Guilherme G. Piccoli,
Hamish Martin, Hari Bathini, Kees Cook, Laurent Dufour, Madhavan Srinivasan,
Mahesh J Salgaonkar, Mahesh Salgaonkar, Masami Hiramatsu, Matt Brown, Matthew
R. Ochs, Michael Neuling, Naveen N. Rao, Nicholas Piggin, Oliver O'Halloran,
Pan Xinhui, Paul Mackerras, Rashmica Gupta, Russell Currey, Sukadev
Bhattiprolu, Thadeu Lima de Souza Cascardo, Tobin C. Harding, Tyrel Datwyler,
Uma Krishnan, Vaibhav Jain, Vipin K Parashar, Yang Shi.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1
iQIcBAABAgAGBQJZDHUMAAoJEFHr6jzI4aWAT7oQALkE2Nj3gjcn1z0SkFhq/1iO
Py9Elmqm4E+L6NKYtBY5dS8xVAJ088ffzERyqJ1FY1LHkB8tn8bWRcMQmbjAFzTI
V4TAzDNI890BN/F4ptrYRwNFxRBHAvZ4NDunTzagwYnwmTzW9PYHmOi4pvWTo3Tw
KFUQ0joLSEgHzyfXxYB3fyj41u8N0FZvhfazdNSqia2Y5Vwwv/ION5jKplDM+09Y
EtVEXFvaKAS1sjbM/d/Jo5rblHfR0D9/lYV10+jjyIokjzslIpyTbnj3izeYoM5V
I4h99372zfsEjBGPPXyM3khL3zizGMSDYRmJHQSaKxjtecS9SPywPTZ8ufO/aSzV
Ngq6nlND+f1zep29VQ0cxd3Jh40skWOXzxJaFjfDT25xa6FbfsWP2NCtk8PGylZ7
EyqTuCWkMgIP02KlX3oHvEB2LRRPCDmRU2zECecRGNJrIQwYC2xjoiVi7Q8Qe8rY
gr7Ib5Jj/a+uiTcCIy37+5nXq2s14/JBOKqxuYZIxeuZFvKYuRUipbKWO05WDOAz
m/pSzeC3J8AAoYiqR0gcSOuJTOnJpGhs7zrQFqnEISbXIwLW+ICumzOmTAiBqOEY
Rt8uW2gYkPwKLrE05445RfVUoERaAjaE06eRMOWS6slnngHmmnRJbf3PcoALiJkT
ediqGEj0/N1HMB31V5tS
=vSF3
-----END PGP SIGNATURE-----
Merge tag 'powerpc-4.12-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux
Pull powerpc updates from Michael Ellerman:
"Highlights include:
- Larger virtual address space on 64-bit server CPUs. By default we
use a 128TB virtual address space, but a process can request access
to the full 512TB by passing a hint to mmap().
- Support for the new Power9 "XIVE" interrupt controller.
- TLB flushing optimisations for the radix MMU on Power9.
- Support for CAPI cards on Power9, using the "Coherent Accelerator
Interface Architecture 2.0".
- The ability to configure the mmap randomisation limits at build and
runtime.
- Several small fixes and cleanups to the kprobes code, as well as
support for KPROBES_ON_FTRACE.
- Major improvements to handling of system reset interrupts,
correctly treating them as NMIs, giving them a dedicated stack and
using a new hypervisor call to trigger them, all of which should
aid debugging and robustness.
- Many fixes and other minor enhancements.
Thanks to: Alastair D'Silva, Alexey Kardashevskiy, Alistair Popple,
Andrew Donnellan, Aneesh Kumar K.V, Anshuman Khandual, Anton
Blanchard, Balbir Singh, Ben Hutchings, Benjamin Herrenschmidt,
Bhupesh Sharma, Chris Packham, Christian Zigotzky, Christophe Leroy,
Christophe Lombard, Daniel Axtens, David Gibson, Gautham R. Shenoy,
Gavin Shan, Geert Uytterhoeven, Guilherme G. Piccoli, Hamish Martin,
Hari Bathini, Kees Cook, Laurent Dufour, Madhavan Srinivasan, Mahesh J
Salgaonkar, Mahesh Salgaonkar, Masami Hiramatsu, Matt Brown, Matthew
R. Ochs, Michael Neuling, Naveen N. Rao, Nicholas Piggin, Oliver
O'Halloran, Pan Xinhui, Paul Mackerras, Rashmica Gupta, Russell
Currey, Sukadev Bhattiprolu, Thadeu Lima de Souza Cascardo, Tobin C.
Harding, Tyrel Datwyler, Uma Krishnan, Vaibhav Jain, Vipin K Parashar,
Yang Shi"
* tag 'powerpc-4.12-1' of git://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux: (214 commits)
powerpc/64s: Power9 has no LPCR[VRMASD] field so don't set it
powerpc/powernv: Fix TCE kill on NVLink2
powerpc/mm/radix: Drop support for CPUs without lockless tlbie
powerpc/book3s/mce: Move add_taint() later in virtual mode
powerpc/sysfs: Move #ifdef CONFIG_HOTPLUG_CPU out of the function body
powerpc/smp: Document irq enable/disable after migrating IRQs
powerpc/mpc52xx: Don't select user-visible RTAS_PROC
powerpc/powernv: Document cxl dependency on special case in pnv_eeh_reset()
powerpc/eeh: Clean up and document event handling functions
powerpc/eeh: Avoid use after free in eeh_handle_special_event()
cxl: Mask slice error interrupts after first occurrence
cxl: Route eeh events to all drivers in cxl_pci_error_detected()
cxl: Force context lock during EEH flow
powerpc/64: Allow CONFIG_RELOCATABLE if COMPILE_TEST
powerpc/xmon: Teach xmon oops about radix vectors
powerpc/mm/hash: Fix off-by-one in comment about kernel contexts ids
powerpc/pseries: Enable VFIO
powerpc/powernv: Fix iommu table size calculation hook for small tables
powerpc/powernv: Check kzalloc() return value in pnv_pci_table_alloc
powerpc: Add arch/powerpc/tools directory
...
2017-05-05 12:36:44 -06:00
|
|
|
addr = kprobe_lookup_name(symbol_name, offset);
|
2011-06-27 01:26:50 -06:00
|
|
|
if (!addr)
|
|
|
|
return ERR_PTR(-ENOENT);
|
2008-03-04 15:29:44 -07:00
|
|
|
}
|
|
|
|
|
2017-03-08 01:26:06 -07:00
|
|
|
addr = (kprobe_opcode_t *)(((char *)addr) + offset);
|
2011-06-27 01:26:50 -06:00
|
|
|
if (addr)
|
|
|
|
return addr;
|
|
|
|
|
|
|
|
invalid:
|
|
|
|
return ERR_PTR(-EINVAL);
|
2008-03-04 15:29:44 -07:00
|
|
|
}
|
|
|
|
|
2017-03-08 01:26:06 -07:00
|
|
|
static kprobe_opcode_t *kprobe_addr(struct kprobe *p)
|
|
|
|
{
|
|
|
|
return _kprobe_addr(p->addr, p->symbol_name, p->offset);
|
|
|
|
}
|
|
|
|
|
2009-09-14 23:13:07 -06:00
|
|
|
/* Check passed kprobe is valid and return kprobe in kprobe_table. */
|
2014-04-17 02:17:54 -06:00
|
|
|
static struct kprobe *__get_valid_kprobe(struct kprobe *p)
|
2009-09-14 23:13:07 -06:00
|
|
|
{
|
2010-12-03 02:53:50 -07:00
|
|
|
struct kprobe *ap, *list_p;
|
2009-09-14 23:13:07 -06:00
|
|
|
|
2010-12-03 02:53:50 -07:00
|
|
|
ap = get_kprobe(p->addr);
|
|
|
|
if (unlikely(!ap))
|
2009-09-14 23:13:07 -06:00
|
|
|
return NULL;
|
|
|
|
|
2010-12-03 02:53:50 -07:00
|
|
|
if (p != ap) {
|
|
|
|
list_for_each_entry_rcu(list_p, &ap->list, list)
|
2009-09-14 23:13:07 -06:00
|
|
|
if (list_p == p)
|
|
|
|
/* kprobe p is a valid probe */
|
|
|
|
goto valid;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
valid:
|
2010-12-03 02:53:50 -07:00
|
|
|
return ap;
|
2009-09-14 23:13:07 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Return error if the kprobe is being re-registered */
|
|
|
|
static inline int check_kprobe_rereg(struct kprobe *p)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
2010-12-03 02:53:50 -07:00
|
|
|
if (__get_valid_kprobe(p))
|
2009-09-14 23:13:07 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
2010-12-03 02:53:50 -07:00
|
|
|
|
2009-09-14 23:13:07 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-15 04:17:34 -06:00
|
|
|
int __weak arch_check_ftrace_location(struct kprobe *p)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-06-05 04:28:32 -06:00
|
|
|
unsigned long ftrace_addr;
|
|
|
|
|
|
|
|
ftrace_addr = ftrace_location((unsigned long)p->addr);
|
|
|
|
if (ftrace_addr) {
|
2012-09-28 02:15:20 -06:00
|
|
|
#ifdef CONFIG_KPROBES_ON_FTRACE
|
2012-06-05 04:28:32 -06:00
|
|
|
/* Given address is not on the instruction boundary */
|
|
|
|
if ((unsigned long)p->addr != ftrace_addr)
|
|
|
|
return -EILSEQ;
|
|
|
|
p->flags |= KPROBE_FLAG_FTRACE;
|
2012-09-28 02:15:20 -06:00
|
|
|
#else /* !CONFIG_KPROBES_ON_FTRACE */
|
2012-06-05 04:28:32 -06:00
|
|
|
return -EINVAL;
|
|
|
|
#endif
|
|
|
|
}
|
2014-10-15 04:17:34 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int check_kprobe_address_safe(struct kprobe *p,
|
|
|
|
struct module **probed_mod)
|
|
|
|
{
|
|
|
|
int ret;
|
2009-09-14 23:13:07 -06:00
|
|
|
|
2014-10-15 04:17:34 -06:00
|
|
|
ret = arch_check_ftrace_location(p);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2010-10-01 15:23:48 -06:00
|
|
|
jump_label_lock();
|
2010-10-18 08:38:58 -06:00
|
|
|
preempt_disable();
|
2012-06-05 04:28:20 -06:00
|
|
|
|
|
|
|
/* Ensure it is not in reserved area nor out of text */
|
2009-07-28 17:47:23 -06:00
|
|
|
if (!kernel_text_address((unsigned long) p->addr) ||
|
2014-04-17 02:17:05 -06:00
|
|
|
within_kprobe_blacklist((unsigned long) p->addr) ||
|
2012-03-05 15:59:12 -07:00
|
|
|
jump_label_text_reserved(p->addr, p->addr)) {
|
|
|
|
ret = -EINVAL;
|
2012-06-05 04:28:20 -06:00
|
|
|
goto out;
|
2012-03-05 15:59:12 -07:00
|
|
|
}
|
2005-12-12 01:37:00 -07:00
|
|
|
|
2012-06-05 04:28:20 -06:00
|
|
|
/* Check if are we probing a module */
|
|
|
|
*probed_mod = __module_text_address((unsigned long) p->addr);
|
|
|
|
if (*probed_mod) {
|
2007-05-08 01:34:13 -06:00
|
|
|
/*
|
2009-01-06 15:41:52 -07:00
|
|
|
* We must hold a refcount of the probed module while updating
|
|
|
|
* its code to prohibit unexpected unloading.
|
2006-01-11 13:17:41 -07:00
|
|
|
*/
|
2012-06-05 04:28:20 -06:00
|
|
|
if (unlikely(!try_module_get(*probed_mod))) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-10-18 08:38:58 -06:00
|
|
|
|
2009-01-06 15:41:55 -07:00
|
|
|
/*
|
|
|
|
* If the module freed .init.text, we couldn't insert
|
|
|
|
* kprobes in there.
|
|
|
|
*/
|
2012-06-05 04:28:20 -06:00
|
|
|
if (within_module_init((unsigned long)p->addr, *probed_mod) &&
|
|
|
|
(*probed_mod)->state != MODULE_STATE_COMING) {
|
|
|
|
module_put(*probed_mod);
|
|
|
|
*probed_mod = NULL;
|
|
|
|
ret = -ENOENT;
|
2009-01-06 15:41:55 -07:00
|
|
|
}
|
2006-01-11 13:17:41 -07:00
|
|
|
}
|
2012-06-05 04:28:20 -06:00
|
|
|
out:
|
2008-11-12 14:26:51 -07:00
|
|
|
preempt_enable();
|
2010-10-18 08:38:58 -06:00
|
|
|
jump_label_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-06-05 04:28:20 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
int register_kprobe(struct kprobe *p)
|
2012-06-05 04:28:20 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct kprobe *old_p;
|
|
|
|
struct module *probed_mod;
|
|
|
|
kprobe_opcode_t *addr;
|
|
|
|
|
|
|
|
/* Adjust probe address from symbol */
|
|
|
|
addr = kprobe_addr(p);
|
|
|
|
if (IS_ERR(addr))
|
|
|
|
return PTR_ERR(addr);
|
|
|
|
p->addr = addr;
|
|
|
|
|
|
|
|
ret = check_kprobe_rereg(p);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* User can pass only KPROBE_FLAG_DISABLED to register_kprobe */
|
|
|
|
p->flags &= KPROBE_FLAG_DISABLED;
|
2005-11-07 02:00:13 -07:00
|
|
|
p->nmissed = 0;
|
2008-04-28 03:14:28 -06:00
|
|
|
INIT_LIST_HEAD(&p->list);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2012-06-05 04:28:20 -06:00
|
|
|
ret = check_kprobe_address_safe(p, &probed_mod);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2005-05-05 17:15:42 -06:00
|
|
|
old_p = get_kprobe(p->addr);
|
|
|
|
if (old_p) {
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Since this may unoptimize old_p, locking text_mutex. */
|
2005-05-05 17:15:42 -06:00
|
|
|
ret = register_aggr_kprobe(old_p, p);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-06-05 04:28:26 -06:00
|
|
|
mutex_lock(&text_mutex); /* Avoiding text modification */
|
2012-06-05 04:28:32 -06:00
|
|
|
ret = prepare_kprobe(p);
|
2012-06-05 04:28:26 -06:00
|
|
|
mutex_unlock(&text_mutex);
|
2007-05-08 01:34:13 -06:00
|
|
|
if (ret)
|
2010-02-25 06:34:07 -07:00
|
|
|
goto out;
|
2006-01-09 21:52:43 -07:00
|
|
|
|
2005-05-05 17:15:42 -06:00
|
|
|
INIT_HLIST_NODE(&p->hlist);
|
2005-11-07 02:00:13 -07:00
|
|
|
hlist_add_head_rcu(&p->hlist,
|
2005-04-16 16:20:36 -06:00
|
|
|
&kprobe_table[hash_ptr(p->addr, KPROBE_HASH_BITS)]);
|
|
|
|
|
2009-04-06 20:01:02 -06:00
|
|
|
if (!kprobes_all_disarmed && !kprobe_disabled(p))
|
2012-06-05 04:28:26 -06:00
|
|
|
arm_kprobe(p);
|
2010-02-25 06:34:07 -07:00
|
|
|
|
|
|
|
/* Try to optimize kprobe */
|
|
|
|
try_to_optimize_kprobe(p);
|
2007-10-16 02:24:07 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
out:
|
2006-03-23 04:00:35 -07:00
|
|
|
mutex_unlock(&kprobe_mutex);
|
2006-01-09 21:52:43 -07:00
|
|
|
|
2009-01-06 15:41:52 -07:00
|
|
|
if (probed_mod)
|
2006-01-11 13:17:41 -07:00
|
|
|
module_put(probed_mod);
|
2009-01-06 15:41:52 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(register_kprobe);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-12-03 02:53:57 -07:00
|
|
|
/* Check if all probes on the aggrprobe are disabled */
|
2014-04-17 02:17:54 -06:00
|
|
|
static int aggr_kprobe_disabled(struct kprobe *ap)
|
2010-12-03 02:53:57 -07:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(kp, &ap->list, list)
|
|
|
|
if (!kprobe_disabled(kp))
|
|
|
|
/*
|
|
|
|
* There is an active probe on the list.
|
|
|
|
* We can't disable this ap.
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Disable one kprobe: Make sure called under kprobe_mutex is locked */
|
2014-04-17 02:17:54 -06:00
|
|
|
static struct kprobe *__disable_kprobe(struct kprobe *p)
|
2010-12-03 02:53:57 -07:00
|
|
|
{
|
|
|
|
struct kprobe *orig_p;
|
|
|
|
|
|
|
|
/* Get an original kprobe for return */
|
|
|
|
orig_p = __get_valid_kprobe(p);
|
|
|
|
if (unlikely(orig_p == NULL))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!kprobe_disabled(p)) {
|
|
|
|
/* Disable probe if it is a child probe */
|
|
|
|
if (p != orig_p)
|
|
|
|
p->flags |= KPROBE_FLAG_DISABLED;
|
|
|
|
|
|
|
|
/* Try to disarm and disable this/parent probe */
|
|
|
|
if (p == orig_p || aggr_kprobe_disabled(orig_p)) {
|
2015-02-13 15:40:26 -07:00
|
|
|
/*
|
|
|
|
* If kprobes_all_disarmed is set, orig_p
|
|
|
|
* should have already been disarmed, so
|
|
|
|
* skip unneed disarming process.
|
|
|
|
*/
|
|
|
|
if (!kprobes_all_disarmed)
|
|
|
|
disarm_kprobe(orig_p, true);
|
2010-12-03 02:53:57 -07:00
|
|
|
orig_p->flags |= KPROBE_FLAG_DISABLED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return orig_p;
|
|
|
|
}
|
|
|
|
|
2009-04-06 20:01:02 -06:00
|
|
|
/*
|
|
|
|
* Unregister a kprobe without a scheduler synchronization.
|
|
|
|
*/
|
2014-04-17 02:17:54 -06:00
|
|
|
static int __unregister_kprobe_top(struct kprobe *p)
|
2009-04-06 20:01:02 -06:00
|
|
|
{
|
2010-12-03 02:53:50 -07:00
|
|
|
struct kprobe *ap, *list_p;
|
2009-04-06 20:01:02 -06:00
|
|
|
|
2010-12-03 02:53:57 -07:00
|
|
|
/* Disable kprobe. This will disarm it if needed. */
|
|
|
|
ap = __disable_kprobe(p);
|
2010-12-03 02:53:50 -07:00
|
|
|
if (ap == NULL)
|
2009-04-06 20:01:02 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-12-03 02:53:57 -07:00
|
|
|
if (ap == p)
|
2007-05-08 01:34:16 -06:00
|
|
|
/*
|
2010-12-03 02:53:57 -07:00
|
|
|
* This probe is an independent(and non-optimized) kprobe
|
|
|
|
* (not an aggrprobe). Remove from the hash list.
|
2007-05-08 01:34:16 -06:00
|
|
|
*/
|
2010-12-03 02:53:57 -07:00
|
|
|
goto disarmed;
|
|
|
|
|
|
|
|
/* Following process expects this probe is an aggrprobe */
|
|
|
|
WARN_ON(!kprobe_aggrprobe(ap));
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
if (list_is_singular(&ap->list) && kprobe_disarmed(ap))
|
|
|
|
/*
|
|
|
|
* !disarmed could be happen if the probe is under delayed
|
|
|
|
* unoptimizing.
|
|
|
|
*/
|
2010-12-03 02:53:57 -07:00
|
|
|
goto disarmed;
|
|
|
|
else {
|
|
|
|
/* If disabling probe has special handlers, update aggrprobe */
|
2009-01-06 15:41:52 -07:00
|
|
|
if (p->break_handler && !kprobe_gone(p))
|
2010-12-03 02:53:50 -07:00
|
|
|
ap->break_handler = NULL;
|
2009-01-06 15:41:52 -07:00
|
|
|
if (p->post_handler && !kprobe_gone(p)) {
|
2010-12-03 02:53:50 -07:00
|
|
|
list_for_each_entry_rcu(list_p, &ap->list, list) {
|
2008-04-28 03:14:28 -06:00
|
|
|
if ((list_p != p) && (list_p->post_handler))
|
|
|
|
goto noclean;
|
|
|
|
}
|
2010-12-03 02:53:50 -07:00
|
|
|
ap->post_handler = NULL;
|
2008-04-28 03:14:28 -06:00
|
|
|
}
|
|
|
|
noclean:
|
2010-12-03 02:53:57 -07:00
|
|
|
/*
|
|
|
|
* Remove from the aggrprobe: this path will do nothing in
|
|
|
|
* __unregister_kprobe_bottom().
|
|
|
|
*/
|
2006-01-09 21:52:43 -07:00
|
|
|
list_del_rcu(&p->list);
|
2010-12-03 02:53:57 -07:00
|
|
|
if (!kprobe_disabled(ap) && !kprobes_all_disarmed)
|
|
|
|
/*
|
|
|
|
* Try to optimize this probe again, because post
|
|
|
|
* handler may have been changed.
|
|
|
|
*/
|
|
|
|
optimize_kprobe(ap);
|
2006-01-09 21:52:43 -07:00
|
|
|
}
|
2008-04-28 03:14:28 -06:00
|
|
|
return 0;
|
2010-12-03 02:53:57 -07:00
|
|
|
|
|
|
|
disarmed:
|
2010-12-03 02:54:09 -07:00
|
|
|
BUG_ON(!kprobe_disarmed(ap));
|
2010-12-03 02:53:57 -07:00
|
|
|
hlist_del_rcu(&ap->hlist);
|
|
|
|
return 0;
|
2008-04-28 03:14:28 -06:00
|
|
|
}
|
2005-11-07 02:00:13 -07:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void __unregister_kprobe_bottom(struct kprobe *p)
|
2008-04-28 03:14:28 -06:00
|
|
|
{
|
2010-12-03 02:53:50 -07:00
|
|
|
struct kprobe *ap;
|
2005-12-12 01:37:00 -07:00
|
|
|
|
2009-01-06 15:41:52 -07:00
|
|
|
if (list_empty(&p->list))
|
2010-12-03 02:54:09 -07:00
|
|
|
/* This is an independent kprobe */
|
2006-01-09 21:52:46 -07:00
|
|
|
arch_remove_kprobe(p);
|
2009-01-06 15:41:52 -07:00
|
|
|
else if (list_is_singular(&p->list)) {
|
2010-12-03 02:54:09 -07:00
|
|
|
/* This is the last child of an aggrprobe */
|
2010-12-03 02:53:50 -07:00
|
|
|
ap = list_entry(p->list.next, struct kprobe, list);
|
2009-01-06 15:41:52 -07:00
|
|
|
list_del(&p->list);
|
2010-12-03 02:53:50 -07:00
|
|
|
free_aggr_kprobe(ap);
|
2008-04-28 03:14:28 -06:00
|
|
|
}
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Otherwise, do nothing. */
|
2008-04-28 03:14:28 -06:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
int register_kprobes(struct kprobe **kps, int num)
|
2008-04-28 03:14:28 -06:00
|
|
|
{
|
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
if (num <= 0)
|
|
|
|
return -EINVAL;
|
|
|
|
for (i = 0; i < num; i++) {
|
2009-01-06 15:41:53 -07:00
|
|
|
ret = register_kprobe(kps[i]);
|
2008-06-12 16:21:35 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
if (i > 0)
|
|
|
|
unregister_kprobes(kps, i);
|
2008-04-28 03:14:28 -06:00
|
|
|
break;
|
2006-06-26 01:25:22 -06:00
|
|
|
}
|
2006-01-09 21:52:43 -07:00
|
|
|
}
|
2008-04-28 03:14:28 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(register_kprobes);
|
2008-04-28 03:14:28 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void unregister_kprobe(struct kprobe *p)
|
2008-04-28 03:14:28 -06:00
|
|
|
{
|
|
|
|
unregister_kprobes(&p, 1);
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kprobe);
|
2008-04-28 03:14:28 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void unregister_kprobes(struct kprobe **kps, int num)
|
2008-04-28 03:14:28 -06:00
|
|
|
{
|
|
|
|
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 16:20:36 -06:00
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kprobes);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-03-08 10:04:15 -07:00
|
|
|
int __weak kprobe_exceptions_notify(struct notifier_block *self,
|
|
|
|
unsigned long val, void *data)
|
2017-02-07 12:54:14 -07:00
|
|
|
{
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
2017-03-08 10:04:15 -07:00
|
|
|
NOKPROBE_SYMBOL(kprobe_exceptions_notify);
|
2017-02-07 12:54:14 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct notifier_block kprobe_exceptions_nb = {
|
2006-06-26 01:25:28 -06:00
|
|
|
.notifier_call = kprobe_exceptions_notify,
|
|
|
|
.priority = 0x7fffffff /* we need to be notified first */
|
|
|
|
};
|
|
|
|
|
2007-07-19 02:48:11 -06:00
|
|
|
unsigned long __weak arch_deref_entry_point(void *entry)
|
|
|
|
{
|
|
|
|
return (unsigned long)entry;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
int register_jprobes(struct jprobe **jps, int num)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-28 03:14:29 -06:00
|
|
|
struct jprobe *jp;
|
|
|
|
int ret = 0, i;
|
2007-07-19 02:48:11 -06:00
|
|
|
|
2008-04-28 03:14:29 -06:00
|
|
|
if (num <= 0)
|
2007-07-19 02:48:11 -06:00
|
|
|
return -EINVAL;
|
2008-04-28 03:14:29 -06:00
|
|
|
for (i = 0; i < num; i++) {
|
2010-09-14 19:04:27 -06:00
|
|
|
unsigned long addr, offset;
|
2008-04-28 03:14:29 -06:00
|
|
|
jp = jps[i];
|
|
|
|
addr = arch_deref_entry_point(jp->entry);
|
|
|
|
|
2010-09-14 19:04:27 -06:00
|
|
|
/* Verify probepoint is a function entry point */
|
|
|
|
if (kallsyms_lookup_size_offset(addr, NULL, &offset) &&
|
|
|
|
offset == 0) {
|
|
|
|
jp->kp.pre_handler = setjmp_pre_handler;
|
|
|
|
jp->kp.break_handler = longjmp_break_handler;
|
|
|
|
ret = register_kprobe(&jp->kp);
|
|
|
|
} else
|
|
|
|
ret = -EINVAL;
|
2010-09-14 19:04:26 -06:00
|
|
|
|
2008-06-12 16:21:35 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
if (i > 0)
|
|
|
|
unregister_jprobes(jps, i);
|
2008-04-28 03:14:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(register_jprobes);
|
2007-07-19 02:48:11 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
int register_jprobe(struct jprobe *jp)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
2009-01-06 15:41:53 -07:00
|
|
|
return register_jprobes(&jp, 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(register_jprobe);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void unregister_jprobe(struct jprobe *jp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-28 03:14:29 -06:00
|
|
|
unregister_jprobes(&jp, 1);
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_jprobe);
|
2008-04-28 03:14:29 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void unregister_jprobes(struct jprobe **jps, int num)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
|
|
|
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 16:20:36 -06:00
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_jprobes);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-04 15:28:37 -07:00
|
|
|
#ifdef CONFIG_KRETPROBES
|
2006-02-03 04:03:42 -07:00
|
|
|
/*
|
|
|
|
* This kprobe pre_handler is registered with every kretprobe. When probe
|
|
|
|
* hits it will set up the return probe.
|
|
|
|
*/
|
2014-04-17 02:18:21 -06:00
|
|
|
static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
|
2006-02-03 04:03:42 -07:00
|
|
|
{
|
|
|
|
struct kretprobe *rp = container_of(p, struct kretprobe, kp);
|
2008-07-25 02:46:04 -06:00
|
|
|
unsigned long hash, flags = 0;
|
|
|
|
struct kretprobe_instance *ri;
|
2006-02-03 04:03:42 -07:00
|
|
|
|
2014-08-03 21:10:16 -06:00
|
|
|
/*
|
|
|
|
* To avoid deadlocks, prohibit return probing in NMI contexts,
|
|
|
|
* just skip the probe and increase the (inexact) 'nmissed'
|
|
|
|
* statistical counter, so that the user is informed that
|
|
|
|
* something happened:
|
|
|
|
*/
|
|
|
|
if (unlikely(in_nmi())) {
|
|
|
|
rp->nmissed++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO: consider to only swap the RA after the last pre_handler fired */
|
2008-07-25 02:46:04 -06:00
|
|
|
hash = hash_ptr(current, KPROBE_HASH_BITS);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spin_lock_irqsave(&rp->lock, flags);
|
2007-05-08 01:34:14 -06:00
|
|
|
if (!hlist_empty(&rp->free_instances)) {
|
|
|
|
ri = hlist_entry(rp->free_instances.first,
|
2008-07-25 02:46:04 -06:00
|
|
|
struct kretprobe_instance, hlist);
|
|
|
|
hlist_del(&ri->hlist);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spin_unlock_irqrestore(&rp->lock, flags);
|
2008-07-25 02:46:04 -06:00
|
|
|
|
2007-05-08 01:34:14 -06:00
|
|
|
ri->rp = rp;
|
|
|
|
ri->task = current;
|
2008-02-06 02:38:22 -07:00
|
|
|
|
2012-02-03 16:37:16 -07:00
|
|
|
if (rp->entry_handler && rp->entry_handler(ri, regs)) {
|
|
|
|
raw_spin_lock_irqsave(&rp->lock, flags);
|
|
|
|
hlist_add_head(&ri->hlist, &rp->free_instances);
|
|
|
|
raw_spin_unlock_irqrestore(&rp->lock, flags);
|
2008-02-06 02:38:22 -07:00
|
|
|
return 0;
|
2012-02-03 16:37:16 -07:00
|
|
|
}
|
2008-02-06 02:38:22 -07:00
|
|
|
|
2007-05-08 01:34:14 -06:00
|
|
|
arch_prepare_kretprobe(ri, regs);
|
|
|
|
|
|
|
|
/* XXX(hch): why is there no hlist_move_head? */
|
2008-07-25 02:46:04 -06: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 01:34:14 -06:00
|
|
|
rp->nmissed++;
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_spin_unlock_irqrestore(&rp->lock, flags);
|
2008-07-25 02:46:04 -06:00
|
|
|
}
|
2006-02-03 04:03:42 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(pre_handler_kretprobe);
|
2006-02-03 04:03:42 -07:00
|
|
|
|
2017-02-22 06:53:37 -07:00
|
|
|
bool __weak arch_function_offset_within_entry(unsigned long offset)
|
|
|
|
{
|
|
|
|
return !offset;
|
|
|
|
}
|
|
|
|
|
2017-03-08 01:26:06 -07:00
|
|
|
bool function_offset_within_entry(kprobe_opcode_t *addr, const char *sym, unsigned long offset)
|
|
|
|
{
|
|
|
|
kprobe_opcode_t *kp_addr = _kprobe_addr(addr, sym, offset);
|
|
|
|
|
|
|
|
if (IS_ERR(kp_addr))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!kallsyms_lookup_size_offset((unsigned long)kp_addr, NULL, &offset) ||
|
|
|
|
!arch_function_offset_within_entry(offset))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
int 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 01:09:19 -06:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
struct kretprobe_instance *inst;
|
|
|
|
int i;
|
2008-03-04 15:29:44 -07:00
|
|
|
void *addr;
|
2017-02-22 06:53:37 -07:00
|
|
|
|
2017-03-08 01:26:06 -07:00
|
|
|
if (!function_offset_within_entry(rp->kp.addr, rp->kp.symbol_name, rp->kp.offset))
|
2017-02-22 06:53:37 -07:00
|
|
|
return -EINVAL;
|
2007-10-16 02:27:49 -06:00
|
|
|
|
|
|
|
if (kretprobe_blacklist_size) {
|
2008-03-04 15:29:44 -07:00
|
|
|
addr = kprobe_addr(&rp->kp);
|
2011-06-27 01:26:50 -06:00
|
|
|
if (IS_ERR(addr))
|
|
|
|
return PTR_ERR(addr);
|
2007-10-16 02:27:49 -06: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 01:09:19 -06:00
|
|
|
|
|
|
|
rp->kp.pre_handler = pre_handler_kretprobe;
|
2006-04-20 03:43:11 -06: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 01:09:19 -06:00
|
|
|
|
|
|
|
/* Pre-allocate memory for max kretprobe instances */
|
|
|
|
if (rp->maxactive <= 0) {
|
|
|
|
#ifdef CONFIG_PREEMPT
|
2009-12-21 05:02:24 -07:00
|
|
|
rp->maxactive = max_t(unsigned int, 10, 2*num_possible_cpus());
|
[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 01:09:19 -06:00
|
|
|
#else
|
2009-10-30 07:53:10 -06:00
|
|
|
rp->maxactive = num_possible_cpus();
|
[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 01:09:19 -06:00
|
|
|
#endif
|
|
|
|
}
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_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 01:09:19 -06:00
|
|
|
INIT_HLIST_HEAD(&rp->free_instances);
|
|
|
|
for (i = 0; i < rp->maxactive; i++) {
|
2008-02-06 02:38:22 -07: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 01:09:19 -06:00
|
|
|
if (inst == NULL) {
|
|
|
|
free_rp_inst(rp);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-07-25 02:46:04 -06: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 01:09:19 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
rp->nmissed = 0;
|
|
|
|
/* Establish function entry probe point */
|
2009-01-06 15:41:53 -07:00
|
|
|
ret = register_kprobe(&rp->kp);
|
2008-04-28 03:14:29 -06: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 01:09:19 -06:00
|
|
|
free_rp_inst(rp);
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-06 20:00:59 -06: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 01:09:19 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
int register_kretprobes(struct kretprobe **rps, int num)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
|
|
|
int ret = 0, i;
|
|
|
|
|
|
|
|
if (num <= 0)
|
|
|
|
return -EINVAL;
|
|
|
|
for (i = 0; i < num; i++) {
|
2009-01-06 15:41:53 -07:00
|
|
|
ret = register_kretprobe(rps[i]);
|
2008-06-12 16:21:35 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
if (i > 0)
|
|
|
|
unregister_kretprobes(rps, i);
|
2008-04-28 03:14:29 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(register_kretprobes);
|
2008-04-28 03:14:29 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void unregister_kretprobe(struct kretprobe *rp)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
|
|
|
unregister_kretprobes(&rp, 1);
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kretprobe);
|
2008-04-28 03:14:29 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void unregister_kretprobes(struct kretprobe **rps, int num)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
|
|
|
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-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kretprobes);
|
2008-04-28 03:14:29 -06:00
|
|
|
|
2008-03-04 15:28:37 -07:00
|
|
|
#else /* CONFIG_KRETPROBES */
|
2014-04-17 02:17:54 -06:00
|
|
|
int 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 01:09:19 -06:00
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2009-04-06 20:00:59 -06: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 01:09:19 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
int register_kretprobes(struct kretprobe **rps, int num)
|
2007-02-20 14:57:54 -07:00
|
|
|
{
|
2008-04-28 03:14:29 -06:00
|
|
|
return -ENOSYS;
|
2007-02-20 14:57:54 -07:00
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(register_kretprobes);
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void 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 01:09:19 -06:00
|
|
|
{
|
2008-04-28 03:14:29 -06:00
|
|
|
}
|
2009-04-06 20:00:59 -06: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 01:09:19 -06:00
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
void unregister_kretprobes(struct kretprobe **rps, int num)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
|
|
|
}
|
2009-04-06 20:00:59 -06:00
|
|
|
EXPORT_SYMBOL_GPL(unregister_kretprobes);
|
2007-05-08 01:34:14 -06:00
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
static int pre_handler_kretprobe(struct kprobe *p, struct pt_regs *regs)
|
2008-04-28 03:14:29 -06:00
|
|
|
{
|
|
|
|
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 01:09:19 -06:00
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(pre_handler_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 01:09:19 -06:00
|
|
|
|
2008-04-28 03:14:29 -06:00
|
|
|
#endif /* CONFIG_KRETPROBES */
|
|
|
|
|
2009-01-06 15:41:52 -07:00
|
|
|
/* Set the kprobe gone and remove its instruction buffer. */
|
2014-04-17 02:17:54 -06:00
|
|
|
static void kill_kprobe(struct kprobe *p)
|
2009-01-06 15:41:52 -07:00
|
|
|
{
|
|
|
|
struct kprobe *kp;
|
2009-04-06 20:01:02 -06:00
|
|
|
|
2009-01-06 15:41:52 -07:00
|
|
|
p->flags |= KPROBE_FLAG_GONE;
|
2010-02-25 06:34:07 -07:00
|
|
|
if (kprobe_aggrprobe(p)) {
|
2009-01-06 15:41:52 -07:00
|
|
|
/*
|
|
|
|
* 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;
|
2010-02-25 06:34:07 -07:00
|
|
|
kill_optimized_kprobe(p);
|
2009-01-06 15:41:52 -07:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2010-04-27 16:33:12 -06:00
|
|
|
/* Disable one kprobe */
|
2014-04-17 02:17:54 -06:00
|
|
|
int disable_kprobe(struct kprobe *kp)
|
2010-04-27 16:33:12 -06:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
2010-12-03 02:53:57 -07:00
|
|
|
/* Disable this kprobe */
|
|
|
|
if (__disable_kprobe(kp) == NULL)
|
2010-04-27 16:33:12 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(disable_kprobe);
|
|
|
|
|
|
|
|
/* Enable one kprobe */
|
2014-04-17 02:17:54 -06:00
|
|
|
int enable_kprobe(struct kprobe *kp)
|
2010-04-27 16:33:12 -06:00
|
|
|
{
|
|
|
|
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 (p != kp)
|
|
|
|
kp->flags &= ~KPROBE_FLAG_DISABLED;
|
|
|
|
|
|
|
|
if (!kprobes_all_disarmed && kprobe_disabled(p)) {
|
|
|
|
p->flags &= ~KPROBE_FLAG_DISABLED;
|
|
|
|
arm_kprobe(p);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(enable_kprobe);
|
|
|
|
|
2014-04-17 02:18:21 -06:00
|
|
|
void dump_kprobe(struct kprobe *kp)
|
2009-08-26 15:38:30 -06:00
|
|
|
{
|
|
|
|
printk(KERN_WARNING "Dumping kprobe:\n");
|
|
|
|
printk(KERN_WARNING "Name: %s\nAddress: %p\nOffset: %x\n",
|
|
|
|
kp->symbol_name, kp->addr, kp->offset);
|
|
|
|
}
|
2014-04-17 02:18:21 -06:00
|
|
|
NOKPROBE_SYMBOL(dump_kprobe);
|
2009-08-26 15:38:30 -06:00
|
|
|
|
2014-04-17 02:17:05 -06: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.
|
|
|
|
*/
|
|
|
|
static int __init populate_kprobe_blacklist(unsigned long *start,
|
|
|
|
unsigned long *end)
|
|
|
|
{
|
|
|
|
unsigned long *iter;
|
|
|
|
struct kprobe_blacklist_entry *ent;
|
2014-07-17 05:44:11 -06:00
|
|
|
unsigned long entry, offset = 0, size = 0;
|
2014-04-17 02:17:05 -06:00
|
|
|
|
|
|
|
for (iter = start; iter < end; iter++) {
|
2014-07-17 05:44:11 -06:00
|
|
|
entry = arch_deref_entry_point((void *)*iter);
|
|
|
|
|
|
|
|
if (!kernel_text_address(entry) ||
|
|
|
|
!kallsyms_lookup_size_offset(entry, &size, &offset)) {
|
|
|
|
pr_err("Failed to find blacklist at %p\n",
|
|
|
|
(void *)entry);
|
2014-04-17 02:17:05 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
ent = kmalloc(sizeof(*ent), GFP_KERNEL);
|
|
|
|
if (!ent)
|
|
|
|
return -ENOMEM;
|
2014-07-17 05:44:11 -06:00
|
|
|
ent->start_addr = entry;
|
|
|
|
ent->end_addr = entry + size;
|
2014-04-17 02:17:05 -06:00
|
|
|
INIT_LIST_HEAD(&ent->list);
|
|
|
|
list_add_tail(&ent->list, &kprobe_blacklist);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-06 15:41:52 -07:00
|
|
|
/* Module notifier call back, checking kprobes on the module */
|
2014-04-17 02:17:54 -06:00
|
|
|
static int kprobes_module_callback(struct notifier_block *nb,
|
|
|
|
unsigned long val, void *data)
|
2009-01-06 15:41:52 -07:00
|
|
|
{
|
|
|
|
struct module *mod = data;
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
2009-01-06 15:41:55 -07:00
|
|
|
int checkcore = (val == MODULE_STATE_GOING);
|
2009-01-06 15:41:52 -07:00
|
|
|
|
2009-01-06 15:41:55 -07:00
|
|
|
if (val != MODULE_STATE_GOING && val != MODULE_STATE_LIVE)
|
2009-01-06 15:41:52 -07:00
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
/*
|
2009-01-06 15:41:55 -07: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 15:41:52 -07:00
|
|
|
*/
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(p, head, hlist)
|
2009-01-06 15:41:55 -07:00
|
|
|
if (within_module_init((unsigned long)p->addr, mod) ||
|
|
|
|
(checkcore &&
|
|
|
|
within_module_core((unsigned long)p->addr, mod))) {
|
2009-01-06 15:41:52 -07:00
|
|
|
/*
|
|
|
|
* The vaddr this probe is installed will soon
|
|
|
|
* be vfreed buy not synced to disk. Hence,
|
|
|
|
* disarming the breakpoint isn't needed.
|
2017-05-16 12:58:35 -06:00
|
|
|
*
|
|
|
|
* Note, this will also move any optimized probes
|
|
|
|
* that are pending to be removed from their
|
|
|
|
* corresponding lists to the freeing_list and
|
|
|
|
* will not be touched by the delayed
|
|
|
|
* kprobe_optimizer work handler.
|
2009-01-06 15:41:52 -07:00
|
|
|
*/
|
|
|
|
kill_kprobe(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block kprobe_module_nb = {
|
|
|
|
.notifier_call = kprobes_module_callback,
|
|
|
|
.priority = 0
|
|
|
|
};
|
|
|
|
|
2014-04-17 02:17:05 -06:00
|
|
|
/* Markers of _kprobe_blacklist section */
|
|
|
|
extern unsigned long __start_kprobe_blacklist[];
|
|
|
|
extern unsigned long __stop_kprobe_blacklist[];
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int __init init_kprobes(void)
|
|
|
|
{
|
|
|
|
int i, err = 0;
|
|
|
|
|
|
|
|
/* 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 01:09:19 -06:00
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
2005-04-16 16:20:36 -06: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 01:09:19 -06:00
|
|
|
INIT_HLIST_HEAD(&kretprobe_inst_table[i]);
|
2009-07-25 08:09:17 -06:00
|
|
|
raw_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 01:09:19 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-04-17 02:17:05 -06:00
|
|
|
err = populate_kprobe_blacklist(__start_kprobe_blacklist,
|
|
|
|
__stop_kprobe_blacklist);
|
|
|
|
if (err) {
|
|
|
|
pr_err("kprobes: failed to populate blacklist: %d\n", err);
|
|
|
|
pr_err("Please take care of using kprobes.\n");
|
2008-04-28 03:14:26 -06:00
|
|
|
}
|
|
|
|
|
2007-10-16 02:27:49 -06:00
|
|
|
if (kretprobe_blacklist_size) {
|
|
|
|
/* lookup the function address from its name */
|
|
|
|
for (i = 0; kretprobe_blacklist[i].name != NULL; i++) {
|
2017-04-19 06:51:00 -06:00
|
|
|
kretprobe_blacklist[i].addr =
|
2017-04-19 06:51:01 -06:00
|
|
|
kprobe_lookup_name(kretprobe_blacklist[i].name, 0);
|
2007-10-16 02:27:49 -06:00
|
|
|
if (!kretprobe_blacklist[i].addr)
|
|
|
|
printk("kretprobe: lookup failed: %s\n",
|
|
|
|
kretprobe_blacklist[i].name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-25 06:34:15 -07:00
|
|
|
#if defined(CONFIG_OPTPROBES)
|
|
|
|
#if defined(__ARCH_WANT_KPROBES_INSN_SLOT)
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Init kprobe_optinsn_slots */
|
|
|
|
kprobe_optinsn_slots.insn_size = MAX_OPTINSN_SIZE;
|
|
|
|
#endif
|
2010-02-25 06:34:15 -07:00
|
|
|
/* By default, kprobes can be optimized */
|
|
|
|
kprobes_allow_optimization = true;
|
|
|
|
#endif
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2009-04-06 20:01:01 -06:00
|
|
|
/* By default, kprobes are armed */
|
|
|
|
kprobes_all_disarmed = false;
|
2007-05-08 01:34:16 -06:00
|
|
|
|
2005-07-05 19:54:50 -06: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 16:17:08 -06:00
|
|
|
if (!err)
|
|
|
|
err = register_die_notifier(&kprobe_exceptions_nb);
|
2009-01-06 15:41:52 -07:00
|
|
|
if (!err)
|
|
|
|
err = register_module_notifier(&kprobe_module_nb);
|
|
|
|
|
2008-07-25 02:46:04 -06: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 16:17:08 -06:00
|
|
|
|
2008-01-30 05:32:53 -07:00
|
|
|
if (!err)
|
|
|
|
init_test_probes();
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-02-20 14:57:54 -07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2014-04-17 02:17:54 -06:00
|
|
|
static void report_probe(struct seq_file *pi, struct kprobe *p,
|
2010-02-25 06:34:07 -07:00
|
|
|
const char *sym, int offset, char *modname, struct kprobe *pp)
|
2007-02-20 14:57:54 -07: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";
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2007-02-20 14:57:54 -07:00
|
|
|
if (sym)
|
2010-02-25 06:34:07 -07:00
|
|
|
seq_printf(pi, "%p %s %s+0x%x %s ",
|
2009-04-06 20:01:02 -06:00
|
|
|
p->addr, kprobe_type, sym, offset,
|
2010-02-25 06:34:07 -07:00
|
|
|
(modname ? modname : " "));
|
2007-02-20 14:57:54 -07:00
|
|
|
else
|
2010-02-25 06:34:07 -07:00
|
|
|
seq_printf(pi, "%p %s %p ",
|
|
|
|
p->addr, kprobe_type, p->addr);
|
|
|
|
|
|
|
|
if (!pp)
|
|
|
|
pp = p;
|
2012-06-05 04:28:32 -06:00
|
|
|
seq_printf(pi, "%s%s%s%s\n",
|
2010-02-25 06:34:07 -07:00
|
|
|
(kprobe_gone(p) ? "[GONE]" : ""),
|
|
|
|
((kprobe_disabled(p) && !kprobe_gone(p)) ? "[DISABLED]" : ""),
|
2012-06-05 04:28:32 -06:00
|
|
|
(kprobe_optimized(pp) ? "[OPTIMIZED]" : ""),
|
|
|
|
(kprobe_ftrace(pp) ? "[FTRACE]" : ""));
|
2007-02-20 14:57:54 -07:00
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void *kprobe_seq_start(struct seq_file *f, loff_t *pos)
|
2007-02-20 14:57:54 -07:00
|
|
|
{
|
|
|
|
return (*pos < KPROBE_TABLE_SIZE) ? pos : NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void *kprobe_seq_next(struct seq_file *f, void *v, loff_t *pos)
|
2007-02-20 14:57:54 -07:00
|
|
|
{
|
|
|
|
(*pos)++;
|
|
|
|
if (*pos >= KPROBE_TABLE_SIZE)
|
|
|
|
return NULL;
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void kprobe_seq_stop(struct seq_file *f, void *v)
|
2007-02-20 14:57:54 -07:00
|
|
|
{
|
|
|
|
/* Nothing to do */
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static int show_kprobe_addr(struct seq_file *pi, void *v)
|
2007-02-20 14:57:54 -07:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct kprobe *p, *kp;
|
|
|
|
const char *sym = NULL;
|
|
|
|
unsigned int i = *(loff_t *) v;
|
2007-05-08 01:28:41 -06:00
|
|
|
unsigned long offset = 0;
|
2013-11-12 16:10:23 -07:00
|
|
|
char *modname, namebuf[KSYM_NAME_LEN];
|
2007-02-20 14:57:54 -07:00
|
|
|
|
|
|
|
head = &kprobe_table[i];
|
|
|
|
preempt_disable();
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(p, head, hlist) {
|
2007-05-08 01:28:41 -06:00
|
|
|
sym = kallsyms_lookup((unsigned long)p->addr, NULL,
|
2007-02-20 14:57:54 -07:00
|
|
|
&offset, &modname, namebuf);
|
2010-02-25 06:34:07 -07:00
|
|
|
if (kprobe_aggrprobe(p)) {
|
2007-02-20 14:57:54 -07:00
|
|
|
list_for_each_entry_rcu(kp, &p->list, list)
|
2010-02-25 06:34:07 -07:00
|
|
|
report_probe(pi, kp, sym, offset, modname, p);
|
2007-02-20 14:57:54 -07:00
|
|
|
} else
|
2010-02-25 06:34:07 -07:00
|
|
|
report_probe(pi, p, sym, offset, modname, NULL);
|
2007-02-20 14:57:54 -07:00
|
|
|
}
|
|
|
|
preempt_enable();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-22 17:43:43 -06:00
|
|
|
static const struct seq_operations kprobes_seq_ops = {
|
2007-02-20 14:57:54 -07:00
|
|
|
.start = kprobe_seq_start,
|
|
|
|
.next = kprobe_seq_next,
|
|
|
|
.stop = kprobe_seq_stop,
|
|
|
|
.show = show_kprobe_addr
|
|
|
|
};
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static int kprobes_open(struct inode *inode, struct file *filp)
|
2007-02-20 14:57:54 -07:00
|
|
|
{
|
|
|
|
return seq_open(filp, &kprobes_seq_ops);
|
|
|
|
}
|
|
|
|
|
2009-10-01 16:43:56 -06:00
|
|
|
static const struct file_operations debugfs_kprobes_operations = {
|
2007-02-20 14:57:54 -07:00
|
|
|
.open = kprobes_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2014-04-17 02:18:49 -06:00
|
|
|
/* kprobes/blacklist -- shows which functions can not be probed */
|
|
|
|
static void *kprobe_blacklist_seq_start(struct seq_file *m, loff_t *pos)
|
|
|
|
{
|
|
|
|
return seq_list_start(&kprobe_blacklist, *pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *kprobe_blacklist_seq_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
return seq_list_next(v, &kprobe_blacklist, pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int kprobe_blacklist_seq_show(struct seq_file *m, void *v)
|
|
|
|
{
|
|
|
|
struct kprobe_blacklist_entry *ent =
|
|
|
|
list_entry(v, struct kprobe_blacklist_entry, list);
|
|
|
|
|
|
|
|
seq_printf(m, "0x%p-0x%p\t%ps\n", (void *)ent->start_addr,
|
|
|
|
(void *)ent->end_addr, (void *)ent->start_addr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct seq_operations kprobe_blacklist_seq_ops = {
|
|
|
|
.start = kprobe_blacklist_seq_start,
|
|
|
|
.next = kprobe_blacklist_seq_next,
|
|
|
|
.stop = kprobe_seq_stop, /* Reuse void function */
|
|
|
|
.show = kprobe_blacklist_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int kprobe_blacklist_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
return seq_open(filp, &kprobe_blacklist_seq_ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations debugfs_kprobe_blacklist_ops = {
|
|
|
|
.open = kprobe_blacklist_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void arm_all_kprobes(void)
|
2007-05-08 01:34:16 -06:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
2009-04-06 20:01:01 -06:00
|
|
|
/* If kprobes are armed, just return */
|
|
|
|
if (!kprobes_all_disarmed)
|
2007-05-08 01:34:16 -06:00
|
|
|
goto already_enabled;
|
|
|
|
|
2015-02-13 15:40:24 -07:00
|
|
|
/*
|
|
|
|
* optimize_kprobe() called by arm_kprobe() checks
|
|
|
|
* kprobes_all_disarmed, so set kprobes_all_disarmed before
|
|
|
|
* arm_kprobe.
|
|
|
|
*/
|
|
|
|
kprobes_all_disarmed = false;
|
2010-02-25 06:34:07 -07:00
|
|
|
/* Arming kprobes doesn't optimize kprobe itself */
|
2007-05-08 01:34:16 -06:00
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(p, head, hlist)
|
2009-04-06 20:01:02 -06:00
|
|
|
if (!kprobe_disabled(p))
|
2012-06-05 04:28:32 -06:00
|
|
|
arm_kprobe(p);
|
2007-05-08 01:34:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_INFO "Kprobes globally enabled\n");
|
|
|
|
|
|
|
|
already_enabled:
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static void disarm_all_kprobes(void)
|
2007-05-08 01:34:16 -06:00
|
|
|
{
|
|
|
|
struct hlist_head *head;
|
|
|
|
struct kprobe *p;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
mutex_lock(&kprobe_mutex);
|
|
|
|
|
2009-04-06 20:01:01 -06:00
|
|
|
/* If kprobes are already disarmed, just return */
|
2010-12-03 02:54:09 -07:00
|
|
|
if (kprobes_all_disarmed) {
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
return;
|
|
|
|
}
|
2007-05-08 01:34:16 -06:00
|
|
|
|
2009-04-06 20:01:01 -06:00
|
|
|
kprobes_all_disarmed = true;
|
2007-05-08 01:34:16 -06:00
|
|
|
printk(KERN_INFO "Kprobes globally disabled\n");
|
2010-02-25 06:34:07 -07:00
|
|
|
|
2007-05-08 01:34:16 -06:00
|
|
|
for (i = 0; i < KPROBE_TABLE_SIZE; i++) {
|
|
|
|
head = &kprobe_table[i];
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-27 18:06:00 -07:00
|
|
|
hlist_for_each_entry_rcu(p, head, hlist) {
|
2009-04-06 20:01:02 -06:00
|
|
|
if (!arch_trampoline_kprobe(p) && !kprobe_disabled(p))
|
2012-06-05 04:28:32 -06:00
|
|
|
disarm_kprobe(p, false);
|
2007-05-08 01:34:16 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&kprobe_mutex);
|
|
|
|
|
2010-12-03 02:54:09 -07:00
|
|
|
/* Wait for disarming all kprobes by optimizer */
|
|
|
|
wait_for_kprobe_optimizer();
|
2007-05-08 01:34:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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-06 20:01:01 -06:00
|
|
|
if (!kprobes_all_disarmed)
|
2007-05-08 01:34:16 -06: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];
|
2012-01-12 18:17:11 -07:00
|
|
|
size_t buf_size;
|
2007-05-08 01:34:16 -06:00
|
|
|
|
|
|
|
buf_size = min(count, (sizeof(buf)-1));
|
|
|
|
if (copy_from_user(buf, user_buf, buf_size))
|
|
|
|
return -EFAULT;
|
|
|
|
|
2013-07-03 16:05:39 -06:00
|
|
|
buf[buf_size] = '\0';
|
2007-05-08 01:34:16 -06:00
|
|
|
switch (buf[0]) {
|
|
|
|
case 'y':
|
|
|
|
case 'Y':
|
|
|
|
case '1':
|
2009-04-06 20:01:01 -06:00
|
|
|
arm_all_kprobes();
|
2007-05-08 01:34:16 -06:00
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
case 'N':
|
|
|
|
case '0':
|
2009-04-06 20:01:01 -06:00
|
|
|
disarm_all_kprobes();
|
2007-05-08 01:34:16 -06:00
|
|
|
break;
|
2013-07-03 16:05:39 -06:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
2007-05-08 01:34:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2009-10-01 16:43:56 -06:00
|
|
|
static const struct file_operations fops_kp = {
|
2007-05-08 01:34:16 -06:00
|
|
|
.read = read_enabled_file_bool,
|
|
|
|
.write = write_enabled_file_bool,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-15 10:52:59 -06:00
|
|
|
.llseek = default_llseek,
|
2007-05-08 01:34:16 -06:00
|
|
|
};
|
|
|
|
|
2014-04-17 02:17:54 -06:00
|
|
|
static int __init debugfs_kprobe_init(void)
|
2007-02-20 14:57:54 -07:00
|
|
|
{
|
|
|
|
struct dentry *dir, *file;
|
2007-05-08 01:34:16 -06:00
|
|
|
unsigned int value = 1;
|
2007-02-20 14:57:54 -07:00
|
|
|
|
|
|
|
dir = debugfs_create_dir("kprobes", NULL);
|
|
|
|
if (!dir)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-05-08 01:27:01 -06:00
|
|
|
file = debugfs_create_file("list", 0444, dir, NULL,
|
2007-02-20 14:57:54 -07:00
|
|
|
&debugfs_kprobes_operations);
|
2014-04-17 02:18:49 -06:00
|
|
|
if (!file)
|
|
|
|
goto error;
|
2007-02-20 14:57:54 -07:00
|
|
|
|
2007-05-08 01:34:16 -06:00
|
|
|
file = debugfs_create_file("enabled", 0600, dir,
|
|
|
|
&value, &fops_kp);
|
2014-04-17 02:18:49 -06:00
|
|
|
if (!file)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
file = debugfs_create_file("blacklist", 0444, dir, NULL,
|
|
|
|
&debugfs_kprobe_blacklist_ops);
|
|
|
|
if (!file)
|
|
|
|
goto error;
|
2007-05-08 01:34:16 -06:00
|
|
|
|
2007-02-20 14:57:54 -07:00
|
|
|
return 0;
|
2014-04-17 02:18:49 -06:00
|
|
|
|
|
|
|
error:
|
|
|
|
debugfs_remove(dir);
|
|
|
|
return -ENOMEM;
|
2007-02-20 14:57:54 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(debugfs_kprobe_init);
|
|
|
|
#endif /* CONFIG_DEBUG_FS */
|
|
|
|
|
|
|
|
module_init(init_kprobes);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-04-06 20:00:59 -06:00
|
|
|
/* defined in arch/.../kernel/kprobes.c */
|
2005-04-16 16:20:36 -06:00
|
|
|
EXPORT_SYMBOL_GPL(jprobe_return);
|