[LTP] [LTP PATCH 2/5] ftrace: Add C implementation of ftrace_regression01

[Praveen K Pandey]

Convert ftrace_regression01.sh to C. This test checks for kernel
panic when using userstacktrace with page fault events.

The C version improves upon the shell version by:
- Properly checking file existence before access
- Reporting TCONF when features are unavailable
- Supporting both exceptions:page_fault_kernel and
  kmem:mm_kernel_pagefault events

This fixes issues seen on kernel 6.12+ and 6.18.1+ where the
shell version would fail with file access errors.

Fixes: #1282
Signed-off-by: Praveen K Pandey <praveen@linux.ibm.com>
---
 .../tracing/ftrace_test/ftrace_regression01.c | 131 ++++++++++++++++++
 1 file changed, 131 insertions(+)
 create mode 100644 testcases/kernel/tracing/ftrace_test/ftrace_regression01.c

diff --git a/testcases/kernel/tracing/ftrace_test/ftrace_regression01.c b/testcases/kernel/tracing/ftrace_test/ftrace_regression01.c
new file mode 100644
index 000000000..83a11cbcb
--- /dev/null
+++ b/testcases/kernel/tracing/ftrace_test/ftrace_regression01.c
@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2015 Red Hat Inc.
+ * Copyright (c) 2024 Linux Test Project
+ * Copyright (c) IBM, 2026
+ *
+ * Author: Li Wang <liwang@redhat.com>
+ * Converted to C by: Praveen K Pandey <praveen@linux.ibm.com>
+ */
+
+/*\
+ * [Description]
+ *
+ * Test for kernel panic while using userstacktrace.
+ *
+ * This is a regression test for a kernel bug where enabling userstacktrace
+ * along with page fault events could cause a kernel panic:
+ *
+ * - BUG: unable to handle kernel paging request
+ * - Thread overran stack, or stack corrupted
+ *
+ * The bug was fixed by commit 1dbd195 (tracing: Fix preempt count leak)
+ *
+ * [Algorithm]
+ *
+ * 1. Enable stack tracer
+ * 2. Enable userstacktrace option
+ * 3. Enable page fault events (either exceptions:page_fault_kernel or
+ *    kmem:mm_kernel_pagefault depending on kernel version)
+ * 4. Repeat multiple times to trigger the issue
+ * 5. System should not panic
+ */
+
+#include "ftrace_lib.h"
+
+#define LOOP_COUNT 10
+
+static void run_test(void)
+{
+	int i;
+	char *exc_page_fault_enable = NULL;
+	char *mm_page_fault_enable = NULL;
+	int use_exc_event = 0;
+
+	/* Check if stack tracer is available */
+	if (access("/proc/sys/kernel/stack_tracer_enabled", F_OK) != 0)
+		tst_brk(TCONF, "Stack tracer is not configured in this kernel");
+
+	/* Determine which page fault event is available */
+	if (ftrace_file_exists("events/exceptions/page_fault_kernel/enable")) {
+		use_exc_event = 1;
+		exc_page_fault_enable = ftrace_read_file("events/exceptions/page_fault_kernel/enable");
+	} else if (ftrace_file_exists("events/kmem/mm_kernel_pagefault/enable")) {
+		use_exc_event = 0;
+		mm_page_fault_enable = ftrace_read_file("events/kmem/mm_kernel_pagefault/enable");
+	} else {
+		tst_brk(TCONF, "Neither page_fault_kernel nor mm_kernel_pagefault event is available");
+	}
+
+	/* Run the test loop */
+	for (i = 0; i < LOOP_COUNT; i++) {
+		FILE *fp;
+		char buf[128];
+		char *options;
+
+		/* Enable stack tracer */
+		fp = SAFE_FOPEN("/proc/sys/kernel/stack_tracer_enabled", "w");
+		SAFE_FPRINTF(fp, "1\n");
+		SAFE_FCLOSE(fp);
+
+		/* Enable userstacktrace option */
+		if (ftrace_write_file("trace_options", "userstacktrace\n") != 0)
+			tst_brk(TBROK, "Failed to set userstacktrace option");
+
+		/* Verify userstacktrace is enabled */
+		options = ftrace_read_file("trace_options");
+		if (!options || !strstr(options, "userstacktrace")) {
+			free(options);
+			tst_brk(TBROK, "Failed to enable userstacktrace");
+		}
+		free(options);
+
+		/* Enable page fault event */
+		if (use_exc_event) {
+			if (ftrace_write_file("events/exceptions/page_fault_kernel/enable", "1\n") != 0)
+				tst_res(TINFO, "Failed to enable page_fault_kernel event");
+		} else {
+			if (ftrace_write_file("events/kmem/mm_kernel_pagefault/enable", "1\n") != 0)
+				tst_res(TINFO, "Failed to enable mm_kernel_pagefault event");
+		}
+
+		/* Small delay to let events trigger */
+		usleep(10000);
+	}
+
+	/* Restore page fault event state */
+	if (use_exc_event && exc_page_fault_enable) {
+		snprintf(buf, sizeof(buf), "%s\n", exc_page_fault_enable);
+		ftrace_write_file("events/exceptions/page_fault_kernel/enable", buf);
+		free(exc_page_fault_enable);
+	} else if (!use_exc_event && mm_page_fault_enable) {
+		snprintf(buf, sizeof(buf), "%s\n", mm_page_fault_enable);
+		ftrace_write_file("events/kmem/mm_kernel_pagefault/enable", buf);
+		free(mm_page_fault_enable);
+	}
+
+	tst_res(TPASS, "System did not panic with userstacktrace enabled");
+}
+
+static void setup(void)
+{
+	ftrace_initialize();
+}
+
+static void cleanup(void)
+{
+	ftrace_cleanup();
+}
+
+static struct tst_test test = {
+	.test_all = run_test,
+	.setup = setup,
+	.cleanup = cleanup,
+	.needs_root = 1,
+	.tags = (const struct tst_tag[]) {
+		{"linux-git", "1dbd195"},
+		{"CVE", "2015-8550"},
+		{}
+	}
+};
+
-- 
2.50.1 (Apple Git-155)