From nobody Wed Dec 17 14:09:53 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id BAEE4C4167B for ; Mon, 27 Nov 2023 13:54:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233147AbjK0Nxz (ORCPT ); Mon, 27 Nov 2023 08:53:55 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46064 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233444AbjK0Nxp (ORCPT ); Mon, 27 Nov 2023 08:53:45 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CF8C7D63 for ; Mon, 27 Nov 2023 05:53:50 -0800 (PST) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 95A14C433CD; Mon, 27 Nov 2023 13:53:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1701093230; bh=BaKMcq+s6VngWMd3ngPTESGkVeznx5ygK1pn7TSuURA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=rX4Fs0k30d6BdyybeD8Gs8B4S0yfPlwedAGmfnOiLE3Ju297UKFf/iC1vum6DEYn+ PKXNMt3sfSTmLdieyu9GSms0PUrYZVNAZxWMYjXAihprA+MJz4IlJdISNFOMObdlZD GZtg1Uv6O2wW5selTcQu5ZmS55V5tuKzQi4tiVxLYjQukv4z7gHl+War8+Y4EeM2jn 3XEutvqP5gdMUaBTA7Y/Gak+caPHBddTrMWjCYhqoiojkAglqA009WhdzR94/E/Aq1 ah7b3m3fAEmDVMqlo1A8j8tXd9sDcYLZgPCCbNSeeHiUUDEXqh2nO0S20edLZ9zRj4 pKTwrqpxAaLiQ== 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 Subject: [PATCH v3 04/33] function_graph: Convert ret_stack to a series of longs Date: Mon, 27 Nov 2023 22:53:43 +0900 Message-Id: <170109322264.343914.17065521139612510215.stgit@devnote2> X-Mailer: git-send-email 2.34.1 In-Reply-To: <170109317214.343914.4784420430328654397.stgit@devnote2> References: <170109317214.343914.4784420430328654397.stgit@devnote2> User-Agent: StGit/0.19 MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Steven Rostedt (VMware) In order to make it possible to have multiple callbacks registered with the function_graph tracer, the retstack needs to be converted from an array of ftrace_ret_stack structures to an array of longs. This will allow to store the list of callbacks on the stack for the return side of the functions. Signed-off-by: Steven Rostedt (VMware) Signed-off-by: Masami Hiramatsu (Google) --- include/linux/sched.h | 2 - kernel/trace/fgraph.c | 124 ++++++++++++++++++++++++++++-----------------= ---- 2 files changed, 71 insertions(+), 55 deletions(-) diff --git a/include/linux/sched.h b/include/linux/sched.h index 77f01ac385f7..3af00d726847 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -1386,7 +1386,7 @@ struct task_struct { int curr_ret_depth; =20 /* Stack of return addresses for return function tracing: */ - struct ftrace_ret_stack *ret_stack; + unsigned long *ret_stack; =20 /* Timestamp for last schedule: */ unsigned long long ftrace_timestamp; diff --git a/kernel/trace/fgraph.c b/kernel/trace/fgraph.c index c83c005e654e..30edeb6d4aa9 100644 --- a/kernel/trace/fgraph.c +++ b/kernel/trace/fgraph.c @@ -25,6 +25,18 @@ #define ASSIGN_OPS_HASH(opsname, val) #endif =20 +#define FGRAPH_RET_SIZE sizeof(struct ftrace_ret_stack) +#define FGRAPH_RET_INDEX (ALIGN(FGRAPH_RET_SIZE, sizeof(long)) / sizeof(lo= ng)) +#define SHADOW_STACK_SIZE (PAGE_SIZE) +#define SHADOW_STACK_INDEX \ + (ALIGN(SHADOW_STACK_SIZE, sizeof(long)) / sizeof(long)) +/* Leave on a buffer at the end */ +#define SHADOW_STACK_MAX_INDEX (SHADOW_STACK_INDEX - FGRAPH_RET_INDEX) + +#define RET_STACK(t, index) ((struct ftrace_ret_stack *)(&(t)->ret_stack[i= ndex])) +#define RET_STACK_INC(c) ({ c +=3D FGRAPH_RET_INDEX; }) +#define RET_STACK_DEC(c) ({ c -=3D FGRAPH_RET_INDEX; }) + DEFINE_STATIC_KEY_FALSE(kill_ftrace_graph); int ftrace_graph_active; =20 @@ -69,6 +81,7 @@ static int ftrace_push_return_trace(unsigned long ret, unsigned long func, unsigned long frame_pointer, unsigned long *retp) { + struct ftrace_ret_stack *ret_stack; unsigned long long calltime; int index; =20 @@ -85,23 +98,25 @@ ftrace_push_return_trace(unsigned long ret, unsigned lo= ng func, smp_rmb(); =20 /* The return trace stack is full */ - if (current->curr_ret_stack =3D=3D FTRACE_RETFUNC_DEPTH - 1) { + if (current->curr_ret_stack >=3D SHADOW_STACK_MAX_INDEX) { atomic_inc(¤t->trace_overrun); return -EBUSY; } =20 calltime =3D trace_clock_local(); =20 - index =3D ++current->curr_ret_stack; + index =3D current->curr_ret_stack; + RET_STACK_INC(current->curr_ret_stack); + ret_stack =3D RET_STACK(current, index); barrier(); - current->ret_stack[index].ret =3D ret; - current->ret_stack[index].func =3D func; - current->ret_stack[index].calltime =3D calltime; + ret_stack->ret =3D ret; + ret_stack->func =3D func; + ret_stack->calltime =3D calltime; #ifdef HAVE_FUNCTION_GRAPH_FP_TEST - current->ret_stack[index].fp =3D frame_pointer; + ret_stack->fp =3D frame_pointer; #endif #ifdef HAVE_FUNCTION_GRAPH_RET_ADDR_PTR - current->ret_stack[index].retp =3D retp; + ret_stack->retp =3D retp; #endif return 0; } @@ -148,7 +163,7 @@ int function_graph_enter(unsigned long ret, unsigned lo= ng func, =20 return 0; out_ret: - current->curr_ret_stack--; + RET_STACK_DEC(current->curr_ret_stack); out: current->curr_ret_depth--; return -EBUSY; @@ -159,11 +174,13 @@ static void ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret, unsigned long frame_pointer) { + struct ftrace_ret_stack *ret_stack; int index; =20 index =3D current->curr_ret_stack; + RET_STACK_DEC(index); =20 - if (unlikely(index < 0 || index >=3D FTRACE_RETFUNC_DEPTH)) { + if (unlikely(index < 0 || index > SHADOW_STACK_MAX_INDEX)) { ftrace_graph_stop(); WARN_ON(1); /* Might as well panic, otherwise we have no where to go */ @@ -171,6 +188,7 @@ ftrace_pop_return_trace(struct ftrace_graph_ret *trace,= unsigned long *ret, return; } =20 + ret_stack =3D RET_STACK(current, index); #ifdef HAVE_FUNCTION_GRAPH_FP_TEST /* * The arch may choose to record the frame pointer used @@ -186,22 +204,22 @@ ftrace_pop_return_trace(struct ftrace_graph_ret *trac= e, unsigned long *ret, * Note, -mfentry does not use frame pointers, and this test * is not needed if CC_USING_FENTRY is set. */ - if (unlikely(current->ret_stack[index].fp !=3D frame_pointer)) { + if (unlikely(ret_stack->fp !=3D frame_pointer)) { ftrace_graph_stop(); WARN(1, "Bad frame pointer: expected %lx, received %lx\n" " from func %ps return to %lx\n", current->ret_stack[index].fp, frame_pointer, - (void *)current->ret_stack[index].func, - current->ret_stack[index].ret); + (void *)ret_stack->func, + ret_stack->ret); *ret =3D (unsigned long)panic; return; } #endif =20 - *ret =3D current->ret_stack[index].ret; - trace->func =3D current->ret_stack[index].func; - trace->calltime =3D current->ret_stack[index].calltime; + *ret =3D ret_stack->ret; + trace->func =3D ret_stack->func; + trace->calltime =3D ret_stack->calltime; trace->overrun =3D atomic_read(¤t->trace_overrun); trace->depth =3D current->curr_ret_depth--; /* @@ -262,7 +280,7 @@ static unsigned long __ftrace_return_to_handler(struct = fgraph_ret_regs *ret_regs * curr_ret_stack is after that. */ barrier(); - current->curr_ret_stack--; + RET_STACK_DEC(current->curr_ret_stack); =20 if (unlikely(!ret)) { ftrace_graph_stop(); @@ -305,12 +323,13 @@ unsigned long ftrace_return_to_handler(unsigned long = frame_pointer) struct ftrace_ret_stack * ftrace_graph_get_ret_stack(struct task_struct *task, int idx) { - idx =3D task->curr_ret_stack - idx; + int index =3D task->curr_ret_stack; =20 - if (idx >=3D 0 && idx <=3D task->curr_ret_stack) - return &task->ret_stack[idx]; + index -=3D FGRAPH_RET_INDEX * (idx + 1); + if (index < 0) + return NULL; =20 - return NULL; + return RET_STACK(task, index); } =20 /** @@ -332,18 +351,20 @@ ftrace_graph_get_ret_stack(struct task_struct *task, = int idx) unsigned long ftrace_graph_ret_addr(struct task_struct *task, int *idx, unsigned long ret, unsigned long *retp) { + struct ftrace_ret_stack *ret_stack; int index =3D task->curr_ret_stack; int i; =20 if (ret !=3D (unsigned long)dereference_kernel_function_descriptor(return= _to_handler)) return ret; =20 - if (index < 0) - return ret; + RET_STACK_DEC(index); =20 - for (i =3D 0; i <=3D index; i++) - if (task->ret_stack[i].retp =3D=3D retp) - return task->ret_stack[i].ret; + for (i =3D index; i >=3D 0; RET_STACK_DEC(i)) { + ret_stack =3D RET_STACK(task, i); + if (ret_stack->retp =3D=3D retp) + return ret_stack->ret; + } =20 return ret; } @@ -357,14 +378,15 @@ unsigned long ftrace_graph_ret_addr(struct task_struc= t *task, int *idx, return ret; =20 task_idx =3D task->curr_ret_stack; + RET_STACK_DEC(task_idx); =20 if (!task->ret_stack || task_idx < *idx) return ret; =20 task_idx -=3D *idx; - (*idx)++; + RET_STACK_INC(*idx); =20 - return task->ret_stack[task_idx].ret; + return RET_STACK(task, task_idx); } #endif /* HAVE_FUNCTION_GRAPH_RET_ADDR_PTR */ =20 @@ -402,7 +424,7 @@ trace_func_graph_ent_t ftrace_graph_entry =3D ftrace_gr= aph_entry_stub; static trace_func_graph_ent_t __ftrace_graph_entry =3D ftrace_graph_entry_= stub; =20 /* Try to assign a return stack array on FTRACE_RETSTACK_ALLOC_SIZE tasks.= */ -static int alloc_retstack_tasklist(struct ftrace_ret_stack **ret_stack_lis= t) +static int alloc_retstack_tasklist(unsigned long **ret_stack_list) { int i; int ret =3D 0; @@ -410,10 +432,7 @@ static int alloc_retstack_tasklist(struct ftrace_ret_s= tack **ret_stack_list) struct task_struct *g, *t; =20 for (i =3D 0; i < FTRACE_RETSTACK_ALLOC_SIZE; i++) { - ret_stack_list[i] =3D - kmalloc_array(FTRACE_RETFUNC_DEPTH, - sizeof(struct ftrace_ret_stack), - GFP_KERNEL); + ret_stack_list[i] =3D kmalloc(SHADOW_STACK_SIZE, GFP_KERNEL); if (!ret_stack_list[i]) { start =3D 0; end =3D i; @@ -431,9 +450,9 @@ static int alloc_retstack_tasklist(struct ftrace_ret_st= ack **ret_stack_list) =20 if (t->ret_stack =3D=3D NULL) { atomic_set(&t->trace_overrun, 0); - t->curr_ret_stack =3D -1; + t->curr_ret_stack =3D 0; t->curr_ret_depth =3D -1; - /* Make sure the tasks see the -1 first: */ + /* Make sure the tasks see the 0 first: */ smp_wmb(); t->ret_stack =3D ret_stack_list[start++]; } @@ -453,6 +472,7 @@ ftrace_graph_probe_sched_switch(void *ignore, bool pree= mpt, struct task_struct *next, unsigned int prev_state) { + struct ftrace_ret_stack *ret_stack; unsigned long long timestamp; int index; =20 @@ -477,8 +497,11 @@ ftrace_graph_probe_sched_switch(void *ignore, bool pre= empt, */ timestamp -=3D next->ftrace_timestamp; =20 - for (index =3D next->curr_ret_stack; index >=3D 0; index--) - next->ret_stack[index].calltime +=3D timestamp; + for (index =3D next->curr_ret_stack - FGRAPH_RET_INDEX; index >=3D 0; ) { + ret_stack =3D RET_STACK(next, index); + ret_stack->calltime +=3D timestamp; + index -=3D FGRAPH_RET_INDEX; + } } =20 static int ftrace_graph_entry_test(struct ftrace_graph_ent *trace) @@ -521,10 +544,10 @@ void update_function_graph_func(void) ftrace_graph_entry =3D __ftrace_graph_entry; } =20 -static DEFINE_PER_CPU(struct ftrace_ret_stack *, idle_ret_stack); +static DEFINE_PER_CPU(unsigned long *, idle_ret_stack); =20 static void -graph_init_task(struct task_struct *t, struct ftrace_ret_stack *ret_stack) +graph_init_task(struct task_struct *t, unsigned long *ret_stack) { atomic_set(&t->trace_overrun, 0); t->ftrace_timestamp =3D 0; @@ -539,7 +562,7 @@ graph_init_task(struct task_struct *t, struct ftrace_re= t_stack *ret_stack) */ void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { - t->curr_ret_stack =3D -1; + t->curr_ret_stack =3D 0; t->curr_ret_depth =3D -1; /* * The idle task has no parent, it either has its own @@ -549,14 +572,11 @@ void ftrace_graph_init_idle_task(struct task_struct *= t, int cpu) WARN_ON(t->ret_stack !=3D per_cpu(idle_ret_stack, cpu)); =20 if (ftrace_graph_active) { - struct ftrace_ret_stack *ret_stack; + unsigned long *ret_stack; =20 ret_stack =3D per_cpu(idle_ret_stack, cpu); if (!ret_stack) { - ret_stack =3D - kmalloc_array(FTRACE_RETFUNC_DEPTH, - sizeof(struct ftrace_ret_stack), - GFP_KERNEL); + ret_stack =3D kmalloc(SHADOW_STACK_SIZE, GFP_KERNEL); if (!ret_stack) return; per_cpu(idle_ret_stack, cpu) =3D ret_stack; @@ -570,15 +590,13 @@ void ftrace_graph_init_task(struct task_struct *t) { /* Make sure we do not use the parent ret_stack */ t->ret_stack =3D NULL; - t->curr_ret_stack =3D -1; + t->curr_ret_stack =3D 0; t->curr_ret_depth =3D -1; =20 if (ftrace_graph_active) { - struct ftrace_ret_stack *ret_stack; + unsigned long *ret_stack; =20 - ret_stack =3D kmalloc_array(FTRACE_RETFUNC_DEPTH, - sizeof(struct ftrace_ret_stack), - GFP_KERNEL); + ret_stack =3D kmalloc(SHADOW_STACK_SIZE, GFP_KERNEL); if (!ret_stack) return; graph_init_task(t, ret_stack); @@ -587,7 +605,7 @@ void ftrace_graph_init_task(struct task_struct *t) =20 void ftrace_graph_exit_task(struct task_struct *t) { - struct ftrace_ret_stack *ret_stack =3D t->ret_stack; + unsigned long *ret_stack =3D t->ret_stack; =20 t->ret_stack =3D NULL; /* NULL must become visible to IRQs before we free it: */ @@ -599,12 +617,10 @@ void ftrace_graph_exit_task(struct task_struct *t) /* Allocate a return stack for each task */ static int start_graph_tracing(void) { - struct ftrace_ret_stack **ret_stack_list; + unsigned long **ret_stack_list; int ret, cpu; =20 - ret_stack_list =3D kmalloc_array(FTRACE_RETSTACK_ALLOC_SIZE, - sizeof(struct ftrace_ret_stack *), - GFP_KERNEL); + ret_stack_list =3D kmalloc(SHADOW_STACK_SIZE, GFP_KERNEL); =20 if (!ret_stack_list) return -ENOMEM;