tracing: More updates for 4.5.
Subsystems (7)
Steven Rostedt
maintainercover tracing: More updates for 4.5.
git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace.git
for-next
Head SHA1: 05a724bd44a68cd5c60bc4b949a946b57d4c9e55
Abel Vesa (1):
ftrace: Join functions ftrace_module_init() and ftrace_init_module()
Chuyu Hu (1):
tracing: Fix comment to use tracing_on over tracing_enable
Denis Kirjanov (1):
tracing: Introduce TRACE_EVENT_FN_COND macro
Jerry Snitselaar (1):
tracing: Use seq_buf_used() in seq_buf_to_user() instead of len
Julia Lawall (1):
bpf: Constify bpf_verifier_ops structure
Li Bin (4):
ftrace: Fix a typo in comment
ia64: ftrace: Fix the comments for ftrace_modify_code()
sh: ftrace: Fix the comments for ftrace_modify_code()
metag: ftrace: Fix the comments for ftrace_modify_code
Steven Rostedt (Red Hat) (4):
ftrace: Fix output of enabled_functions for showing tramp
ftrace: Remove use of control list and ops
ftrace: Have ftrace_ops_get_func() handle RCU and PER_CPU flags too
ftrace: Clean up ftrace_module_init() code
----
arch/ia64/kernel/ftrace.c | 12 ++- arch/metag/kernel/ftrace.c | 11 ++- arch/sh/kernel/ftrace.c | 12 ++- include/linux/ftrace.h | 35 ++++---- include/linux/tracepoint.h | 4 + include/trace/define_trace.h | 6 ++ include/trace/trace_events.h | 6 ++ kernel/trace/bpf_trace.c | 2 +- kernel/trace/ftrace.c | 179 +++++++++++++++------------------------- kernel/trace/trace.h | 6 +- kernel/trace/trace_event_perf.c | 2 +- lib/seq_buf.c | 6 +- 12 files changed, 122 insertions(+), 159 deletions(-)
Steven Rostedt
maintainerPATCH 1/13 ftrace: Fix a typo in comment
From: Li Bin <[email protected]>
s/ARCH_SUPPORT_FTARCE_OPS/ARCH_SUPPORTS_FTRACE_OPS/
--- kernel/trace/ftrace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/ftrace.c +1 -1
@@ -5263,7 +5263,7 @@ out:* being NULL, or CONFIG_DYNAMIC_FTRACE_WITH_REGS. * Note, CONFIG_DYNAMIC_FTRACE_WITH_REGS expects a full regs to be saved. * An architecture can pass partial regs with ftrace_ops and still -* set the ARCH_SUPPORT_FTARCE_OPS. +* set the ARCH_SUPPORTS_FTRACE_OPS. */ #if ARCH_SUPPORTS_FTRACE_OPS static void ftrace_ops_list_func(unsigned long ip, unsigned long parent_ip,
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 2/13 ftrace: Fix output of enabled_functions for showing tramp
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
When showing all tramps registered to a ftrace record in the file enabled_functions, it exits the loop with ops == NULL. But then it is suppose to show the function on the ops->trampoline and add_trampoline_func() is called with the given ops. But because ops is now NULL (to exit the loop), it always shows the static trampoline instead of the one that is really registered to the record.
The call to add_trampoline_func() that shows the trampoline for the given ops needs to be called at every iteration.
--- kernel/trace/ftrace.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
kernel/trace/ftrace.c +4 -3
@@ -3322,7 +3322,7 @@ static int t_show(struct seq_file *m, void *v)seq_printf (m,"%ps" , (void *)rec->ip);if (iter->flags &FTRACE_ITER_ENABLED ) { -struct ftrace_ops *ops =NULL ; +struct ftrace_ops *ops; seq_printf(m, " (%ld)%s%s", ftrace_rec_count(rec),
@@ -3335,13 +3335,14 @@ static int t_show(struct seq_file *m, void *v)seq_printf (m,"\ttramp: %pS (%pS)" , (void *)ops->trampoline, (void *)ops->func); +add_trampoline_func (m, ops, rec); ops =ftrace_find_tramp_ops_next (rec, ops); }while (ops); }else seq_puts (m,"\ttramp: ERROR!" ); - + }else { +add_trampoline_func (m,NULL , rec); } -add_trampoline_func (m, ops, rec); }seq_putc (m,'\n' );
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 3/13 ftrace: Remove use of control list and ops
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Currently perf has its own list function within the ftrace infrastructure that seems to be used only to allow for it to have per-cpu disabling as well as a check to make sure that it's not called while RCU is not watching. It uses something called the "control_ops" which is used to iterate over ops under it with the control_list_func().
The problem is that this control_ops and control_list_func unnecessarily complicates the code. By replacing FTRACE_OPS_FL_CONTROL with two new flags (FTRACE_OPS_FL_RCU and FTRACE_OPS_FL_PER_CPU) we can remove all the code that is special with the control ops and add the needed checks within the generic ftrace_list_func().
--- include/linux/ftrace.h | 35 +++++------ kernel/trace/ftrace.c | 126 ++++++++++++---------------------------- kernel/trace/trace.h | 2 - kernel/trace/trace_event_perf.c | 2 +- 4 files changed, 57 insertions(+), 108 deletions(-)
include/linux/ftrace.h +18 -17
@@ -76,8 +76,8 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);* ENABLED - set/unset when ftrace_ops is registered/unregistered * DYNAMIC - set when ftrace_ops is registered to denote dynamically * allocated ftrace_ops which need special care -* CONTROL - set manualy by ftrace_ops user to denote the ftrace_ops -* could be controled by following calls: +* PER_CPU - set manualy by ftrace_ops user to denote the ftrace_ops +* could be controlled by following calls: * ftrace_function_local_enable * ftrace_function_local_disable * SAVE_REGS - The ftrace_ops wants regs saved at each function called
@@ -121,7 +121,7 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);enum {FTRACE_OPS_FL_ENABLED =1 <<0 ,FTRACE_OPS_FL_DYNAMIC =1 <<1 , -FTRACE_OPS_FL_CONTROL =1 <<2 , +FTRACE_OPS_FL_PER_CPU =1 <<2 ,FTRACE_OPS_FL_SAVE_REGS =1 <<3 ,FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED =1 <<4 ,FTRACE_OPS_FL_RECURSION_SAFE =1 <<5 ,
@@ -134,6 +134,7 @@ enum {FTRACE_OPS_FL_ALLOC_TRAMP =1 <<12 ,FTRACE_OPS_FL_IPMODIFY =1 <<13 ,FTRACE_OPS_FL_PID =1 <<14 , + FTRACE_OPS_FL_RCU = 1 << 15, };#ifdef CONFIG_DYNAMIC_FTRACE
@@ -146,11 +147,11 @@ struct ftrace_ops_hash {#endif /* -* Note, ftrace_ops can be referenced outside of RCU protection. -* (Although, for perf, the control ops prevent that). If ftrace_ops is -* allocated and not part of kernel core data, the unregistering of it will -* perform a scheduling on all CPUs to make sure that there are no more users. -* Depending on the load of the system that may take a bit of time. +* Note, ftrace_ops can be referenced outside of RCU protection, unless +* the RCU flag is set. If ftrace_ops is allocated and not part of kernel +* core data, the unregistering of it will perform a scheduling on all CPUs +* to make sure that there are no more users. Depending on the load of the +* system that may take a bit of time. * * Any private data added must also take care not to be freed and if private * data is added to a ftrace_ops that is in core code, the user of the
@@ -196,34 +197,34 @@ int unregister_ftrace_function(struct ftrace_ops *ops);void clear_ftrace_function (void );/** -* ftrace_function_local_enable - enable controlled ftrace_ops on current cpu +* ftrace_function_local_enable - enable ftrace_ops on current cpu * * This function enables tracing on current cpu by decreasing * the per cpu control variable. * It must be called with preemption disabled and only on ftrace_ops -* registered with FTRACE_OPS_FL_CONTROL. If called without preemption +* registered with FTRACE_OPS_FL_PER_CPU. If called without preemption * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. */ static inline void ftrace_function_local_enable (struct ftrace_ops *ops) { -if (WARN_ON_ONCE (!(ops->flags &FTRACE_OPS_FL_CONTROL ))) +if (WARN_ON_ONCE (!(ops->flags &FTRACE_OPS_FL_PER_CPU )))return ; (*this_cpu_ptr (ops->disabled))--; }/** -* ftrace_function_local_disable - enable controlled ftrace_ops on current cpu +* ftrace_function_local_disable - disable ftrace_ops on current cpu * -* This function enables tracing on current cpu by decreasing +* This function disables tracing on current cpu by increasing * the per cpu control variable. * It must be called with preemption disabled and only on ftrace_ops -* registered with FTRACE_OPS_FL_CONTROL. If called without preemption +* registered with FTRACE_OPS_FL_PER_CPU. If called without preemption * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. */ static inline void ftrace_function_local_disable (struct ftrace_ops *ops) { -if (WARN_ON_ONCE (!(ops->flags &FTRACE_OPS_FL_CONTROL ))) +if (WARN_ON_ONCE (!(ops->flags &FTRACE_OPS_FL_PER_CPU )))return ; (*this_cpu_ptr (ops->disabled))++;
@@ -235,12 +236,12 @@ static inline void ftrace_function_local_disable(struct ftrace_ops *ops)* * This function returns value of ftrace_ops::disabled on current cpu. * It must be called with preemption disabled and only on ftrace_ops -* registered with FTRACE_OPS_FL_CONTROL. If called without preemption +* registered with FTRACE_OPS_FL_PER_CPU. If called without preemption * disabled, this_cpu_ptr will complain when CONFIG_DEBUG_PREEMPT is enabled. */ static inline int ftrace_function_local_disabled (struct ftrace_ops *ops) { -WARN_ON_ONCE (!(ops->flags &FTRACE_OPS_FL_CONTROL )); +WARN_ON_ONCE (!(ops->flags &FTRACE_OPS_FL_PER_CPU ));return *this_cpu_ptr (ops->disabled); }
kernel/trace/ftrace.c +38 -88
233 lines not on this page · raw message
kernel/trace/trace.h +0 -2
@@ -467,8 +467,6 @@ enum {TRACE_INTERNAL_IRQ_BIT ,TRACE_INTERNAL_SIRQ_BIT , -TRACE_CONTROL_BIT , - TRACE_BRANCH_BIT,/* * Abuse of the trace_recursion.
kernel/trace/trace_event_perf.c +1 -1
@@ -334,7 +334,7 @@ static int perf_ftrace_function_register(struct perf_event *event) {struct ftrace_ops *ops = &event->ftrace_ops; - ops->flags |=FTRACE_OPS_FL_CONTROL ; + ops->flags |=FTRACE_OPS_FL_PER_CPU |FTRACE_OPS_FL_RCU ; ops->func = perf_ftrace_function_call;return register_ftrace_function (ops); }
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 4/13 ftrace: Have ftrace_ops_get_func() handle RCU and PER_CPU flags too
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
Jiri Olsa noted that the change to replace the control_ops did not update the trampoline for when running perf on a single CPU and with CONFIG_PREEMPT disabled (where dynamic ops, like perf, can use trampolines directly). The result was that perf function could be called when RCU is not watching as well as not handle the ftrace_local_disable().
Modify the ftrace_ops_get_func() to also check the RCU and PER_CPU ops flags and use the recursive function if they are set. The recursive function is modified to check those flags and execute the appropriate checks if they are set.
--- kernel/trace/ftrace.c | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-)
kernel/trace/ftrace.c +18 -12
@@ -115,9 +115,6 @@ static struct ftrace_ops *ftrace_ops_list __read_mostly = &ftrace_list_end;ftrace_func_t ftrace_trace_function__read_mostly = ftrace_stub;static struct ftrace_ops global_ops; -static void ftrace_ops_recurs_func (unsigned long ip,unsigned long parent_ip, -struct ftrace_ops *op,struct pt_regs *regs); -#if ARCH_SUPPORTS_FTRACE_OPS static void ftrace_ops_list_func (unsigned long ip,unsigned long parent_ip,struct ftrace_ops *op,struct pt_regs *regs);
@@ -5231,20 +5228,29 @@ static void ftrace_ops_no_ops(unsigned long ip, unsigned long parent_ip)/* * If there's only one function registered but it does not support -* recursion, this function will be called by the mcount trampoline. -* This function will handle recursion protection. +* recursion, needs RCU protection and/or requires per cpu handling, then +* this function will be called by the mcount trampoline. */ -static void ftrace_ops_recurs_func (unsigned long ip,unsigned long parent_ip, +static void ftrace_ops_assist_func (unsigned long ip,unsigned long parent_ip,struct ftrace_ops *op,struct pt_regs *regs) {int bit; +if ((op->flags &FTRACE_OPS_FL_RCU ) && !rcu_is_watching ()) +return ; + bit =trace_test_and_set_recursion (TRACE_LIST_START ,TRACE_LIST_MAX );if (bit <0 )return ; - op->func (ip, parent_ip, op, regs); +preempt_disable_notrace (); +if (!(op->flags &FTRACE_OPS_FL_PER_CPU ) || + !ftrace_function_local_disabled (op)) { + op->func (ip, parent_ip, op, regs); + } + +preempt_enable_notrace ();trace_clear_recursion (bit); }
@@ -5262,12 +5268,12 @@ static void ftrace_ops_recurs_func(unsigned long ip, unsigned long parent_ip,ftrace_func_t ftrace_ops_get_func (struct ftrace_ops *ops) {/* -* If the func handles its own recursion, call it directly. -* Otherwise call the recursion protected function that -* will call the ftrace ops function. +* If the function does not handle recursion, needs to be RCU safe, +* or does per cpu logic, then we need to call the assist handler. */ -if (!(ops->flags &FTRACE_OPS_FL_RECURSION_SAFE )) -return ftrace_ops_recurs_func; +if (!(ops->flags &FTRACE_OPS_FL_RECURSION_SAFE ) || + ops->flags & (FTRACE_OPS_FL_RCU |FTRACE_OPS_FL_PER_CPU )) +return ftrace_ops_assist_func;return ops->func; }
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 5/13 bpf: Constify bpf_verifier_ops structure
In reply to Steven RostedtFrom: Julia Lawall <[email protected]>
This bpf_verifier_ops structure is never modified, like the other bpf_verifier_ops structures, so declare it as const.
Done with the help of Coccinelle.
--- kernel/trace/bpf_trace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
kernel/trace/bpf_trace.c +1 -1
@@ -316,7 +316,7 @@ static bool kprobe_prog_is_valid_access(int off, int size, enum bpf_access_typereturn true; } -static struct bpf_verifier_ops kprobe_prog_ops = { +static const struct bpf_verifier_ops kprobe_prog_ops = { .get_func_proto = kprobe_prog_func_proto, .is_valid_access = kprobe_prog_is_valid_access, };
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 6/13 tracing: Use seq_buf_used() in seq_buf_to_user() instead of len
In reply to Steven RostedtFrom: Jerry Snitselaar <[email protected]>
commit 5ac48378414d ("tracing: Use trace_seq_used() and seq_buf_used() instead of len") changed the tracing code to use trace_seq_used() and seq_buf_used() instead of using the seq_buf len directly to avoid overflow issues, but missed a spot in seq_buf_to_user() that makes use of s->len.
Cleaned up the code a bit as well per suggestion of Steve Rostedt.
--- lib/seq_buf.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
lib/seq_buf.c +4 -2
@@ -306,10 +306,12 @@ int seq_buf_to_user(struct seq_buf *s, char __user *ubuf, int cnt)if (!cnt)return 0 ; -if (s->len <= s->readpos) + len =seq_buf_used (s); + +if (len <= s->readpos)return -EBUSY ; - len =seq_buf_used (s) - s->readpos; + len -= s->readpos;if (cnt > len) cnt = len; ret =copy_to_user (ubuf, s->buffer + s->readpos, cnt);
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 7/13 tracing: Introduce TRACE_EVENT_FN_COND macro
In reply to Steven RostedtFrom: Denis Kirjanov <[email protected]>
TRACE_EVENT_FN can't be used in some circumstances like invoking trace functions from offlined CPU due to RCU usage.
This patch adds the TRACE_EVENT_FN_COND macro to make such trace points conditional.
--- include/linux/tracepoint.h | 4 ++++ include/trace/define_trace.h | 6 ++++++ include/trace/trace_events.h | 6 ++++++ 3 files changed, 16 insertions(+)
include/linux/tracepoint.h +4 -0
@@ -493,6 +493,10 @@ extern void syscall_unregfunc(void);#define TRACE_EVENT_FN (name, proto, args, struct, \ assign, print, reg, unreg) \ DECLARE_TRACE(name, PARAMS(proto), PARAMS(args)) +#define TRACE_EVENT_FN_COND (name, proto, args, cond, struct, \ + assign, print, reg, unreg) \ + DECLARE_TRACE_CONDITION(name, PARAMS(proto), \ + PARAMS(args), PARAMS(cond))#define TRACE_EVENT_CONDITION (name, proto, args, cond, \ struct, assign, print) \ DECLARE_TRACE_CONDITION(name, PARAMS(proto), \
include/trace/define_trace.h +6 -0
@@ -40,6 +40,11 @@ assign, print, reg, unreg) \ DEFINE_TRACE_FN(name, reg, unreg) +#undef TRACE_EVENT_FN_COND +#define TRACE_EVENT_FN_COND (name, proto, args, cond, tstruct, \ + assign, print, reg, unreg) \ + DEFINE_TRACE_FN(name, reg, unreg) +#undef DEFINE_EVENT#define DEFINE_EVENT (template, name, proto, args) \ DEFINE_TRACE(name)
@@ -93,6 +98,7 @@#undef TRACE_EVENT#undef TRACE_EVENT_FN +#undef TRACE_EVENT_FN_COND#undef TRACE_EVENT_CONDITION#undef DECLARE_EVENT_CLASS#undef DEFINE_EVENT
include/trace/trace_events.h +6 -0
@@ -123,6 +123,12 @@ TRACE_MAKE_SYSTEM_STR();TRACE_EVENT (name,PARAMS (proto),PARAMS (args), \ PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \ +#undef TRACE_EVENT_FN_COND +#define TRACE_EVENT_FN_COND (name, proto, args, cond, tstruct, \ + assign, print, reg, unreg) \ + TRACE_EVENT_CONDITION(name, PARAMS(proto), PARAMS(args), PARAMS(cond), \ + PARAMS(tstruct), PARAMS(assign), PARAMS(print)) \ +#undef TRACE_EVENT_FLAGS#define TRACE_EVENT_FLAGS (name, value) \ __TRACE_EVENT_FLAGS(name, value)
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 8/13 ftrace: Join functions ftrace_module_init() and ftrace_init_module()
In reply to Steven RostedtFrom: Abel Vesa <[email protected]>
Simple cleanup. No need for two functions here.
The whole work can simply be done inside 'ftrace_module_init'.
--- kernel/trace/ftrace.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-)
kernel/trace/ftrace.c +6 -9
@@ -4980,19 +4980,16 @@ void ftrace_release_mod(struct module *mod)mutex_unlock (&ftrace_lock); } -static void ftrace_init_module (struct module *mod, -unsigned long *start,unsigned long *end) +void ftrace_module_init (struct module *mod) { +unsigned long *start = mod->ftrace_callsites; +unsigned long *end = mod->ftrace_callsites + + mod->num_ftrace_callsites; +if (ftrace_disabled || start == end)return ; -ftrace_process_locs (mod, start, end); -} -void ftrace_module_init (struct module *mod) -{ -ftrace_init_module (mod, mod->ftrace_callsites, - mod->ftrace_callsites + - mod->num_ftrace_callsites); +ftrace_process_locs (mod, start, end); } static int ftrace_module_notify_exit(struct notifier_block *self,
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 9/13 ftrace: Clean up ftrace_module_init() code
In reply to Steven RostedtFrom: "Steven Rostedt (Red Hat)" <[email protected]>
The start and end variables were only used when ftrace_module_init() was split up into multiple functions. No need to keep them around after the merger.
--- kernel/trace/ftrace.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-)
kernel/trace/ftrace.c +3 -6
@@ -4982,14 +4982,11 @@ void ftrace_release_mod(struct module *mod)void ftrace_module_init (struct module *mod) { -unsigned long *start = mod->ftrace_callsites; -unsigned long *end = mod->ftrace_callsites + - mod->num_ftrace_callsites; - -if (ftrace_disabled || start == end) +if (ftrace_disabled || !mod->num_ftrace_callsites)return ; -ftrace_process_locs (mod, start, end); +ftrace_process_locs (mod, mod->ftrace_callsites, + mod->ftrace_callsites + mod->num_ftrace_callsites); } static int ftrace_module_notify_exit(struct notifier_block *self,
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 10/13 ia64: ftrace: Fix the comments for ftrace_modify_code()
In reply to Steven RostedtFrom: Li Bin <[email protected]>
There is no need to worry about module and __init text disappearing case, because that ftrace has a module notifier that is called when a module is being unloaded and before the text goes away and this code grabs the ftrace_lock mutex and removes the module functions from the ftrace list, such that it will no longer do any modifications to that module's text, the update to make functions be traced or not is done under the ftrace_lock mutex as well. And by now, __init section codes should not been modified by ftrace, because it is black listed in recordmcount.c and ignored by ftrace.
--- arch/ia64/kernel/ftrace.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-)
arch/ia64/kernel/ftrace.c +5 -7
@@ -97,13 +97,11 @@ ftrace_modify_code(unsigned long ip, unsigned char *old_code,unsigned char replaced[MCOUNT_INSN_SIZE ];/* -* Note: Due to modules and __init, code can -* disappear and change, we need to protect against faulting -* as well as code changing. We do this by using the -* probe_kernel_* functions. -* -* No real locking needed, this code is run through -* kstop_machine, or before SMP starts. +* Note: +* We are paranoid about modifying text, as if a bug was to happen, it +* could cause us to read or write to someplace that could cause harm. +* Carefully read and modify the code with probe_kernel_*(), and make +* sure what we read is what we expected it to be before modifying it. */ if (!do_check)
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 11/13 sh: ftrace: Fix the comments for ftrace_modify_code()
In reply to Steven RostedtFrom: Li Bin <[email protected]>
There is no need to worry about module and __init text disappearing case, because that ftrace has a module notifier that is called when a module is being unloaded and before the text goes away and this code grabs the ftrace_lock mutex and removes the module functions from the ftrace list, such that it will no longer do any modifications to that module's text, the update to make functions be traced or not is done under the ftrace_lock mutex as well. And by now, __init section codes should not been modified by ftrace, because it is black listed in recordmcount.c and ignored by ftrace.
--- arch/sh/kernel/ftrace.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-)
arch/sh/kernel/ftrace.c +5 -7
@@ -212,13 +212,11 @@ static int ftrace_modify_code(unsigned long ip, unsigned char *old_code,unsigned char replaced[MCOUNT_INSN_SIZE ];/* -* Note: Due to modules and __init, code can -* disappear and change, we need to protect against faulting -* as well as code changing. We do this by using the -* probe_kernel_* functions. -* -* No real locking needed, this code is run through -* kstop_machine, or before SMP starts. +* Note: +* We are paranoid about modifying text, as if a bug was to happen, it +* could cause us to read or write to someplace that could cause harm. +* Carefully read and modify the code with probe_kernel_*(), and make +* sure what we read is what we expected it to be before modifying it. */ /* read the text we want to modify */
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 12/13 metag: ftrace: Fix the comments for ftrace_modify_code
In reply to Steven RostedtFrom: Li Bin <[email protected]>
There is no need to worry about module and __init text disappearing case, because that ftrace has a module notifier that is called when a module is being unloaded and before the text goes away and this code grabs the ftrace_lock mutex and removes the module functions from the ftrace list, such that it will no longer do any modifications to that module's text, the update to make functions be traced or not is done under the ftrace_lock mutex as well. And by now, __init section codes should not been modified by ftrace, because it is black listed in recordmcount.c and ignored by ftrace.
--- arch/metag/kernel/ftrace.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-)
arch/metag/kernel/ftrace.c +5 -6
@@ -54,12 +54,11 @@ static int ftrace_modify_code(unsigned long pc, unsigned char *old_code,unsigned char replaced[MCOUNT_INSN_SIZE ];/* -* Note: Due to modules and __init, code can -* disappear and change, we need to protect against faulting -* as well as code changing. -* -* No real locking needed, this code is run through -* kstop_machine. +* Note: +* We are paranoid about modifying text, as if a bug was to happen, it +* could cause us to read or write to someplace that could cause harm. +* Carefully read and modify the code with probe_kernel_*(), and make +* sure what we read is what we expected it to be before modifying it. */ /* read the text we want to modify */
Signature · 1 line
2.6.2
Steven Rostedt
maintainerPATCH 13/13 tracing: Fix comment to use tracing_on over tracing_enable
In reply to Steven RostedtFrom: Chuyu Hu <[email protected]>
The file tracing_enable is obsolete and does not exist anymore. Replace the comment that references it with the proper tracing_on file.
--- kernel/trace/trace.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/trace/trace.h +2 -2
@@ -363,8 +363,8 @@ struct trace_option_dentry {* @name: the name chosen to select it on the available_tracers file * @init: called when one switches to this tracer (echo name > current_tracer) * @reset: called when one switches to another tracer -* @start: called when tracing is unpaused (echo 1 > tracing_enabled) -* @stop: called when tracing is paused (echo 0 > tracing_enabled) +* @start: called when tracing is unpaused (echo 1 > tracing_on) +* @stop: called when tracing is paused (echo 0 > tracing_on) * @update_thresh: called when tracing_thresh is updated * @open: called when the trace file is opened * @pipe_open: called when the trace_pipe file is opened
Signature · 1 line
2.6.2