2008-05-12 19:20:42 +00:00
|
|
|
/*
|
|
|
|
|
* Infrastructure for profiling code inserted by 'gcc -pg'.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
|
|
|
|
|
* Copyright (C) 2004-2008 Ingo Molnar <mingo@redhat.com>
|
|
|
|
|
*
|
|
|
|
|
* Originally ported from the -rt patch by:
|
|
|
|
|
* Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
|
|
|
|
|
*
|
|
|
|
|
* Based on code in the latency_tracer, that is:
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2004-2006 Ingo Molnar
|
|
|
|
|
* Copyright (C) 2004 William Lee Irwin III
|
|
|
|
|
*/
|
|
|
|
|
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
#include <linux/stop_machine.h>
|
|
|
|
|
#include <linux/clocksource.h>
|
|
|
|
|
#include <linux/kallsyms.h>
|
2008-05-12 19:20:43 +00:00
|
|
|
#include <linux/seq_file.h>
|
|
|
|
|
#include <linux/debugfs.h>
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
#include <linux/hardirq.h>
|
2008-02-23 15:55:50 +00:00
|
|
|
#include <linux/kthread.h>
|
2008-05-12 19:20:43 +00:00
|
|
|
#include <linux/uaccess.h>
|
2008-06-21 18:20:29 +00:00
|
|
|
#include <linux/kprobes.h>
|
2008-02-23 15:55:50 +00:00
|
|
|
#include <linux/ftrace.h>
|
2008-05-12 19:20:43 +00:00
|
|
|
#include <linux/sysctl.h>
|
2008-05-12 19:20:43 +00:00
|
|
|
#include <linux/ctype.h>
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
#include <linux/list.h>
|
|
|
|
|
|
2008-06-21 18:17:27 +00:00
|
|
|
#include <asm/ftrace.h>
|
|
|
|
|
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
#include "trace.h"
|
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-10-23 13:33:03 +00:00
|
|
|
#define FTRACE_WARN_ON(cond) \
|
|
|
|
|
do { \
|
|
|
|
|
if (WARN_ON(cond)) \
|
|
|
|
|
ftrace_kill(); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
#define FTRACE_WARN_ON_ONCE(cond) \
|
|
|
|
|
do { \
|
|
|
|
|
if (WARN_ON_ONCE(cond)) \
|
|
|
|
|
ftrace_kill(); \
|
|
|
|
|
} while (0)
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
/* ftrace_enabled is a method to turn ftrace on or off */
|
|
|
|
|
int ftrace_enabled __read_mostly;
|
2008-05-12 19:20:43 +00:00
|
|
|
static int last_ftrace_enabled;
|
2008-05-12 19:20:43 +00:00
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
/*
|
|
|
|
|
* ftrace_disabled is set when an anomaly is discovered.
|
|
|
|
|
* ftrace_disabled is much stronger than ftrace_enabled.
|
|
|
|
|
*/
|
|
|
|
|
static int ftrace_disabled __read_mostly;
|
|
|
|
|
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
static DEFINE_SPINLOCK(ftrace_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
static DEFINE_MUTEX(ftrace_sysctl_lock);
|
|
|
|
|
|
2008-05-12 19:20:42 +00:00
|
|
|
static struct ftrace_ops ftrace_list_end __read_mostly =
|
|
|
|
|
{
|
|
|
|
|
.func = ftrace_stub,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct ftrace_ops *ftrace_list __read_mostly = &ftrace_list_end;
|
|
|
|
|
ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
|
|
|
|
|
|
2008-05-22 08:37:48 +00:00
|
|
|
static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
|
2008-05-12 19:20:42 +00:00
|
|
|
{
|
|
|
|
|
struct ftrace_ops *op = ftrace_list;
|
|
|
|
|
|
|
|
|
|
/* in case someone actually ports this to alpha! */
|
|
|
|
|
read_barrier_depends();
|
|
|
|
|
|
|
|
|
|
while (op != &ftrace_list_end) {
|
|
|
|
|
/* silly alpha */
|
|
|
|
|
read_barrier_depends();
|
|
|
|
|
op->func(ip, parent_ip);
|
|
|
|
|
op = op->next;
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
* clear_ftrace_function - reset the ftrace function
|
2008-05-12 19:20:42 +00:00
|
|
|
*
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
* This NULLs the ftrace function and in essence stops
|
|
|
|
|
* tracing. There may be lag
|
2008-05-12 19:20:42 +00:00
|
|
|
*/
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
void clear_ftrace_function(void)
|
2008-05-12 19:20:42 +00:00
|
|
|
{
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
ftrace_trace_function = ftrace_stub;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static int __register_ftrace_function(struct ftrace_ops *ops)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-08-16 01:40:05 +00:00
|
|
|
/* should not be called from interrupt context */
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
spin_lock(&ftrace_lock);
|
2008-05-12 19:20:42 +00:00
|
|
|
|
|
|
|
|
ops->next = ftrace_list;
|
|
|
|
|
/*
|
|
|
|
|
* We are entering ops into the ftrace_list but another
|
|
|
|
|
* CPU might be walking that list. We need to make sure
|
|
|
|
|
* the ops->next pointer is valid before another CPU sees
|
|
|
|
|
* the ops pointer included into the ftrace_list.
|
|
|
|
|
*/
|
|
|
|
|
smp_wmb();
|
|
|
|
|
ftrace_list = ops;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
if (ftrace_enabled) {
|
|
|
|
|
/*
|
|
|
|
|
* For one func, simply call it directly.
|
|
|
|
|
* For more than one func, call the chain.
|
|
|
|
|
*/
|
|
|
|
|
if (ops->next == &ftrace_list_end)
|
|
|
|
|
ftrace_trace_function = ops->func;
|
|
|
|
|
else
|
|
|
|
|
ftrace_trace_function = ftrace_list_func;
|
|
|
|
|
}
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
|
|
|
|
spin_unlock(&ftrace_lock);
|
2008-05-12 19:20:42 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static int __unregister_ftrace_function(struct ftrace_ops *ops)
|
2008-05-12 19:20:42 +00:00
|
|
|
{
|
|
|
|
|
struct ftrace_ops **p;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2008-08-16 01:40:05 +00:00
|
|
|
/* should not be called from interrupt context */
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
spin_lock(&ftrace_lock);
|
2008-05-12 19:20:42 +00:00
|
|
|
|
|
|
|
|
/*
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
* If we are removing the last function, then simply point
|
|
|
|
|
* to the ftrace_stub.
|
2008-05-12 19:20:42 +00:00
|
|
|
*/
|
|
|
|
|
if (ftrace_list == ops && ops->next == &ftrace_list_end) {
|
|
|
|
|
ftrace_trace_function = ftrace_stub;
|
|
|
|
|
ftrace_list = &ftrace_list_end;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (p = &ftrace_list; *p != &ftrace_list_end; p = &(*p)->next)
|
|
|
|
|
if (*p == ops)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (*p != ops) {
|
|
|
|
|
ret = -1;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*p = (*p)->next;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
if (ftrace_enabled) {
|
|
|
|
|
/* If we only have one func left, then call that directly */
|
|
|
|
|
if (ftrace_list == &ftrace_list_end ||
|
|
|
|
|
ftrace_list->next == &ftrace_list_end)
|
|
|
|
|
ftrace_trace_function = ftrace_list->func;
|
|
|
|
|
}
|
2008-05-12 19:20:42 +00:00
|
|
|
|
|
|
|
|
out:
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
spin_unlock(&ftrace_lock);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
2008-08-16 01:40:05 +00:00
|
|
|
#ifndef CONFIG_FTRACE_MCOUNT_RECORD
|
2008-10-23 13:33:05 +00:00
|
|
|
# error Dynamic ftrace depends on MCOUNT_RECORD
|
2008-08-16 01:40:05 +00:00
|
|
|
#endif
|
|
|
|
|
|
2008-09-20 08:00:37 +00:00
|
|
|
/*
|
|
|
|
|
* Since MCOUNT_ADDR may point to mcount itself, we do not want
|
|
|
|
|
* to get it confused by reading a reference in the code as we
|
|
|
|
|
* are parsing on objcopy output of text. Use a variable for
|
|
|
|
|
* it instead.
|
|
|
|
|
*/
|
|
|
|
|
static unsigned long mcount_addr = MCOUNT_ADDR;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
enum {
|
|
|
|
|
FTRACE_ENABLE_CALLS = (1 << 0),
|
|
|
|
|
FTRACE_DISABLE_CALLS = (1 << 1),
|
|
|
|
|
FTRACE_UPDATE_TRACE_FUNC = (1 << 2),
|
|
|
|
|
FTRACE_ENABLE_MCOUNT = (1 << 3),
|
|
|
|
|
FTRACE_DISABLE_MCOUNT = (1 << 4),
|
|
|
|
|
};
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
static int ftrace_filtered;
|
2008-06-21 18:17:53 +00:00
|
|
|
static int tracing_on;
|
2008-05-12 19:20:43 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
static LIST_HEAD(ftrace_new_addrs);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
static DEFINE_MUTEX(ftrace_regex_lock);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
struct ftrace_page {
|
|
|
|
|
struct ftrace_page *next;
|
2008-05-14 05:06:56 +00:00
|
|
|
unsigned long index;
|
2008-05-12 19:20:43 +00:00
|
|
|
struct dyn_ftrace records[];
|
2008-05-14 05:06:56 +00:00
|
|
|
};
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
#define ENTRIES_PER_PAGE \
|
|
|
|
|
((PAGE_SIZE - sizeof(struct ftrace_page)) / sizeof(struct dyn_ftrace))
|
|
|
|
|
|
|
|
|
|
/* estimate from running different kernels */
|
|
|
|
|
#define NR_TO_INIT 10000
|
|
|
|
|
|
|
|
|
|
static struct ftrace_page *ftrace_pages_start;
|
|
|
|
|
static struct ftrace_page *ftrace_pages;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
static struct dyn_ftrace *ftrace_free_records;
|
|
|
|
|
|
2008-06-21 18:17:53 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_KPROBES
|
2008-10-24 10:47:10 +00:00
|
|
|
|
|
|
|
|
static int frozen_record_count;
|
|
|
|
|
|
2008-06-21 18:17:53 +00:00
|
|
|
static inline void freeze_record(struct dyn_ftrace *rec)
|
|
|
|
|
{
|
|
|
|
|
if (!(rec->flags & FTRACE_FL_FROZEN)) {
|
|
|
|
|
rec->flags |= FTRACE_FL_FROZEN;
|
|
|
|
|
frozen_record_count++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void unfreeze_record(struct dyn_ftrace *rec)
|
|
|
|
|
{
|
|
|
|
|
if (rec->flags & FTRACE_FL_FROZEN) {
|
|
|
|
|
rec->flags &= ~FTRACE_FL_FROZEN;
|
|
|
|
|
frozen_record_count--;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int record_frozen(struct dyn_ftrace *rec)
|
|
|
|
|
{
|
|
|
|
|
return rec->flags & FTRACE_FL_FROZEN;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
# define freeze_record(rec) ({ 0; })
|
|
|
|
|
# define unfreeze_record(rec) ({ 0; })
|
|
|
|
|
# define record_frozen(rec) ({ 0; })
|
|
|
|
|
#endif /* CONFIG_KPROBES */
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void ftrace_free_rec(struct dyn_ftrace *rec)
|
2008-05-12 19:20:48 +00:00
|
|
|
{
|
|
|
|
|
rec->ip = (unsigned long)ftrace_free_records;
|
|
|
|
|
ftrace_free_records = rec;
|
|
|
|
|
rec->flags |= FTRACE_FL_FREE;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-15 02:47:19 +00:00
|
|
|
void ftrace_release(void *start, unsigned long size)
|
|
|
|
|
{
|
|
|
|
|
struct dyn_ftrace *rec;
|
|
|
|
|
struct ftrace_page *pg;
|
|
|
|
|
unsigned long s = (unsigned long)start;
|
|
|
|
|
unsigned long e = s + size;
|
|
|
|
|
int i;
|
|
|
|
|
|
2008-08-16 01:40:04 +00:00
|
|
|
if (ftrace_disabled || !start)
|
2008-08-15 02:47:19 +00:00
|
|
|
return;
|
|
|
|
|
|
2008-08-16 01:40:05 +00:00
|
|
|
/* should not be called from interrupt context */
|
2008-08-15 02:47:19 +00:00
|
|
|
spin_lock(&ftrace_lock);
|
|
|
|
|
|
|
|
|
|
for (pg = ftrace_pages_start; pg; pg = pg->next) {
|
|
|
|
|
for (i = 0; i < pg->index; i++) {
|
|
|
|
|
rec = &pg->records[i];
|
|
|
|
|
|
|
|
|
|
if ((rec->ip >= s) && (rec->ip < e))
|
|
|
|
|
ftrace_free_rec(rec);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
spin_unlock(&ftrace_lock);
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static struct dyn_ftrace *ftrace_alloc_dyn_node(unsigned long ip)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
2008-05-12 19:20:48 +00:00
|
|
|
struct dyn_ftrace *rec;
|
|
|
|
|
|
|
|
|
|
/* First check for freed records */
|
|
|
|
|
if (ftrace_free_records) {
|
|
|
|
|
rec = ftrace_free_records;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!(rec->flags & FTRACE_FL_FREE))) {
|
2008-10-23 13:33:03 +00:00
|
|
|
FTRACE_WARN_ON_ONCE(1);
|
2008-05-12 19:20:48 +00:00
|
|
|
ftrace_free_records = NULL;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ftrace_free_records = (void *)rec->ip;
|
|
|
|
|
memset(rec, 0, sizeof(*rec));
|
|
|
|
|
return rec;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
if (ftrace_pages->index == ENTRIES_PER_PAGE) {
|
2008-10-23 13:33:07 +00:00
|
|
|
if (!ftrace_pages->next) {
|
|
|
|
|
/* allocate another page */
|
|
|
|
|
ftrace_pages->next =
|
|
|
|
|
(void *)get_zeroed_page(GFP_KERNEL);
|
|
|
|
|
if (!ftrace_pages->next)
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_pages = ftrace_pages->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return &ftrace_pages->records[ftrace_pages->index++];
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
static struct dyn_ftrace *
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_record_ip(unsigned long ip)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-10-23 13:33:07 +00:00
|
|
|
struct dyn_ftrace *rec;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (!ftrace_enabled || ftrace_disabled)
|
2008-10-23 13:33:07 +00:00
|
|
|
return NULL;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
rec = ftrace_alloc_dyn_node(ip);
|
|
|
|
|
if (!rec)
|
|
|
|
|
return NULL;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
rec->ip = ip;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
list_add(&rec->list, &ftrace_new_addrs);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
return rec;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:50 +00:00
|
|
|
#define FTRACE_ADDR ((long)(ftrace_caller))
|
2008-05-12 19:20:43 +00:00
|
|
|
|
2008-06-01 16:17:30 +00:00
|
|
|
static int
|
2008-05-12 19:20:43 +00:00
|
|
|
__ftrace_replace_code(struct dyn_ftrace *rec,
|
|
|
|
|
unsigned char *old, unsigned char *new, int enable)
|
|
|
|
|
{
|
2008-05-22 15:46:33 +00:00
|
|
|
unsigned long ip, fl;
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
ip = rec->ip;
|
|
|
|
|
|
|
|
|
|
if (ftrace_filtered && enable) {
|
|
|
|
|
/*
|
|
|
|
|
* If filtering is on:
|
|
|
|
|
*
|
|
|
|
|
* If this record is set to be filtered and
|
|
|
|
|
* is enabled then do nothing.
|
|
|
|
|
*
|
|
|
|
|
* If this record is set to be filtered and
|
|
|
|
|
* it is not enabled, enable it.
|
|
|
|
|
*
|
|
|
|
|
* If this record is not set to be filtered
|
|
|
|
|
* and it is not enabled do nothing.
|
|
|
|
|
*
|
2008-05-22 15:46:33 +00:00
|
|
|
* If this record is set not to trace then
|
|
|
|
|
* do nothing.
|
|
|
|
|
*
|
2008-06-14 06:29:39 +00:00
|
|
|
* If this record is set not to trace and
|
|
|
|
|
* it is enabled then disable it.
|
|
|
|
|
*
|
2008-05-12 19:20:43 +00:00
|
|
|
* If this record is not set to be filtered and
|
|
|
|
|
* it is enabled, disable it.
|
|
|
|
|
*/
|
2008-06-14 06:29:39 +00:00
|
|
|
|
|
|
|
|
fl = rec->flags & (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE |
|
|
|
|
|
FTRACE_FL_ENABLED);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
if ((fl == (FTRACE_FL_FILTER | FTRACE_FL_ENABLED)) ||
|
2008-06-14 06:29:39 +00:00
|
|
|
(fl == (FTRACE_FL_FILTER | FTRACE_FL_NOTRACE)) ||
|
|
|
|
|
!fl || (fl == FTRACE_FL_NOTRACE))
|
2008-06-01 16:17:30 +00:00
|
|
|
return 0;
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* If it is enabled disable it,
|
|
|
|
|
* otherwise enable it!
|
|
|
|
|
*/
|
2008-06-14 06:29:39 +00:00
|
|
|
if (fl & FTRACE_FL_ENABLED) {
|
2008-05-12 19:20:43 +00:00
|
|
|
/* swap new and old */
|
|
|
|
|
new = old;
|
|
|
|
|
old = ftrace_call_replace(ip, FTRACE_ADDR);
|
|
|
|
|
rec->flags &= ~FTRACE_FL_ENABLED;
|
|
|
|
|
} else {
|
|
|
|
|
new = ftrace_call_replace(ip, FTRACE_ADDR);
|
|
|
|
|
rec->flags |= FTRACE_FL_ENABLED;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
if (enable) {
|
|
|
|
|
/*
|
|
|
|
|
* If this record is set not to trace and is
|
|
|
|
|
* not enabled, do nothing.
|
|
|
|
|
*/
|
|
|
|
|
fl = rec->flags & (FTRACE_FL_NOTRACE | FTRACE_FL_ENABLED);
|
|
|
|
|
if (fl == FTRACE_FL_NOTRACE)
|
2008-06-01 16:17:30 +00:00
|
|
|
return 0;
|
2008-05-22 15:46:33 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
new = ftrace_call_replace(ip, FTRACE_ADDR);
|
2008-05-22 15:46:33 +00:00
|
|
|
} else
|
2008-05-12 19:20:43 +00:00
|
|
|
old = ftrace_call_replace(ip, FTRACE_ADDR);
|
|
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
|
if (rec->flags & FTRACE_FL_ENABLED)
|
2008-06-01 16:17:30 +00:00
|
|
|
return 0;
|
2008-05-12 19:20:43 +00:00
|
|
|
rec->flags |= FTRACE_FL_ENABLED;
|
|
|
|
|
} else {
|
|
|
|
|
if (!(rec->flags & FTRACE_FL_ENABLED))
|
2008-06-01 16:17:30 +00:00
|
|
|
return 0;
|
2008-05-12 19:20:43 +00:00
|
|
|
rec->flags &= ~FTRACE_FL_ENABLED;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-01 16:17:30 +00:00
|
|
|
return ftrace_modify_code(ip, old, new);
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void ftrace_replace_code(int enable)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
2008-06-01 16:17:30 +00:00
|
|
|
int i, failed;
|
2008-05-12 19:20:43 +00:00
|
|
|
unsigned char *new = NULL, *old = NULL;
|
|
|
|
|
struct dyn_ftrace *rec;
|
|
|
|
|
struct ftrace_page *pg;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
if (enable)
|
2008-05-12 19:20:43 +00:00
|
|
|
old = ftrace_nop_replace();
|
|
|
|
|
else
|
|
|
|
|
new = ftrace_nop_replace();
|
|
|
|
|
|
|
|
|
|
for (pg = ftrace_pages_start; pg; pg = pg->next) {
|
|
|
|
|
for (i = 0; i < pg->index; i++) {
|
|
|
|
|
rec = &pg->records[i];
|
|
|
|
|
|
|
|
|
|
/* don't modify code that has already faulted */
|
|
|
|
|
if (rec->flags & FTRACE_FL_FAILED)
|
|
|
|
|
continue;
|
|
|
|
|
|
2008-06-21 18:20:29 +00:00
|
|
|
/* ignore updates to this record's mcount site */
|
2008-06-26 17:21:51 +00:00
|
|
|
if (get_kprobe((void *)rec->ip)) {
|
|
|
|
|
freeze_record(rec);
|
2008-06-21 18:20:29 +00:00
|
|
|
continue;
|
2008-06-26 17:21:51 +00:00
|
|
|
} else {
|
|
|
|
|
unfreeze_record(rec);
|
|
|
|
|
}
|
2008-06-21 18:20:29 +00:00
|
|
|
|
2008-06-01 16:17:30 +00:00
|
|
|
failed = __ftrace_replace_code(rec, old, new, enable);
|
|
|
|
|
if (failed && (rec->flags & FTRACE_FL_CONVERTED)) {
|
|
|
|
|
rec->flags |= FTRACE_FL_FAILED;
|
|
|
|
|
if ((system_state == SYSTEM_BOOTING) ||
|
2008-06-03 03:03:41 +00:00
|
|
|
!core_kernel_text(rec->ip)) {
|
2008-06-01 16:17:30 +00:00
|
|
|
ftrace_free_rec(rec);
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-09-22 21:55:47 +00:00
|
|
|
static void print_ip_ins(const char *fmt, unsigned char *p)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
printk(KERN_CONT "%s", fmt);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MCOUNT_INSN_SIZE; i++)
|
|
|
|
|
printk(KERN_CONT "%s%02x", i ? ":" : "", p[i]);
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-24 18:40:04 +00:00
|
|
|
static int
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_code_disable(struct dyn_ftrace *rec)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
unsigned long ip;
|
|
|
|
|
unsigned char *nop, *call;
|
2008-10-23 13:32:59 +00:00
|
|
|
int ret;
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
ip = rec->ip;
|
|
|
|
|
|
|
|
|
|
nop = ftrace_nop_replace();
|
2008-08-28 03:24:15 +00:00
|
|
|
call = ftrace_call_replace(ip, mcount_addr);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
2008-10-23 13:32:59 +00:00
|
|
|
ret = ftrace_modify_code(ip, call, nop);
|
|
|
|
|
if (ret) {
|
|
|
|
|
switch (ret) {
|
|
|
|
|
case -EFAULT:
|
2008-10-23 13:33:03 +00:00
|
|
|
FTRACE_WARN_ON_ONCE(1);
|
2008-09-22 21:55:47 +00:00
|
|
|
pr_info("ftrace faulted on modifying ");
|
|
|
|
|
print_ip_sym(ip);
|
|
|
|
|
break;
|
2008-10-23 13:32:59 +00:00
|
|
|
case -EINVAL:
|
2008-10-23 13:33:03 +00:00
|
|
|
FTRACE_WARN_ON_ONCE(1);
|
2008-09-22 21:55:47 +00:00
|
|
|
pr_info("ftrace failed to modify ");
|
|
|
|
|
print_ip_sym(ip);
|
|
|
|
|
print_ip_ins(" expected: ", call);
|
|
|
|
|
print_ip_ins(" actual: ", (unsigned char *)ip);
|
|
|
|
|
print_ip_ins(" replace: ", nop);
|
|
|
|
|
printk(KERN_CONT "\n");
|
|
|
|
|
break;
|
2008-10-23 13:32:59 +00:00
|
|
|
case -EPERM:
|
2008-10-23 13:33:03 +00:00
|
|
|
FTRACE_WARN_ON_ONCE(1);
|
2008-10-23 13:32:59 +00:00
|
|
|
pr_info("ftrace faulted on writing ");
|
|
|
|
|
print_ip_sym(ip);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2008-10-23 13:33:03 +00:00
|
|
|
FTRACE_WARN_ON_ONCE(1);
|
2008-10-23 13:32:59 +00:00
|
|
|
pr_info("ftrace faulted on unknown error ");
|
|
|
|
|
print_ip_sym(ip);
|
2008-09-22 21:55:47 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
rec->flags |= FTRACE_FL_FAILED;
|
2008-05-24 18:40:04 +00:00
|
|
|
return 0;
|
2008-05-12 19:20:48 +00:00
|
|
|
}
|
2008-05-24 18:40:04 +00:00
|
|
|
return 1;
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static int __ftrace_modify_code(void *data)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-05-12 19:20:43 +00:00
|
|
|
int *command = data;
|
|
|
|
|
|
ftrace: user update and disable dynamic ftrace daemon
In dynamic ftrace, the mcount function starts off pointing to a stub
function that just returns.
On start up, the call to the stub is modified to point to a "record_ip"
function. The job of the record_ip function is to add the function to
a pre-allocated hash list. If the function is already there, it simply is
ignored, otherwise it is added to the list.
Later, a ftraced daemon wakes up and calls kstop_machine if any functions
have been recorded, and changes the calls to the recorded functions to
a simple nop. If no functions were recorded, the daemon goes back to sleep.
The daemon wakes up once a second to see if it needs to update any newly
recorded functions into nops. Usually it does not, but if a lot of code
has been executed for the first time in the kernel, the ftraced daemon
will call kstop_machine to update those into nops.
The problem currently is that there's no way to stop the daemon from doing
this, and it can cause unneeded latencies (800us which for some is bothersome).
This patch adds a new file /debugfs/tracing/ftraced_enabled. If the daemon
is active, reading this will return "enabled\n" and "disabled\n" when the
daemon is not running. To disable the daemon, the user can echo "0" or
"disable" into this file, and "1" or "enable" to re-enable the daemon.
Since the daemon is used to convert the functions into nops to increase
the performance of the system, I also added that anytime something is
written into the ftraced_enabled file, kstop_machine will run if there
are new functions that have been detected that need to be converted.
This way the user can disable the daemon but still be able to control the
conversion of the mcount calls to nops by simply,
"echo 0 > /debugfs/tracing/ftraced_enabled"
when they need to do more conversions.
To see the number of converted functions:
"cat /debugfs/tracing/dyn_ftrace_total_info"
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-05-28 00:48:37 +00:00
|
|
|
if (*command & FTRACE_ENABLE_CALLS) {
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_replace_code(1);
|
2008-06-21 18:17:53 +00:00
|
|
|
tracing_on = 1;
|
|
|
|
|
} else if (*command & FTRACE_DISABLE_CALLS) {
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_replace_code(0);
|
2008-06-21 18:17:53 +00:00
|
|
|
tracing_on = 0;
|
|
|
|
|
}
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
if (*command & FTRACE_UPDATE_TRACE_FUNC)
|
|
|
|
|
ftrace_update_ftrace_func(ftrace_trace_function);
|
|
|
|
|
|
|
|
|
|
return 0;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void ftrace_run_update_code(int command)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-07-28 17:16:31 +00:00
|
|
|
stop_machine(__ftrace_modify_code, &command, NULL);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
static ftrace_func_t saved_ftrace_func;
|
2008-10-23 13:33:05 +00:00
|
|
|
static int ftrace_start;
|
|
|
|
|
static DEFINE_MUTEX(ftrace_start_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void ftrace_startup(void)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-05-12 19:20:43 +00:00
|
|
|
int command = 0;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return;
|
|
|
|
|
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_lock(&ftrace_start_lock);
|
|
|
|
|
ftrace_start++;
|
|
|
|
|
if (ftrace_start == 1)
|
2008-05-12 19:20:43 +00:00
|
|
|
command |= FTRACE_ENABLE_CALLS;
|
|
|
|
|
|
|
|
|
|
if (saved_ftrace_func != ftrace_trace_function) {
|
|
|
|
|
saved_ftrace_func = ftrace_trace_function;
|
|
|
|
|
command |= FTRACE_UPDATE_TRACE_FUNC;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!command || !ftrace_enabled)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
goto out;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_run_update_code(command);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
out:
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_unlock(&ftrace_start_lock);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void ftrace_shutdown(void)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-05-12 19:20:43 +00:00
|
|
|
int command = 0;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return;
|
|
|
|
|
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_lock(&ftrace_start_lock);
|
|
|
|
|
ftrace_start--;
|
|
|
|
|
if (!ftrace_start)
|
2008-05-12 19:20:43 +00:00
|
|
|
command |= FTRACE_DISABLE_CALLS;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
if (saved_ftrace_func != ftrace_trace_function) {
|
|
|
|
|
saved_ftrace_func = ftrace_trace_function;
|
|
|
|
|
command |= FTRACE_UPDATE_TRACE_FUNC;
|
|
|
|
|
}
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
if (!command || !ftrace_enabled)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
ftrace_run_update_code(command);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
out:
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_unlock(&ftrace_start_lock);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void ftrace_startup_sysctl(void)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
2008-05-12 19:20:43 +00:00
|
|
|
int command = FTRACE_ENABLE_MCOUNT;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return;
|
|
|
|
|
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_lock(&ftrace_start_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
/* Force update next time */
|
|
|
|
|
saved_ftrace_func = NULL;
|
2008-10-23 13:33:05 +00:00
|
|
|
/* ftrace_start is true if we want ftrace running */
|
|
|
|
|
if (ftrace_start)
|
2008-05-12 19:20:43 +00:00
|
|
|
command |= FTRACE_ENABLE_CALLS;
|
|
|
|
|
|
|
|
|
|
ftrace_run_update_code(command);
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_unlock(&ftrace_start_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void ftrace_shutdown_sysctl(void)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
2008-05-12 19:20:43 +00:00
|
|
|
int command = FTRACE_DISABLE_MCOUNT;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return;
|
|
|
|
|
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_lock(&ftrace_start_lock);
|
|
|
|
|
/* ftrace_start is true if ftrace is running */
|
|
|
|
|
if (ftrace_start)
|
2008-05-12 19:20:43 +00:00
|
|
|
command |= FTRACE_DISABLE_CALLS;
|
|
|
|
|
|
|
|
|
|
ftrace_run_update_code(command);
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_unlock(&ftrace_start_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
static cycle_t ftrace_update_time;
|
|
|
|
|
static unsigned long ftrace_update_cnt;
|
|
|
|
|
unsigned long ftrace_update_tot_cnt;
|
|
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
static int ftrace_update_code(void)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-10-23 13:33:07 +00:00
|
|
|
struct dyn_ftrace *p, *t;
|
2008-06-21 18:20:29 +00:00
|
|
|
cycle_t start, stop;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-05-12 19:20:46 +00:00
|
|
|
start = ftrace_now(raw_smp_processor_id());
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
ftrace_update_cnt = 0;
|
|
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
list_for_each_entry_safe(p, t, &ftrace_new_addrs, list) {
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
/* If something went wrong, bail without enabling anything */
|
|
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return -1;
|
2008-06-21 18:20:29 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
list_del_init(&p->list);
|
2008-06-21 18:20:29 +00:00
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
/* convert record (i.e, patch mcount-call with NOP) */
|
|
|
|
|
if (ftrace_code_disable(p)) {
|
|
|
|
|
p->flags |= FTRACE_FL_CONVERTED;
|
|
|
|
|
ftrace_update_cnt++;
|
|
|
|
|
} else
|
|
|
|
|
ftrace_free_rec(p);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:46 +00:00
|
|
|
stop = ftrace_now(raw_smp_processor_id());
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
ftrace_update_time = stop - start;
|
|
|
|
|
ftrace_update_tot_cnt += ftrace_update_cnt;
|
|
|
|
|
|
2008-05-12 19:20:42 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-14 19:45:08 +00:00
|
|
|
static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
struct ftrace_page *pg;
|
|
|
|
|
int cnt;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* allocate a few pages */
|
|
|
|
|
ftrace_pages_start = (void *)get_zeroed_page(GFP_KERNEL);
|
|
|
|
|
if (!ftrace_pages_start)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate a few more pages.
|
|
|
|
|
*
|
|
|
|
|
* TODO: have some parser search vmlinux before
|
|
|
|
|
* final linking to find all calls to ftrace.
|
|
|
|
|
* Then we can:
|
|
|
|
|
* a) know how many pages to allocate.
|
|
|
|
|
* and/or
|
|
|
|
|
* b) set up the table then.
|
|
|
|
|
*
|
|
|
|
|
* The dynamic code is still necessary for
|
|
|
|
|
* modules.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
pg = ftrace_pages = ftrace_pages_start;
|
|
|
|
|
|
2008-08-14 19:45:08 +00:00
|
|
|
cnt = num_to_init / ENTRIES_PER_PAGE;
|
2008-10-23 13:33:07 +00:00
|
|
|
pr_info("ftrace: allocating %ld entries in %d pages\n",
|
2008-08-14 19:45:08 +00:00
|
|
|
num_to_init, cnt);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
|
|
|
pg->next = (void *)get_zeroed_page(GFP_KERNEL);
|
|
|
|
|
|
|
|
|
|
/* If we fail, we'll try later anyway */
|
|
|
|
|
if (!pg->next)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
pg = pg->next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
enum {
|
|
|
|
|
FTRACE_ITER_FILTER = (1 << 0),
|
|
|
|
|
FTRACE_ITER_CONT = (1 << 1),
|
2008-05-22 15:46:33 +00:00
|
|
|
FTRACE_ITER_NOTRACE = (1 << 2),
|
2008-06-01 16:17:54 +00:00
|
|
|
FTRACE_ITER_FAILURES = (1 << 3),
|
2008-05-12 19:20:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
|
|
|
|
|
|
|
|
|
|
struct ftrace_iterator {
|
|
|
|
|
loff_t pos;
|
|
|
|
|
struct ftrace_page *pg;
|
|
|
|
|
unsigned idx;
|
|
|
|
|
unsigned flags;
|
|
|
|
|
unsigned char buffer[FTRACE_BUFF_MAX+1];
|
|
|
|
|
unsigned buffer_idx;
|
|
|
|
|
unsigned filtered;
|
|
|
|
|
};
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void *
|
2008-05-12 19:20:43 +00:00
|
|
|
t_next(struct seq_file *m, void *v, loff_t *pos)
|
|
|
|
|
{
|
|
|
|
|
struct ftrace_iterator *iter = m->private;
|
|
|
|
|
struct dyn_ftrace *rec = NULL;
|
|
|
|
|
|
|
|
|
|
(*pos)++;
|
|
|
|
|
|
2008-08-16 01:40:05 +00:00
|
|
|
/* should not be called from interrupt context */
|
|
|
|
|
spin_lock(&ftrace_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
retry:
|
|
|
|
|
if (iter->idx >= iter->pg->index) {
|
|
|
|
|
if (iter->pg->next) {
|
|
|
|
|
iter->pg = iter->pg->next;
|
|
|
|
|
iter->idx = 0;
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
rec = &iter->pg->records[iter->idx++];
|
2008-08-15 02:47:17 +00:00
|
|
|
if ((rec->flags & FTRACE_FL_FREE) ||
|
|
|
|
|
|
|
|
|
|
(!(iter->flags & FTRACE_ITER_FAILURES) &&
|
2008-06-01 16:17:54 +00:00
|
|
|
(rec->flags & FTRACE_FL_FAILED)) ||
|
|
|
|
|
|
|
|
|
|
((iter->flags & FTRACE_ITER_FAILURES) &&
|
2008-08-15 02:47:17 +00:00
|
|
|
!(rec->flags & FTRACE_FL_FAILED)) ||
|
2008-06-01 16:17:54 +00:00
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
((iter->flags & FTRACE_ITER_NOTRACE) &&
|
|
|
|
|
!(rec->flags & FTRACE_FL_NOTRACE))) {
|
2008-05-12 19:20:43 +00:00
|
|
|
rec = NULL;
|
|
|
|
|
goto retry;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-08-16 01:40:05 +00:00
|
|
|
spin_unlock(&ftrace_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
iter->pos = *pos;
|
|
|
|
|
|
|
|
|
|
return rec;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void *t_start(struct seq_file *m, loff_t *pos)
|
|
|
|
|
{
|
|
|
|
|
struct ftrace_iterator *iter = m->private;
|
|
|
|
|
void *p = NULL;
|
|
|
|
|
loff_t l = -1;
|
|
|
|
|
|
|
|
|
|
if (*pos != iter->pos) {
|
|
|
|
|
for (p = t_next(m, p, &l); p && l < *pos; p = t_next(m, p, &l))
|
|
|
|
|
;
|
|
|
|
|
} else {
|
|
|
|
|
l = *pos;
|
|
|
|
|
p = t_next(m, p, &l);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void t_stop(struct seq_file *m, void *p)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int t_show(struct seq_file *m, void *v)
|
|
|
|
|
{
|
|
|
|
|
struct dyn_ftrace *rec = v;
|
|
|
|
|
char str[KSYM_SYMBOL_LEN];
|
|
|
|
|
|
|
|
|
|
if (!rec)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
|
|
|
|
|
|
|
|
|
|
seq_printf(m, "%s\n", str);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct seq_operations show_ftrace_seq_ops = {
|
|
|
|
|
.start = t_start,
|
|
|
|
|
.next = t_next,
|
|
|
|
|
.stop = t_stop,
|
|
|
|
|
.show = t_show,
|
|
|
|
|
};
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static int
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_avail_open(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
struct ftrace_iterator *iter;
|
|
|
|
|
int ret;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
iter = kzalloc(sizeof(*iter), GFP_KERNEL);
|
|
|
|
|
if (!iter)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
iter->pg = ftrace_pages_start;
|
|
|
|
|
iter->pos = -1;
|
|
|
|
|
|
|
|
|
|
ret = seq_open(file, &show_ftrace_seq_ops);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
struct seq_file *m = file->private_data;
|
2008-05-12 19:20:46 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
m->private = iter;
|
2008-05-12 19:20:46 +00:00
|
|
|
} else {
|
2008-05-12 19:20:43 +00:00
|
|
|
kfree(iter);
|
2008-05-12 19:20:46 +00:00
|
|
|
}
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int ftrace_avail_release(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
struct seq_file *m = (struct seq_file *)file->private_data;
|
|
|
|
|
struct ftrace_iterator *iter = m->private;
|
|
|
|
|
|
|
|
|
|
seq_release(inode, file);
|
|
|
|
|
kfree(iter);
|
2008-05-12 19:20:46 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-06-01 16:17:54 +00:00
|
|
|
static int
|
|
|
|
|
ftrace_failures_open(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
struct seq_file *m;
|
|
|
|
|
struct ftrace_iterator *iter;
|
|
|
|
|
|
|
|
|
|
ret = ftrace_avail_open(inode, file);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
m = (struct seq_file *)file->private_data;
|
|
|
|
|
iter = (struct ftrace_iterator *)m->private;
|
|
|
|
|
iter->flags = FTRACE_ITER_FAILURES;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
static void ftrace_filter_reset(int enable)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
struct ftrace_page *pg;
|
|
|
|
|
struct dyn_ftrace *rec;
|
2008-05-22 15:46:33 +00:00
|
|
|
unsigned long type = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
|
2008-05-12 19:20:43 +00:00
|
|
|
unsigned i;
|
|
|
|
|
|
2008-08-16 01:40:05 +00:00
|
|
|
/* should not be called from interrupt context */
|
|
|
|
|
spin_lock(&ftrace_lock);
|
2008-05-22 15:46:33 +00:00
|
|
|
if (enable)
|
|
|
|
|
ftrace_filtered = 0;
|
2008-05-12 19:20:43 +00:00
|
|
|
pg = ftrace_pages_start;
|
|
|
|
|
while (pg) {
|
|
|
|
|
for (i = 0; i < pg->index; i++) {
|
|
|
|
|
rec = &pg->records[i];
|
|
|
|
|
if (rec->flags & FTRACE_FL_FAILED)
|
|
|
|
|
continue;
|
2008-05-22 15:46:33 +00:00
|
|
|
rec->flags &= ~type;
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
pg = pg->next;
|
|
|
|
|
}
|
2008-08-16 01:40:05 +00:00
|
|
|
spin_unlock(&ftrace_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static int
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_regex_open(struct inode *inode, struct file *file, int enable)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
struct ftrace_iterator *iter;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
iter = kzalloc(sizeof(*iter), GFP_KERNEL);
|
|
|
|
|
if (!iter)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
mutex_lock(&ftrace_regex_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
if ((file->f_mode & FMODE_WRITE) &&
|
|
|
|
|
!(file->f_flags & O_APPEND))
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_filter_reset(enable);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
if (file->f_mode & FMODE_READ) {
|
|
|
|
|
iter->pg = ftrace_pages_start;
|
|
|
|
|
iter->pos = -1;
|
2008-05-22 15:46:33 +00:00
|
|
|
iter->flags = enable ? FTRACE_ITER_FILTER :
|
|
|
|
|
FTRACE_ITER_NOTRACE;
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
ret = seq_open(file, &show_ftrace_seq_ops);
|
|
|
|
|
if (!ret) {
|
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
|
m->private = iter;
|
|
|
|
|
} else
|
|
|
|
|
kfree(iter);
|
|
|
|
|
} else
|
|
|
|
|
file->private_data = iter;
|
2008-05-22 15:46:33 +00:00
|
|
|
mutex_unlock(&ftrace_regex_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
static int
|
|
|
|
|
ftrace_filter_open(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
return ftrace_regex_open(inode, file, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ftrace_notrace_open(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
return ftrace_regex_open(inode, file, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static ssize_t
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_regex_read(struct file *file, char __user *ubuf,
|
2008-05-12 19:20:43 +00:00
|
|
|
size_t cnt, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
if (file->f_mode & FMODE_READ)
|
|
|
|
|
return seq_read(file, ubuf, cnt, ppos);
|
|
|
|
|
else
|
|
|
|
|
return -EPERM;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static loff_t
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_regex_lseek(struct file *file, loff_t offset, int origin)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
loff_t ret;
|
|
|
|
|
|
|
|
|
|
if (file->f_mode & FMODE_READ)
|
|
|
|
|
ret = seq_lseek(file, offset, origin);
|
|
|
|
|
else
|
|
|
|
|
file->f_pos = ret = 1;
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
MATCH_FULL,
|
|
|
|
|
MATCH_FRONT_ONLY,
|
|
|
|
|
MATCH_MIDDLE_ONLY,
|
|
|
|
|
MATCH_END_ONLY,
|
|
|
|
|
};
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static void
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_match(unsigned char *buff, int len, int enable)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
char str[KSYM_SYMBOL_LEN];
|
|
|
|
|
char *search = NULL;
|
|
|
|
|
struct ftrace_page *pg;
|
|
|
|
|
struct dyn_ftrace *rec;
|
|
|
|
|
int type = MATCH_FULL;
|
2008-05-22 15:46:33 +00:00
|
|
|
unsigned long flag = enable ? FTRACE_FL_FILTER : FTRACE_FL_NOTRACE;
|
2008-05-12 19:20:43 +00:00
|
|
|
unsigned i, match = 0, search_len = 0;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
|
if (buff[i] == '*') {
|
|
|
|
|
if (!i) {
|
|
|
|
|
search = buff + i + 1;
|
|
|
|
|
type = MATCH_END_ONLY;
|
|
|
|
|
search_len = len - (i + 1);
|
|
|
|
|
} else {
|
|
|
|
|
if (type == MATCH_END_ONLY) {
|
|
|
|
|
type = MATCH_MIDDLE_ONLY;
|
|
|
|
|
} else {
|
|
|
|
|
match = i;
|
|
|
|
|
type = MATCH_FRONT_ONLY;
|
|
|
|
|
}
|
|
|
|
|
buff[i] = 0;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-16 01:40:05 +00:00
|
|
|
/* should not be called from interrupt context */
|
|
|
|
|
spin_lock(&ftrace_lock);
|
2008-05-22 15:46:33 +00:00
|
|
|
if (enable)
|
|
|
|
|
ftrace_filtered = 1;
|
2008-05-12 19:20:43 +00:00
|
|
|
pg = ftrace_pages_start;
|
|
|
|
|
while (pg) {
|
|
|
|
|
for (i = 0; i < pg->index; i++) {
|
|
|
|
|
int matched = 0;
|
|
|
|
|
char *ptr;
|
|
|
|
|
|
|
|
|
|
rec = &pg->records[i];
|
|
|
|
|
if (rec->flags & FTRACE_FL_FAILED)
|
|
|
|
|
continue;
|
|
|
|
|
kallsyms_lookup(rec->ip, NULL, NULL, NULL, str);
|
|
|
|
|
switch (type) {
|
|
|
|
|
case MATCH_FULL:
|
|
|
|
|
if (strcmp(str, buff) == 0)
|
|
|
|
|
matched = 1;
|
|
|
|
|
break;
|
|
|
|
|
case MATCH_FRONT_ONLY:
|
|
|
|
|
if (memcmp(str, buff, match) == 0)
|
|
|
|
|
matched = 1;
|
|
|
|
|
break;
|
|
|
|
|
case MATCH_MIDDLE_ONLY:
|
|
|
|
|
if (strstr(str, search))
|
|
|
|
|
matched = 1;
|
|
|
|
|
break;
|
|
|
|
|
case MATCH_END_ONLY:
|
|
|
|
|
ptr = strstr(str, search);
|
|
|
|
|
if (ptr && (ptr[search_len] == 0))
|
|
|
|
|
matched = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (matched)
|
2008-05-22 15:46:33 +00:00
|
|
|
rec->flags |= flag;
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
pg = pg->next;
|
|
|
|
|
}
|
2008-08-16 01:40:05 +00:00
|
|
|
spin_unlock(&ftrace_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static ssize_t
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_regex_write(struct file *file, const char __user *ubuf,
|
|
|
|
|
size_t cnt, loff_t *ppos, int enable)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
struct ftrace_iterator *iter;
|
|
|
|
|
char ch;
|
|
|
|
|
size_t read = 0;
|
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
|
|
if (!cnt || cnt < 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
mutex_lock(&ftrace_regex_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
if (file->f_mode & FMODE_READ) {
|
|
|
|
|
struct seq_file *m = file->private_data;
|
|
|
|
|
iter = m->private;
|
|
|
|
|
} else
|
|
|
|
|
iter = file->private_data;
|
|
|
|
|
|
|
|
|
|
if (!*ppos) {
|
|
|
|
|
iter->flags &= ~FTRACE_ITER_CONT;
|
|
|
|
|
iter->buffer_idx = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = get_user(ch, ubuf++);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
read++;
|
|
|
|
|
cnt--;
|
|
|
|
|
|
|
|
|
|
if (!(iter->flags & ~FTRACE_ITER_CONT)) {
|
|
|
|
|
/* skip white space */
|
|
|
|
|
while (cnt && isspace(ch)) {
|
|
|
|
|
ret = get_user(ch, ubuf++);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
read++;
|
|
|
|
|
cnt--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isspace(ch)) {
|
|
|
|
|
file->f_pos += read;
|
|
|
|
|
ret = read;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
iter->buffer_idx = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (cnt && !isspace(ch)) {
|
|
|
|
|
if (iter->buffer_idx < FTRACE_BUFF_MAX)
|
|
|
|
|
iter->buffer[iter->buffer_idx++] = ch;
|
|
|
|
|
else {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
ret = get_user(ch, ubuf++);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto out;
|
|
|
|
|
read++;
|
|
|
|
|
cnt--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isspace(ch)) {
|
|
|
|
|
iter->filtered++;
|
|
|
|
|
iter->buffer[iter->buffer_idx] = 0;
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_match(iter->buffer, iter->buffer_idx, enable);
|
2008-05-12 19:20:43 +00:00
|
|
|
iter->buffer_idx = 0;
|
|
|
|
|
} else
|
|
|
|
|
iter->flags |= FTRACE_ITER_CONT;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
file->f_pos += read;
|
|
|
|
|
|
|
|
|
|
ret = read;
|
|
|
|
|
out:
|
2008-05-22 15:46:33 +00:00
|
|
|
mutex_unlock(&ftrace_regex_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
static ssize_t
|
|
|
|
|
ftrace_filter_write(struct file *file, const char __user *ubuf,
|
|
|
|
|
size_t cnt, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
return ftrace_regex_write(file, ubuf, cnt, ppos, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
|
ftrace_notrace_write(struct file *file, const char __user *ubuf,
|
|
|
|
|
size_t cnt, loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
return ftrace_regex_write(file, ubuf, cnt, ppos, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
ftrace_set_regex(unsigned char *buf, int len, int reset, int enable)
|
|
|
|
|
{
|
|
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
mutex_lock(&ftrace_regex_lock);
|
|
|
|
|
if (reset)
|
|
|
|
|
ftrace_filter_reset(enable);
|
|
|
|
|
if (buf)
|
|
|
|
|
ftrace_match(buf, len, enable);
|
|
|
|
|
mutex_unlock(&ftrace_regex_lock);
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:45 +00:00
|
|
|
/**
|
|
|
|
|
* ftrace_set_filter - set a function to filter on in ftrace
|
|
|
|
|
* @buf - the string that holds the function filter text.
|
|
|
|
|
* @len - the length of the string.
|
|
|
|
|
* @reset - non zero to reset all filters before applying this filter.
|
|
|
|
|
*
|
|
|
|
|
* Filters denote which functions should be enabled when tracing is enabled.
|
|
|
|
|
* If @buf is NULL and reset is set, all functions will be enabled for tracing.
|
|
|
|
|
*/
|
2008-05-12 19:20:51 +00:00
|
|
|
void ftrace_set_filter(unsigned char *buf, int len, int reset)
|
2008-05-12 19:20:45 +00:00
|
|
|
{
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_set_regex(buf, len, reset, 1);
|
|
|
|
|
}
|
2008-05-12 19:20:48 +00:00
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
/**
|
|
|
|
|
* ftrace_set_notrace - set a function to not trace in ftrace
|
|
|
|
|
* @buf - the string that holds the function notrace text.
|
|
|
|
|
* @len - the length of the string.
|
|
|
|
|
* @reset - non zero to reset all filters before applying this filter.
|
|
|
|
|
*
|
|
|
|
|
* Notrace Filters denote which functions should not be enabled when tracing
|
|
|
|
|
* is enabled. If @buf is NULL and reset is set, all functions will be enabled
|
|
|
|
|
* for tracing.
|
|
|
|
|
*/
|
|
|
|
|
void ftrace_set_notrace(unsigned char *buf, int len, int reset)
|
|
|
|
|
{
|
|
|
|
|
ftrace_set_regex(buf, len, reset, 0);
|
2008-05-12 19:20:45 +00:00
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
static int
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_regex_release(struct inode *inode, struct file *file, int enable)
|
2008-05-12 19:20:43 +00:00
|
|
|
{
|
|
|
|
|
struct seq_file *m = (struct seq_file *)file->private_data;
|
|
|
|
|
struct ftrace_iterator *iter;
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
mutex_lock(&ftrace_regex_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
if (file->f_mode & FMODE_READ) {
|
|
|
|
|
iter = m->private;
|
|
|
|
|
|
|
|
|
|
seq_release(inode, file);
|
|
|
|
|
} else
|
|
|
|
|
iter = file->private_data;
|
|
|
|
|
|
|
|
|
|
if (iter->buffer_idx) {
|
|
|
|
|
iter->filtered++;
|
|
|
|
|
iter->buffer[iter->buffer_idx] = 0;
|
2008-05-22 15:46:33 +00:00
|
|
|
ftrace_match(iter->buffer, iter->buffer_idx, enable);
|
2008-05-12 19:20:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mutex_lock(&ftrace_sysctl_lock);
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_lock(&ftrace_start_lock);
|
|
|
|
|
if (iter->filtered && ftrace_start && ftrace_enabled)
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_run_update_code(FTRACE_ENABLE_CALLS);
|
2008-10-23 13:33:05 +00:00
|
|
|
mutex_unlock(&ftrace_start_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
mutex_unlock(&ftrace_sysctl_lock);
|
|
|
|
|
|
|
|
|
|
kfree(iter);
|
2008-05-22 15:46:33 +00:00
|
|
|
mutex_unlock(&ftrace_regex_lock);
|
2008-05-12 19:20:43 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
static int
|
|
|
|
|
ftrace_filter_release(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
return ftrace_regex_release(inode, file, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
ftrace_notrace_release(struct inode *inode, struct file *file)
|
|
|
|
|
{
|
|
|
|
|
return ftrace_regex_release(inode, file, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
static struct file_operations ftrace_avail_fops = {
|
|
|
|
|
.open = ftrace_avail_open,
|
|
|
|
|
.read = seq_read,
|
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
|
.release = ftrace_avail_release,
|
|
|
|
|
};
|
|
|
|
|
|
2008-06-01 16:17:54 +00:00
|
|
|
static struct file_operations ftrace_failures_fops = {
|
|
|
|
|
.open = ftrace_failures_open,
|
|
|
|
|
.read = seq_read,
|
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
|
.release = ftrace_avail_release,
|
|
|
|
|
};
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
static struct file_operations ftrace_filter_fops = {
|
|
|
|
|
.open = ftrace_filter_open,
|
2008-05-22 15:46:33 +00:00
|
|
|
.read = ftrace_regex_read,
|
2008-05-12 19:20:43 +00:00
|
|
|
.write = ftrace_filter_write,
|
2008-05-22 15:46:33 +00:00
|
|
|
.llseek = ftrace_regex_lseek,
|
2008-05-12 19:20:43 +00:00
|
|
|
.release = ftrace_filter_release,
|
|
|
|
|
};
|
|
|
|
|
|
2008-05-22 15:46:33 +00:00
|
|
|
static struct file_operations ftrace_notrace_fops = {
|
|
|
|
|
.open = ftrace_notrace_open,
|
|
|
|
|
.read = ftrace_regex_read,
|
|
|
|
|
.write = ftrace_notrace_write,
|
|
|
|
|
.llseek = ftrace_regex_lseek,
|
|
|
|
|
.release = ftrace_notrace_release,
|
|
|
|
|
};
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
static __init int ftrace_init_debugfs(void)
|
|
|
|
|
{
|
|
|
|
|
struct dentry *d_tracer;
|
|
|
|
|
struct dentry *entry;
|
|
|
|
|
|
|
|
|
|
d_tracer = tracing_init_dentry();
|
|
|
|
|
|
|
|
|
|
entry = debugfs_create_file("available_filter_functions", 0444,
|
|
|
|
|
d_tracer, NULL, &ftrace_avail_fops);
|
|
|
|
|
if (!entry)
|
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
|
"'available_filter_functions' entry\n");
|
|
|
|
|
|
2008-06-01 16:17:54 +00:00
|
|
|
entry = debugfs_create_file("failures", 0444,
|
|
|
|
|
d_tracer, NULL, &ftrace_failures_fops);
|
|
|
|
|
if (!entry)
|
|
|
|
|
pr_warning("Could not create debugfs 'failures' entry\n");
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
entry = debugfs_create_file("set_ftrace_filter", 0644, d_tracer,
|
|
|
|
|
NULL, &ftrace_filter_fops);
|
|
|
|
|
if (!entry)
|
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
|
"'set_ftrace_filter' entry\n");
|
2008-05-22 15:46:33 +00:00
|
|
|
|
|
|
|
|
entry = debugfs_create_file("set_ftrace_notrace", 0644, d_tracer,
|
|
|
|
|
NULL, &ftrace_notrace_fops);
|
|
|
|
|
if (!entry)
|
|
|
|
|
pr_warning("Could not create debugfs "
|
|
|
|
|
"'set_ftrace_notrace' entry\n");
|
ftrace: user update and disable dynamic ftrace daemon
In dynamic ftrace, the mcount function starts off pointing to a stub
function that just returns.
On start up, the call to the stub is modified to point to a "record_ip"
function. The job of the record_ip function is to add the function to
a pre-allocated hash list. If the function is already there, it simply is
ignored, otherwise it is added to the list.
Later, a ftraced daemon wakes up and calls kstop_machine if any functions
have been recorded, and changes the calls to the recorded functions to
a simple nop. If no functions were recorded, the daemon goes back to sleep.
The daemon wakes up once a second to see if it needs to update any newly
recorded functions into nops. Usually it does not, but if a lot of code
has been executed for the first time in the kernel, the ftraced daemon
will call kstop_machine to update those into nops.
The problem currently is that there's no way to stop the daemon from doing
this, and it can cause unneeded latencies (800us which for some is bothersome).
This patch adds a new file /debugfs/tracing/ftraced_enabled. If the daemon
is active, reading this will return "enabled\n" and "disabled\n" when the
daemon is not running. To disable the daemon, the user can echo "0" or
"disable" into this file, and "1" or "enable" to re-enable the daemon.
Since the daemon is used to convert the functions into nops to increase
the performance of the system, I also added that anytime something is
written into the ftraced_enabled file, kstop_machine will run if there
are new functions that have been detected that need to be converted.
This way the user can disable the daemon but still be able to control the
conversion of the mcount calls to nops by simply,
"echo 0 > /debugfs/tracing/ftraced_enabled"
when they need to do more conversions.
To see the number of converted functions:
"cat /debugfs/tracing/dyn_ftrace_total_info"
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-05-28 00:48:37 +00:00
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fs_initcall(ftrace_init_debugfs);
|
|
|
|
|
|
2008-08-14 19:45:08 +00:00
|
|
|
static int ftrace_convert_nops(unsigned long *start,
|
|
|
|
|
unsigned long *end)
|
|
|
|
|
{
|
|
|
|
|
unsigned long *p;
|
|
|
|
|
unsigned long addr;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
mutex_lock(&ftrace_start_lock);
|
2008-08-14 19:45:08 +00:00
|
|
|
p = start;
|
|
|
|
|
while (p < end) {
|
|
|
|
|
addr = ftrace_call_adjust(*p++);
|
|
|
|
|
ftrace_record_ip(addr);
|
|
|
|
|
}
|
|
|
|
|
|
2008-10-23 13:33:07 +00:00
|
|
|
/* disable interrupts to prevent kstop machine */
|
2008-08-14 19:45:08 +00:00
|
|
|
local_irq_save(flags);
|
2008-10-23 13:33:07 +00:00
|
|
|
ftrace_update_code();
|
2008-08-14 19:45:08 +00:00
|
|
|
local_irq_restore(flags);
|
2008-10-23 13:33:07 +00:00
|
|
|
mutex_unlock(&ftrace_start_lock);
|
2008-08-14 19:45:08 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-14 19:45:09 +00:00
|
|
|
void ftrace_init_module(unsigned long *start, unsigned long *end)
|
|
|
|
|
{
|
2008-08-16 01:40:04 +00:00
|
|
|
if (ftrace_disabled || start == end)
|
2008-08-15 02:47:19 +00:00
|
|
|
return;
|
2008-08-14 19:45:09 +00:00
|
|
|
ftrace_convert_nops(start, end);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-14 19:45:08 +00:00
|
|
|
extern unsigned long __start_mcount_loc[];
|
|
|
|
|
extern unsigned long __stop_mcount_loc[];
|
|
|
|
|
|
|
|
|
|
void __init ftrace_init(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long count, addr, flags;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/* Keep the ftrace pointer to the stub */
|
|
|
|
|
addr = (unsigned long)ftrace_stub;
|
|
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
ftrace_dyn_arch_init(&addr);
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
|
|
/* ftrace_dyn_arch_init places the return code in addr */
|
|
|
|
|
if (addr)
|
|
|
|
|
goto failed;
|
|
|
|
|
|
|
|
|
|
count = __stop_mcount_loc - __start_mcount_loc;
|
|
|
|
|
|
|
|
|
|
ret = ftrace_dyn_table_alloc(count);
|
|
|
|
|
if (ret)
|
|
|
|
|
goto failed;
|
|
|
|
|
|
|
|
|
|
last_ftrace_enabled = ftrace_enabled = 1;
|
|
|
|
|
|
|
|
|
|
ret = ftrace_convert_nops(__start_mcount_loc,
|
|
|
|
|
__stop_mcount_loc);
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
failed:
|
|
|
|
|
ftrace_disabled = 1;
|
|
|
|
|
}
|
|
|
|
|
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
#else
|
2008-10-28 19:17:38 +00:00
|
|
|
|
|
|
|
|
static int __init ftrace_nodyn_init(void)
|
|
|
|
|
{
|
|
|
|
|
ftrace_enabled = 1;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
device_initcall(ftrace_nodyn_init);
|
|
|
|
|
|
2008-05-12 19:20:45 +00:00
|
|
|
# define ftrace_startup() do { } while (0)
|
|
|
|
|
# define ftrace_shutdown() do { } while (0)
|
|
|
|
|
# define ftrace_startup_sysctl() do { } while (0)
|
|
|
|
|
# define ftrace_shutdown_sysctl() do { } while (0)
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
#endif /* CONFIG_DYNAMIC_FTRACE */
|
|
|
|
|
|
2008-07-11 00:58:15 +00:00
|
|
|
/**
|
2008-10-23 13:33:02 +00:00
|
|
|
* ftrace_kill - kill ftrace
|
2008-07-11 00:58:15 +00:00
|
|
|
*
|
|
|
|
|
* This function should be used by panic code. It stops ftrace
|
|
|
|
|
* but in a not so nice way. If you need to simply kill ftrace
|
|
|
|
|
* from a non-atomic section, use ftrace_kill.
|
|
|
|
|
*/
|
2008-10-23 13:33:02 +00:00
|
|
|
void ftrace_kill(void)
|
2008-07-11 00:58:15 +00:00
|
|
|
{
|
|
|
|
|
ftrace_disabled = 1;
|
|
|
|
|
ftrace_enabled = 0;
|
|
|
|
|
clear_ftrace_function();
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:42 +00:00
|
|
|
/**
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
* register_ftrace_function - register a function for profiling
|
|
|
|
|
* @ops - ops structure that holds the function for profiling.
|
2008-05-12 19:20:42 +00:00
|
|
|
*
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
* Register a function to be called by all functions in the
|
|
|
|
|
* kernel.
|
|
|
|
|
*
|
|
|
|
|
* Note: @ops->func and all the functions it calls must be labeled
|
|
|
|
|
* with "notrace", otherwise it will go into a
|
|
|
|
|
* recursive loop.
|
2008-05-12 19:20:42 +00:00
|
|
|
*/
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
int register_ftrace_function(struct ftrace_ops *ops)
|
2008-05-12 19:20:42 +00:00
|
|
|
{
|
2008-05-12 19:20:43 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return -1;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
mutex_lock(&ftrace_sysctl_lock);
|
|
|
|
|
ret = __register_ftrace_function(ops);
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_startup();
|
2008-05-12 19:20:43 +00:00
|
|
|
mutex_unlock(&ftrace_sysctl_lock);
|
|
|
|
|
|
|
|
|
|
return ret;
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* unregister_ftrace_function - unresgister a function for profiling.
|
|
|
|
|
* @ops - ops structure that holds the function to unregister
|
|
|
|
|
*
|
|
|
|
|
* Unregister a function that was added to be called by ftrace profiling.
|
|
|
|
|
*/
|
|
|
|
|
int unregister_ftrace_function(struct ftrace_ops *ops)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
mutex_lock(&ftrace_sysctl_lock);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
ret = __unregister_ftrace_function(ops);
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_shutdown();
|
2008-05-12 19:20:43 +00:00
|
|
|
mutex_unlock(&ftrace_sysctl_lock);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2008-05-12 19:20:51 +00:00
|
|
|
int
|
2008-05-12 19:20:43 +00:00
|
|
|
ftrace_enable_sysctl(struct ctl_table *table, int write,
|
2008-05-12 19:20:43 +00:00
|
|
|
struct file *file, void __user *buffer, size_t *lenp,
|
2008-05-12 19:20:43 +00:00
|
|
|
loff_t *ppos)
|
|
|
|
|
{
|
|
|
|
|
int ret;
|
|
|
|
|
|
2008-05-12 19:20:48 +00:00
|
|
|
if (unlikely(ftrace_disabled))
|
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
mutex_lock(&ftrace_sysctl_lock);
|
|
|
|
|
|
2008-05-12 19:20:43 +00:00
|
|
|
ret = proc_dointvec(table, write, file, buffer, lenp, ppos);
|
2008-05-12 19:20:43 +00:00
|
|
|
|
|
|
|
|
if (ret || !write || (last_ftrace_enabled == ftrace_enabled))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
last_ftrace_enabled = ftrace_enabled;
|
|
|
|
|
|
|
|
|
|
if (ftrace_enabled) {
|
|
|
|
|
|
|
|
|
|
ftrace_startup_sysctl();
|
|
|
|
|
|
|
|
|
|
/* we are starting ftrace again */
|
|
|
|
|
if (ftrace_list != &ftrace_list_end) {
|
|
|
|
|
if (ftrace_list->next == &ftrace_list_end)
|
|
|
|
|
ftrace_trace_function = ftrace_list->func;
|
|
|
|
|
else
|
|
|
|
|
ftrace_trace_function = ftrace_list_func;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
/* stopping ftrace calls (just send to ftrace_stub) */
|
|
|
|
|
ftrace_trace_function = ftrace_stub;
|
|
|
|
|
|
|
|
|
|
ftrace_shutdown_sysctl();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
mutex_unlock(&ftrace_sysctl_lock);
|
ftrace: dynamic enabling/disabling of function calls
This patch adds a feature to dynamically replace the ftrace code
with the jmps to allow a kernel with ftrace configured to run
as fast as it can without it configured.
The way this works, is on bootup (if ftrace is enabled), a ftrace
function is registered to record the instruction pointer of all
places that call the function.
Later, if there's still any code to patch, a kthread is awoken
(rate limited to at most once a second) that performs a stop_machine,
and replaces all the code that was called with a jmp over the call
to ftrace. It only replaces what was found the previous time. Typically
the system reaches equilibrium quickly after bootup and there's no code
patching needed at all.
e.g.
call ftrace /* 5 bytes */
is replaced with
jmp 3f /* jmp is 2 bytes and we jump 3 forward */
3:
When we want to enable ftrace for function tracing, the IP recording
is removed, and stop_machine is called again to replace all the locations
of that were recorded back to the call of ftrace. When it is disabled,
we replace the code back to the jmp.
Allocation is done by the kthread. If the ftrace recording function is
called, and we don't have any record slots available, then we simply
skip that call. Once a second a new page (if needed) is allocated for
recording new ftrace function calls. A large batch is allocated at
boot up to get most of the calls there.
Because we do this via stop_machine, we don't have to worry about another
CPU executing a ftrace call as we modify it. But we do need to worry
about NMI's so all functions that might be called via nmi must be
annotated with notrace_nmi. When this code is configured in, the NMI code
will not call notrace.
Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2008-05-12 19:20:42 +00:00
|
|
|
return ret;
|
2008-05-12 19:20:42 +00:00
|
|
|
}
|
2008-10-24 10:47:10 +00:00
|
|
|
|