arch: x86: ia32: Implement perf stack thrace func

Implement stack trace function for x86_32 arch, that get required
thread register values and unwind stack with it.

Signed-off-by: Mikhail Kushnerov <[email protected]>

Author: Mikhail Kushnerov

arch/x86/core/ia32.cmake

@@ -25,6 +25,8 @@ zephyr_library_sources_ifdef(CONFIG_GDBSTUB		ia32/gdbstub.c)
 
 zephyr_library_sources_ifdef(CONFIG_DEBUG_COREDUMP	ia32/coredump.c)
 
+zephyr_library_sources_ifdef(CONFIG_PROFILING_PERF	ia32/perf.c)
+
 zephyr_library_sources_ifdef(
   CONFIG_X86_USE_THREAD_LOCAL_STORAGE
   ia32/tls.c

arch/x86/core/ia32/intstub.S

@@ -112,11 +112,12 @@ SECTION_FUNC(PINNED_TEXT, _interrupt_enter)
 	 * EAX = isr_param, EDX = isr
 	 */
 
-	/* Push EDI as we will use it for scratch space.
+	/* Push EBP as we will use it for scratch space.
+     * Also it helps in stack unwinding
 	 * Rest of the callee-saved regs get saved by invocation of C
 	 * functions (isr handler, arch_swap(), etc)
 	 */
-	pushl	%edi
+	pushl	%ebp
 
 	/* load %ecx with &_kernel */
 
@@ -131,17 +132,17 @@ SECTION_FUNC(PINNED_TEXT, _interrupt_enter)
 	jne	alreadyOnIntStack
 
 	/*
-	 * switch to base of the interrupt stack: save esp in edi, then load
+	 * switch to base of the interrupt stack: save esp in ebp, then load
 	 * irq_stack pointer
 	 */
 
-	movl	%esp, %edi
+	movl	%esp, %ebp
 	movl	_kernel_offset_to_irq_stack(%ecx), %esp
 
 
 	/* save thread's stack pointer onto base of interrupt stack */
 
-	pushl	%edi			/* Save stack pointer */
+	pushl	%ebp			/* Save stack pointer */
 
 #ifdef CONFIG_PM
 	cmpl	$0, _kernel_offset_to_idle(%ecx)
@@ -265,7 +266,7 @@ alreadyOnIntStack:
 #endif /* CONFIG_LAZY_FPU_SHARING */
 
 	/* Restore volatile registers and return to the interrupted thread */
-	popl	%edi
+	popl	%ebp
 	popl	%ecx
 	popl	%edx
 	popl	%eax
@@ -298,7 +299,7 @@ noReschedule:
 	 */
 
 nestedInterrupt:
-	popl	%edi
+	popl	%ebp
 	popl	%ecx		/* pop volatile registers in reverse order */
 	popl	%edx
 	popl	%eax

arch/x86/core/ia32/perf.c

@@ -0,0 +1,81 @@
+/*
+ *  Copyright (c) 2023 KNS Group LLC (YADRO)
+ *  Copyright (c) 2020 Yonatan Goldschmidt <[email protected]>
+ *
+ *  SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/kernel.h>
+
+static bool valid_stack(uintptr_t addr, k_tid_t current)
+{
+	return current->stack_info.start <= addr &&
+		addr < current->stack_info.start + current->stack_info.size;
+}
+
+/* interruption stack frame */
+struct isf {
+	uint32_t ebp;
+	uint32_t ecx;
+	uint32_t edx;
+	uint32_t eax;
+	uint32_t eip;
+};
+
+/*
+ * This function use frame pointers to unwind stack and get trace of return addresses.
+ * Return addresses are translated in corresponding function's names using .elf file.
+ * So we get function call trace
+ */
+size_t arch_perf_current_stack_trace(uintptr_t *buf, size_t size)
+{
+	if (size < 1U)
+		return 0;
+
+	size_t idx = 0;
+
+	const struct isf * const isf =
+		*((struct isf **)(((void **)_current_cpu->irq_stack)-1));
+	/*
+	 * In x86 (arch/x86/core/ia32/intstub.S) %eip and %ebp
+	 * are saved at the beginning of _interrupt_enter in order, that described
+	 * in struct esf. Core switch %esp to
+	 * _current_cpu->irq_stack and push %esp on irq stack
+	 *
+	 * The following lines lines do the reverse things to get %eip and %ebp
+	 * from thread stack
+	 */
+	void **fp = (void **)isf->ebp;
+
+	/*
+	 * %ebp is frame pointer.
+	 *
+	 * stack frame in memory:
+	 * (addresses growth up)
+	 *  ....
+	 *  ra
+	 *  %ebp (next) <- %ebp (curr)
+	 *  ....
+	 */
+
+	buf[idx++] = (uintptr_t)isf->eip;
+	while (valid_stack((uintptr_t)fp, _current)) {
+		if (idx >= size)
+			return 0;
+
+		buf[idx++] = (uintptr_t)fp[1];
+		void **new_fp = (void **)fp[0];
+
+		/*
+		 * anti-infinity-loop if
+		 * new_fp can't be smaller than fp, cause the stack is growing down
+		 * and trace moves deeper into the stack
+		 */
+		if (new_fp <= fp) {
+			break;
+		}
+		fp = new_fp;
+	}
+
+	return idx;
+}