From: Greg Kroah-Hartman Date: Tue, 11 Feb 2014 01:56:05 +0000 (-0800) Subject: 3.13-stable patches X-Git-Tag: v3.4.80~25 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=596f3ddf4ef18a189fb906e3a0ae9254c65c725e;p=thirdparty%2Fkernel%2Fstable-queue.git 3.13-stable patches added patches: ftrace-synchronize-setting-function_trace_op-with-ftrace_trace_function.patch --- diff --git a/queue-3.13/ftrace-fix-synchronization-location-disabling-and-freeing-ftrace_ops.patch b/queue-3.13/ftrace-fix-synchronization-location-disabling-and-freeing-ftrace_ops.patch index f505f789a6b..d3a6ef27728 100644 --- a/queue-3.13/ftrace-fix-synchronization-location-disabling-and-freeing-ftrace_ops.patch +++ b/queue-3.13/ftrace-fix-synchronization-location-disabling-and-freeing-ftrace_ops.patch @@ -27,7 +27,7 @@ Signed-off-by: Greg Kroah-Hartman --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c -@@ -447,20 +447,6 @@ static int __unregister_ftrace_function( +@@ -490,20 +490,6 @@ static int __unregister_ftrace_function( } else if (ops->flags & FTRACE_OPS_FL_CONTROL) { ret = remove_ftrace_list_ops(&ftrace_control_list, &control_ops, ops); @@ -48,7 +48,7 @@ Signed-off-by: Greg Kroah-Hartman } else ret = remove_ftrace_ops(&ftrace_ops_list, ops); -@@ -470,17 +456,6 @@ static int __unregister_ftrace_function( +@@ -513,17 +499,6 @@ static int __unregister_ftrace_function( if (ftrace_enabled) update_ftrace_function(); @@ -66,7 +66,7 @@ Signed-off-by: Greg Kroah-Hartman return 0; } -@@ -2164,10 +2139,41 @@ static int ftrace_shutdown(struct ftrace +@@ -2213,10 +2188,41 @@ static int ftrace_shutdown(struct ftrace command |= FTRACE_UPDATE_TRACE_FUNC; } diff --git a/queue-3.13/ftrace-have-function-graph-only-trace-based-on-global_ops-filters.patch b/queue-3.13/ftrace-have-function-graph-only-trace-based-on-global_ops-filters.patch index 9ae9d2d1c76..bd5b9cdc673 100644 --- a/queue-3.13/ftrace-have-function-graph-only-trace-based-on-global_ops-filters.patch +++ b/queue-3.13/ftrace-have-function-graph-only-trace-based-on-global_ops-filters.patch @@ -95,8 +95,8 @@ Signed-off-by: Greg Kroah-Hartman --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c -@@ -278,6 +278,12 @@ static void update_global_ops(void) - global_ops.func = func; +@@ -297,6 +297,12 @@ static void ftrace_sync_ipi(void *data) + smp_rmb(); } +#ifdef CONFIG_FUNCTION_GRAPH_TRACER @@ -108,16 +108,16 @@ Signed-off-by: Greg Kroah-Hartman static void update_ftrace_function(void) { ftrace_func_t func; -@@ -325,6 +331,8 @@ static int remove_ftrace_ops(struct ftra - { - struct ftrace_ops **p; +@@ -329,6 +335,8 @@ static void update_ftrace_function(void) + if (ftrace_trace_function == func) + return; + update_function_graph_func(); + /* - * If we are removing the last function, then simply point - * to the ftrace_stub. -@@ -4862,6 +4870,7 @@ int ftrace_graph_entry_stub(struct ftrac + * If we are using the list function, it doesn't care + * about the function_trace_ops. +@@ -4925,6 +4933,7 @@ int ftrace_graph_entry_stub(struct ftrac trace_func_graph_ret_t ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub; trace_func_graph_ent_t ftrace_graph_entry = ftrace_graph_entry_stub; @@ -125,7 +125,7 @@ Signed-off-by: Greg Kroah-Hartman /* Try to assign a return stack array on FTRACE_RETSTACK_ALLOC_SIZE tasks. */ static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_list) -@@ -5003,6 +5012,30 @@ static struct ftrace_ops fgraph_ops __re +@@ -5066,6 +5075,30 @@ static struct ftrace_ops fgraph_ops __re FTRACE_OPS_FL_RECURSION_SAFE, }; @@ -156,7 +156,7 @@ Signed-off-by: Greg Kroah-Hartman int register_ftrace_graph(trace_func_graph_ret_t retfunc, trace_func_graph_ent_t entryfunc) { -@@ -5027,7 +5060,16 @@ int register_ftrace_graph(trace_func_gra +@@ -5090,7 +5123,16 @@ int register_ftrace_graph(trace_func_gra } ftrace_graph_return = retfunc; @@ -174,7 +174,7 @@ Signed-off-by: Greg Kroah-Hartman ret = ftrace_startup(&fgraph_ops, FTRACE_START_FUNC_RET); -@@ -5046,6 +5088,7 @@ void unregister_ftrace_graph(void) +@@ -5109,6 +5151,7 @@ void unregister_ftrace_graph(void) ftrace_graph_active--; ftrace_graph_return = (trace_func_graph_ret_t)ftrace_stub; ftrace_graph_entry = ftrace_graph_entry_stub; diff --git a/queue-3.13/ftrace-synchronize-setting-function_trace_op-with-ftrace_trace_function.patch b/queue-3.13/ftrace-synchronize-setting-function_trace_op-with-ftrace_trace_function.patch new file mode 100644 index 00000000000..e4c07e1bc8c --- /dev/null +++ b/queue-3.13/ftrace-synchronize-setting-function_trace_op-with-ftrace_trace_function.patch @@ -0,0 +1,168 @@ +From 405e1d834807e51b2ebd3dea81cb51e53fb61504 Mon Sep 17 00:00:00 2001 +From: "Steven Rostedt (Red Hat)" +Date: Fri, 8 Nov 2013 14:17:30 -0500 +Subject: ftrace: Synchronize setting function_trace_op with ftrace_trace_function + +From: "Steven Rostedt (Red Hat)" + +commit 405e1d834807e51b2ebd3dea81cb51e53fb61504 upstream. + +ftrace_trace_function is a variable that holds what function will be called +directly by the assembly code (mcount). If just a single function is +registered and it handles recursion itself, then the assembly will call that +function directly without any helper function. It also passes in the +ftrace_op that was registered with the callback. The ftrace_op to send is +stored in the function_trace_op variable. + +The ftrace_trace_function and function_trace_op needs to be coordinated such +that the called callback wont be called with the wrong ftrace_op, otherwise +bad things can happen if it expected a different op. Luckily, there's no +callback that doesn't use the helper functions that requires this. But +there soon will be and this needs to be fixed. + +Use a set_function_trace_op to store the ftrace_op to set the +function_trace_op to when it is safe to do so (during the update function +within the breakpoint or stop machine calls). Or if dynamic ftrace is not +being used (static tracing) then we have to do a bit more synchronization +when the ftrace_trace_function is set as that takes affect immediately +(as oppose to dynamic ftrace doing it with the modification of the trampoline). + +Signed-off-by: Steven Rostedt +Signed-off-by: Greg Kroah-Hartman + +--- + kernel/trace/ftrace.c | 87 +++++++++++++++++++++++++++++++++++++++++--------- + 1 file changed, 72 insertions(+), 15 deletions(-) + +--- a/kernel/trace/ftrace.c ++++ b/kernel/trace/ftrace.c +@@ -85,6 +85,8 @@ int function_trace_stop __read_mostly; + + /* Current function tracing op */ + struct ftrace_ops *function_trace_op __read_mostly = &ftrace_list_end; ++/* What to set function_trace_op to */ ++static struct ftrace_ops *set_function_trace_op; + + /* List for set_ftrace_pid's pids. */ + LIST_HEAD(ftrace_pids); +@@ -278,6 +280,23 @@ static void update_global_ops(void) + global_ops.func = func; + } + ++static void ftrace_sync(struct work_struct *work) ++{ ++ /* ++ * This function is just a stub to implement a hard force ++ * of synchronize_sched(). This requires synchronizing ++ * tasks even in userspace and idle. ++ * ++ * Yes, function tracing is rude. ++ */ ++} ++ ++static void ftrace_sync_ipi(void *data) ++{ ++ /* Probably not needed, but do it anyway */ ++ smp_rmb(); ++} ++ + static void update_ftrace_function(void) + { + ftrace_func_t func; +@@ -296,16 +315,59 @@ static void update_ftrace_function(void) + !FTRACE_FORCE_LIST_FUNC)) { + /* Set the ftrace_ops that the arch callback uses */ + if (ftrace_ops_list == &global_ops) +- function_trace_op = ftrace_global_list; ++ set_function_trace_op = ftrace_global_list; + else +- function_trace_op = ftrace_ops_list; ++ set_function_trace_op = ftrace_ops_list; + func = ftrace_ops_list->func; + } else { + /* Just use the default ftrace_ops */ +- function_trace_op = &ftrace_list_end; ++ set_function_trace_op = &ftrace_list_end; + func = ftrace_ops_list_func; + } + ++ /* If there's no change, then do nothing more here */ ++ if (ftrace_trace_function == func) ++ return; ++ ++ /* ++ * If we are using the list function, it doesn't care ++ * about the function_trace_ops. ++ */ ++ if (func == ftrace_ops_list_func) { ++ ftrace_trace_function = func; ++ /* ++ * Don't even bother setting function_trace_ops, ++ * it would be racy to do so anyway. ++ */ ++ return; ++ } ++ ++#ifndef CONFIG_DYNAMIC_FTRACE ++ /* ++ * For static tracing, we need to be a bit more careful. ++ * The function change takes affect immediately. Thus, ++ * we need to coorditate the setting of the function_trace_ops ++ * with the setting of the ftrace_trace_function. ++ * ++ * Set the function to the list ops, which will call the ++ * function we want, albeit indirectly, but it handles the ++ * ftrace_ops and doesn't depend on function_trace_op. ++ */ ++ ftrace_trace_function = ftrace_ops_list_func; ++ /* ++ * Make sure all CPUs see this. Yes this is slow, but static ++ * tracing is slow and nasty to have enabled. ++ */ ++ schedule_on_each_cpu(ftrace_sync); ++ /* Now all cpus are using the list ops. */ ++ function_trace_op = set_function_trace_op; ++ /* Make sure the function_trace_op is visible on all CPUs */ ++ smp_wmb(); ++ /* Nasty way to force a rmb on all cpus */ ++ smp_call_function(ftrace_sync_ipi, NULL, 1); ++ /* OK, we are all set to update the ftrace_trace_function now! */ ++#endif /* !CONFIG_DYNAMIC_FTRACE */ ++ + ftrace_trace_function = func; + } + +@@ -410,17 +472,6 @@ static int __register_ftrace_function(st + return 0; + } + +-static void ftrace_sync(struct work_struct *work) +-{ +- /* +- * This function is just a stub to implement a hard force +- * of synchronize_sched(). This requires synchronizing +- * tasks even in userspace and idle. +- * +- * Yes, function tracing is rude. +- */ +-} +- + static int __unregister_ftrace_function(struct ftrace_ops *ops) + { + int ret; +@@ -1992,8 +2043,14 @@ void ftrace_modify_all_code(int command) + else if (command & FTRACE_DISABLE_CALLS) + ftrace_replace_code(0); + +- if (update && ftrace_trace_function != ftrace_ops_list_func) ++ if (update && ftrace_trace_function != ftrace_ops_list_func) { ++ function_trace_op = set_function_trace_op; ++ smp_wmb(); ++ /* If irqs are disabled, we are in stop machine */ ++ if (!irqs_disabled()) ++ smp_call_function(ftrace_sync_ipi, NULL, 1); + ftrace_update_ftrace_func(ftrace_trace_function); ++ } + + if (command & FTRACE_START_FUNC_RET) + ftrace_enable_ftrace_graph_caller(); diff --git a/queue-3.13/series b/queue-3.13/series index 47f49bf7f53..f0bd316c17a 100644 --- a/queue-3.13/series +++ b/queue-3.13/series @@ -1,7 +1,5 @@ mei-mei_hbm_dispatch-returns-void.patch selinux-fix-memory-leak-upon-loading-policy.patch -ftrace-have-function-graph-only-trace-based-on-global_ops-filters.patch -ftrace-fix-synchronization-location-disabling-and-freeing-ftrace_ops.patch tracing-have-trace-buffer-point-back-to-trace_array.patch tracing-check-if-tracing-is-enabled-in-trace_puts.patch arch-sh-kernel-kgdb.c-add-missing-include-linux-sched.h.patch @@ -106,3 +104,6 @@ drm-vmwgfx-fix-regression-caused-by-drm-ttm-make-ttm-reservation-calls-behave-li drm-mgag200-fix-oops-in-cursor-code.patch drm-mgag200-fix-typo-causing-bw-limits-to-be-ignored-on-some-chips.patch drm-mgag200-ast-cirrus-fix-regression-with-drm_can_sleep-conversion.patch +ftrace-synchronize-setting-function_trace_op-with-ftrace_trace_function.patch +ftrace-fix-synchronization-location-disabling-and-freeing-ftrace_ops.patch +ftrace-have-function-graph-only-trace-based-on-global_ops-filters.patch