From nobody Fri Nov 29 23:49:34 2024 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 159DD1C3F1D; Sun, 15 Sep 2024 09:10:11 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1726391412; cv=none; b=sxMiO8G0sMeDirZwsHmAdURfVGCYZtWVk4LT2XupQ9Oxiywljqkp1Lp7RJHKak34L0CPqQmkJLdUJ4FScRlbxv9jNl/anQDG0y+nzrM8ii3Um5a7zykymuO5ShdEPOVIHEg2KlFFMdwgHYt7dsVIbWv3LnUwOuURb+60Psrs1VY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1726391412; c=relaxed/simple; bh=zak5l4q/srTzoj7xpILeQ/IpGTWeBkdtvqrlp8jdEi0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=sPNeVnMZV/YEhbJneTERAuEGNBW6Ssg4nIAWOrIvWk7DHI2EeBOhUAJzK5HD79ygNxJGT8PWbPrUpmcGbAtyR1zOX+g/W5byx0jSJO0NdAKuMIZZc5dP9KA6r20gANfyhAnX76qtgF0n2LOiXtpGC7HTKg4gNZ1TPw16bUJ6isM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=B6h9Xk+Q; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="B6h9Xk+Q" Received: by smtp.kernel.org (Postfix) with ESMTPSA id BBBC2C4CEC3; Sun, 15 Sep 2024 09:10:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1726391411; bh=zak5l4q/srTzoj7xpILeQ/IpGTWeBkdtvqrlp8jdEi0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=B6h9Xk+Q3mhMMK8IRlvpYSTYV4/Z2JkADgvA7bFi7U/zfqtahG7BCi51AV8B8n+Yl rNhA/37nnSqkPiLIgl4PdFuOCRTlJvfN3EVCANS/zT57X3Re3x7MOO8tAEG6AaMxY1 kiarB+lkI/fgZKYa96j4T0mciUCgIIkWdDq5bpysxoz8lgTMJYrvGnvAZMddaFK/vX aczl9nnFocgmUQCgXHyKgCp1pK2ZcFcbo6y2VeXZ8vBOizcJn0eyFgxUXnj3nOmbkc aZKWqx2b1zPeCriaPtUdJgZPQT3wQiDKJ02+9jsl/psC9jEa0I2Md2emX5WZe+8dEJ Y4eJoA5tm4mag== From: "Masami Hiramatsu (Google)" To: Alexei Starovoitov , Steven Rostedt , Florent Revest Cc: linux-trace-kernel@vger.kernel.org, LKML , Martin KaFai Lau , bpf , Sven Schnelle , Alexei Starovoitov , Jiri Olsa , Arnaldo Carvalho de Melo , Daniel Borkmann , Alan Maguire , Mark Rutland , Peter Zijlstra , Thomas Gleixner , Guo Ren , linux-arch@vger.kernel.org Subject: [PATCH v15 03/19] function_graph: Pass ftrace_regs to entryfunc Date: Sun, 15 Sep 2024 18:10:05 +0900 Message-Id: <172639140527.366111.9896534785607143001.stgit@devnote2> X-Mailer: git-send-email 2.34.1 In-Reply-To: <172639136989.366111.11359590127009702129.stgit@devnote2> References: <172639136989.366111.11359590127009702129.stgit@devnote2> User-Agent: StGit/0.19 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable From: Masami Hiramatsu (Google) Pass ftrace_regs to the fgraph_ops::entryfunc(). If ftrace_regs is not available, it passes a NULL instead. User callback function can access some registers (including return address) via this ftrace_regs. Signed-off-by: Masami Hiramatsu (Google) --- Changes in v11: - Update for the latest for-next branch. Changes in v8: - Just pass ftrace_regs to the handler instead of adding a new entryregfunc. - Update riscv ftrace_graph_func(). Changes in v3: - Update for new multiple fgraph. --- arch/arm64/kernel/ftrace.c | 20 +++++++++++- arch/loongarch/kernel/ftrace_dyn.c | 10 +++++- arch/powerpc/kernel/trace/ftrace.c | 2 + arch/powerpc/kernel/trace/ftrace_64_pg.c | 10 ++++-- arch/riscv/kernel/ftrace.c | 17 ++++++++++ arch/x86/kernel/ftrace.c | 50 +++++++++++++++++++++-----= ---- include/linux/ftrace.h | 18 ++++++++--- kernel/trace/fgraph.c | 23 ++++++++------ kernel/trace/ftrace.c | 3 +- kernel/trace/trace.h | 3 +- kernel/trace/trace_functions_graph.c | 3 +- kernel/trace/trace_irqsoff.c | 3 +- kernel/trace/trace_sched_wakeup.c | 3 +- kernel/trace/trace_selftest.c | 8 +++-- 14 files changed, 128 insertions(+), 45 deletions(-) diff --git a/arch/arm64/kernel/ftrace.c b/arch/arm64/kernel/ftrace.c index a650f5e11fc5..bc647b725e6a 100644 --- a/arch/arm64/kernel/ftrace.c +++ b/arch/arm64/kernel/ftrace.c @@ -481,7 +481,25 @@ void prepare_ftrace_return(unsigned long self_addr, un= signed long *parent, void ftrace_graph_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs) { - prepare_ftrace_return(ip, &fregs->lr, fregs->fp); + unsigned long return_hooker =3D (unsigned long)&return_to_handler; + unsigned long frame_pointer =3D fregs->fp; + unsigned long *parent =3D &fregs->lr; + unsigned long old; + + if (unlikely(atomic_read(¤t->tracing_graph_pause))) + return; + + /* + * Note: + * No protection against faulting at *parent, which may be seen + * on other archs. It's unlikely on AArch64. + */ + old =3D *parent; + + if (!function_graph_enter_regs(old, ip, frame_pointer, + (void *)frame_pointer, fregs)) { + *parent =3D return_hooker; + } } #else /* diff --git a/arch/loongarch/kernel/ftrace_dyn.c b/arch/loongarch/kernel/ftr= ace_dyn.c index bff058317062..966e0f7f7aca 100644 --- a/arch/loongarch/kernel/ftrace_dyn.c +++ b/arch/loongarch/kernel/ftrace_dyn.c @@ -243,8 +243,16 @@ void ftrace_graph_func(unsigned long ip, unsigned long= parent_ip, { struct pt_regs *regs =3D &fregs->regs; unsigned long *parent =3D (unsigned long *)®s->regs[1]; + unsigned long return_hooker =3D (unsigned long)&return_to_handler; + unsigned long old; + + if (unlikely(atomic_read(¤t->tracing_graph_pause))) + return; + + old =3D *parent; =20 - prepare_ftrace_return(ip, (unsigned long *)parent); + if (!function_graph_enter_regs(old, ip, 0, parent, fregs)) + *parent =3D return_hooker; } #else static int ftrace_modify_graph_caller(bool enable) diff --git a/arch/powerpc/kernel/trace/ftrace.c b/arch/powerpc/kernel/trace= /ftrace.c index d8d6b4fd9a14..a1a0e0b57662 100644 --- a/arch/powerpc/kernel/trace/ftrace.c +++ b/arch/powerpc/kernel/trace/ftrace.c @@ -434,7 +434,7 @@ void ftrace_graph_func(unsigned long ip, unsigned long = parent_ip, if (bit < 0) goto out; =20 - if (!function_graph_enter(parent_ip, ip, 0, (unsigned long *)sp)) + if (!function_graph_enter_regs(parent_ip, ip, 0, (unsigned long *)sp, fre= gs)) parent_ip =3D ppc_function_entry(return_to_handler); =20 ftrace_test_recursion_unlock(bit); diff --git a/arch/powerpc/kernel/trace/ftrace_64_pg.c b/arch/powerpc/kernel= /trace/ftrace_64_pg.c index 12fab1803bcf..4ae9eeb1c8f1 100644 --- a/arch/powerpc/kernel/trace/ftrace_64_pg.c +++ b/arch/powerpc/kernel/trace/ftrace_64_pg.c @@ -800,7 +800,8 @@ int ftrace_disable_ftrace_graph_caller(void) * in current thread info. Return the address we want to divert to. */ static unsigned long -__prepare_ftrace_return(unsigned long parent, unsigned long ip, unsigned l= ong sp) +__prepare_ftrace_return(unsigned long parent, unsigned long ip, unsigned l= ong sp, + struct ftrace_regs *fregs) { unsigned long return_hooker; int bit; @@ -817,7 +818,7 @@ __prepare_ftrace_return(unsigned long parent, unsigned = long ip, unsigned long sp =20 return_hooker =3D ppc_function_entry(return_to_handler); =20 - if (!function_graph_enter(parent, ip, 0, (unsigned long *)sp)) + if (!function_graph_enter_regs(parent, ip, 0, (unsigned long *)sp, fregs)) parent =3D return_hooker; =20 ftrace_test_recursion_unlock(bit); @@ -829,13 +830,14 @@ __prepare_ftrace_return(unsigned long parent, unsigne= d long ip, unsigned long sp void ftrace_graph_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs) { - fregs->regs.link =3D __prepare_ftrace_return(parent_ip, ip, fregs->regs.g= pr[1]); + fregs->regs.link =3D __prepare_ftrace_return(parent_ip, ip, + fregs->regs.gpr[1], fregs); } #else unsigned long prepare_ftrace_return(unsigned long parent, unsigned long ip, unsigned long sp) { - return __prepare_ftrace_return(parent, ip, sp); + return __prepare_ftrace_return(parent, ip, sp, NULL); } #endif #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ diff --git a/arch/riscv/kernel/ftrace.c b/arch/riscv/kernel/ftrace.c index 4b95c574fd04..f5c3b5a752b0 100644 --- a/arch/riscv/kernel/ftrace.c +++ b/arch/riscv/kernel/ftrace.c @@ -214,7 +214,22 @@ void prepare_ftrace_return(unsigned long *parent, unsi= gned long self_addr, void ftrace_graph_func(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs) { - prepare_ftrace_return(&fregs->ra, ip, fregs->s0); + unsigned long return_hooker =3D (unsigned long)&return_to_handler; + unsigned long frame_pointer =3D fregs->s0; + unsigned long *parent =3D &fregs->ra; + unsigned long old; + + if (unlikely(atomic_read(¤t->tracing_graph_pause))) + return; + + /* + * We don't suffer access faults, so no extra fault-recovery assembly + * is needed here. + */ + old =3D *parent; + + if (!function_graph_enter_regs(old, ip, frame_pointer, parent, fregs)) + *parent =3D return_hooker; } #else /* CONFIG_DYNAMIC_FTRACE_WITH_ARGS */ extern void ftrace_graph_call(void); diff --git a/arch/x86/kernel/ftrace.c b/arch/x86/kernel/ftrace.c index 8da0e66ca22d..decf4c11dcf3 100644 --- a/arch/x86/kernel/ftrace.c +++ b/arch/x86/kernel/ftrace.c @@ -605,16 +605,8 @@ int ftrace_disable_ftrace_graph_caller(void) } #endif /* CONFIG_DYNAMIC_FTRACE && !CONFIG_HAVE_DYNAMIC_FTRACE_WITH_ARGS */ =20 -/* - * Hook the return address and push it in the stack of return addrs - * in current thread info. - */ -void prepare_ftrace_return(unsigned long ip, unsigned long *parent, - unsigned long frame_pointer) +static inline bool skip_ftrace_return(void) { - unsigned long return_hooker =3D (unsigned long)&return_to_handler; - int bit; - /* * When resuming from suspend-to-ram, this function can be indirectly * called from early CPU startup code while the CPU is in real mode, @@ -624,13 +616,28 @@ void prepare_ftrace_return(unsigned long ip, unsigned= long *parent, * This check isn't as accurate as virt_addr_valid(), but it should be * good enough for this purpose, and it's fast. */ - if (unlikely((long)__builtin_frame_address(0) >=3D 0)) - return; + if ((long)__builtin_frame_address(0) >=3D 0) + return true; =20 - if (unlikely(ftrace_graph_is_dead())) - return; + if (ftrace_graph_is_dead()) + return true; + + if (atomic_read(¤t->tracing_graph_pause)) + return true; + return false; +} + +/* + * Hook the return address and push it in the stack of return addrs + * in current thread info. + */ +void prepare_ftrace_return(unsigned long ip, unsigned long *parent, + unsigned long frame_pointer) +{ + unsigned long return_hooker =3D (unsigned long)&return_to_handler; + int bit; =20 - if (unlikely(atomic_read(¤t->tracing_graph_pause))) + if (unlikely(skip_ftrace_return())) return; =20 bit =3D ftrace_test_recursion_trylock(ip, *parent); @@ -649,8 +656,21 @@ void ftrace_graph_func(unsigned long ip, unsigned long= parent_ip, { struct pt_regs *regs =3D &fregs->regs; unsigned long *stack =3D (unsigned long *)kernel_stack_pointer(regs); + unsigned long return_hooker =3D (unsigned long)&return_to_handler; + unsigned long *parent =3D (unsigned long *)stack; + int bit; =20 - prepare_ftrace_return(ip, (unsigned long *)stack, 0); + if (unlikely(skip_ftrace_return())) + return; + + bit =3D ftrace_test_recursion_trylock(ip, *parent); + if (bit < 0) + return; + + if (!function_graph_enter_regs(*parent, ip, 0, parent, fregs)) + *parent =3D return_hooker; + + ftrace_test_recursion_unlock(bit); } #endif =20 diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h index 787f3eef70c4..a7a3fab37f39 100644 --- a/include/linux/ftrace.h +++ b/include/linux/ftrace.h @@ -1063,9 +1063,12 @@ struct fgraph_ops; typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *, struct fgraph_ops *); /* return */ typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *, - struct fgraph_ops *); /* entry */ + struct fgraph_ops *, + struct ftrace_regs *); /* entry */ =20 -extern int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace, struct = fgraph_ops *gops); +extern int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace, + struct fgraph_ops *gops, + struct ftrace_regs *fregs); bool ftrace_pids_enabled(struct ftrace_ops *ops); =20 #ifdef CONFIG_FUNCTION_GRAPH_TRACER @@ -1105,8 +1108,15 @@ struct ftrace_ret_stack { extern void return_to_handler(void); =20 extern int -function_graph_enter(unsigned long ret, unsigned long func, - unsigned long frame_pointer, unsigned long *retp); +function_graph_enter_regs(unsigned long ret, unsigned long func, + unsigned long frame_pointer, unsigned long *retp, + struct ftrace_regs *fregs); + +static inline int function_graph_enter(unsigned long ret, unsigned long fu= nc, + unsigned long fp, unsigned long *retp) +{ + return function_graph_enter_regs(ret, func, fp, retp, NULL); +} =20 struct ftrace_ret_stack * ftrace_graph_get_ret_stack(struct task_struct *task, int skip); diff --git a/kernel/trace/fgraph.c b/kernel/trace/fgraph.c index 58a28ec35dab..5b0780b28305 100644 --- a/kernel/trace/fgraph.c +++ b/kernel/trace/fgraph.c @@ -290,7 +290,8 @@ static inline unsigned long make_data_type_val(int idx,= int size, int offset) } =20 /* ftrace_graph_entry set to this to tell some archs to run function graph= */ -static int entry_run(struct ftrace_graph_ent *trace, struct fgraph_ops *op= s) +static int entry_run(struct ftrace_graph_ent *trace, struct fgraph_ops *op= s, + struct ftrace_regs *fregs) { return 0; } @@ -518,7 +519,7 @@ int __weak ftrace_disable_ftrace_graph_caller(void) #endif =20 int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, struct ftrace_regs *fregs) { return 0; } @@ -642,8 +643,9 @@ ftrace_push_return_trace(unsigned long ret, unsigned lo= ng func, #endif =20 /* If the caller does not use ftrace, call this function. */ -int function_graph_enter(unsigned long ret, unsigned long func, - unsigned long frame_pointer, unsigned long *retp) +int function_graph_enter_regs(unsigned long ret, unsigned long func, + unsigned long frame_pointer, unsigned long *retp, + struct ftrace_regs *fregs) { struct ftrace_graph_ent trace; unsigned long bitmap =3D 0; @@ -661,7 +663,7 @@ int function_graph_enter(unsigned long ret, unsigned lo= ng func, if (static_branch_likely(&fgraph_do_direct)) { int save_curr_ret_stack =3D current->curr_ret_stack; =20 - if (static_call(fgraph_func)(&trace, fgraph_direct_gops)) + if (static_call(fgraph_func)(&trace, fgraph_direct_gops, fregs)) bitmap |=3D BIT(fgraph_direct_gops->idx); else /* Clear out any saved storage */ @@ -679,7 +681,7 @@ int function_graph_enter(unsigned long ret, unsigned lo= ng func, =20 save_curr_ret_stack =3D current->curr_ret_stack; if (ftrace_ops_test(&gops->ops, func, NULL) && - gops->entryfunc(&trace, gops)) + gops->entryfunc(&trace, gops, fregs)) bitmap |=3D BIT(i); else /* Clear out any saved storage */ @@ -954,7 +956,7 @@ unsigned long ftrace_graph_ret_addr(struct task_struct = *task, int *idx, =20 static struct ftrace_ops graph_ops =3D { .func =3D ftrace_graph_func, - .flags =3D FTRACE_OPS_GRAPH_STUB, + .flags =3D FTRACE_OPS_GRAPH_STUB | FTRACE_OPS_FL_SAVE_ARGS, #ifdef FTRACE_GRAPH_TRAMP_ADDR .trampoline =3D FTRACE_GRAPH_TRAMP_ADDR, /* trampoline_size is only needed for dynamically allocated tramps */ @@ -964,7 +966,8 @@ static struct ftrace_ops graph_ops =3D { void fgraph_init_ops(struct ftrace_ops *dst_ops, struct ftrace_ops *src_ops) { - dst_ops->flags =3D FTRACE_OPS_FL_PID | FTRACE_OPS_GRAPH_STUB; + dst_ops->flags =3D FTRACE_OPS_FL_PID | FTRACE_OPS_GRAPH_STUB | + FTRACE_OPS_FL_SAVE_ARGS; =20 #ifdef CONFIG_DYNAMIC_FTRACE if (src_ops) { @@ -1136,7 +1139,7 @@ void ftrace_graph_exit_task(struct task_struct *t) =20 #ifdef CONFIG_DYNAMIC_FTRACE static int fgraph_pid_func(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, struct ftrace_regs *fregs) { struct trace_array *tr =3D gops->ops.private; int pid; @@ -1150,7 +1153,7 @@ static int fgraph_pid_func(struct ftrace_graph_ent *t= race, return 0; } =20 - return gops->saved_func(trace, gops); + return gops->saved_func(trace, gops, fregs); } =20 void fgraph_update_pid_func(void) diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c index 5dccb02b6525..3ab1bfaaafa1 100644 --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c @@ -827,7 +827,8 @@ struct profile_fgraph_data { }; =20 static int profile_graph_entry(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, + struct ftrace_regs *fregs) { struct profile_fgraph_data *profile_data; =20 diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 8a3cfe67a76c..c5588cdd2222 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -683,7 +683,8 @@ void trace_default_header(struct seq_file *m); void print_trace_header(struct seq_file *m, struct trace_iterator *iter); =20 void trace_graph_return(struct ftrace_graph_ret *trace, struct fgraph_ops = *gops); -int trace_graph_entry(struct ftrace_graph_ent *trace, struct fgraph_ops *g= ops); +int trace_graph_entry(struct ftrace_graph_ent *trace, struct fgraph_ops *g= ops, + struct ftrace_regs *fregs); =20 void tracing_start_cmdline_record(void); void tracing_stop_cmdline_record(void); diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_func= tions_graph.c index ff0871a9425a..9a8355cc4e02 100644 --- a/kernel/trace/trace_functions_graph.c +++ b/kernel/trace/trace_functions_graph.c @@ -133,7 +133,8 @@ struct fgraph_times { }; =20 int trace_graph_entry(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, + struct ftrace_regs *fregs) { unsigned long *task_var =3D fgraph_get_task_var(gops); struct trace_array *tr =3D gops->private; diff --git a/kernel/trace/trace_irqsoff.c b/kernel/trace/trace_irqsoff.c index fce064e20570..ad739d76fc86 100644 --- a/kernel/trace/trace_irqsoff.c +++ b/kernel/trace/trace_irqsoff.c @@ -176,7 +176,8 @@ static int irqsoff_display_graph(struct trace_array *tr= , int set) } =20 static int irqsoff_graph_entry(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, + struct ftrace_regs *fregs) { struct trace_array *tr =3D irqsoff_trace; struct trace_array_cpu *data; diff --git a/kernel/trace/trace_sched_wakeup.c b/kernel/trace/trace_sched_w= akeup.c index 130ca7e7787e..23360a2700de 100644 --- a/kernel/trace/trace_sched_wakeup.c +++ b/kernel/trace/trace_sched_wakeup.c @@ -113,7 +113,8 @@ static int wakeup_display_graph(struct trace_array *tr,= int set) } =20 static int wakeup_graph_entry(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, + struct ftrace_regs *fregs) { struct trace_array *tr =3D wakeup_trace; struct trace_array_cpu *data; diff --git a/kernel/trace/trace_selftest.c b/kernel/trace/trace_selftest.c index c4ad7cd7e778..89067f02094a 100644 --- a/kernel/trace/trace_selftest.c +++ b/kernel/trace/trace_selftest.c @@ -773,7 +773,8 @@ struct fgraph_fixture { }; =20 static __init int store_entry(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, + struct ftrace_regs *fregs) { struct fgraph_fixture *fixture =3D container_of(gops, struct fgraph_fixtu= re, gops); const char *type =3D fixture->store_type_name; @@ -1024,7 +1025,8 @@ static unsigned int graph_hang_thresh; =20 /* Wrap the real function entry probe to avoid possible hanging */ static int trace_graph_entry_watchdog(struct ftrace_graph_ent *trace, - struct fgraph_ops *gops) + struct fgraph_ops *gops, + struct ftrace_regs *fregs) { /* This is harmlessly racy, we want to approximately detect a hang */ if (unlikely(++graph_hang_thresh > GRAPH_MAX_FUNC_TEST)) { @@ -1038,7 +1040,7 @@ static int trace_graph_entry_watchdog(struct ftrace_g= raph_ent *trace, return 0; } =20 - return trace_graph_entry(trace, gops); + return trace_graph_entry(trace, gops, fregs); } =20 static struct fgraph_ops fgraph_ops __initdata =3D {