[v12,5/6] fs/proc: Show STACKLEAK metrics in the /proc file system
diff mbox

Message ID 1526488097-20611-6-git-send-email-alex.popov@linux.com
State New
Headers show

Commit Message

Alexander Popov May 16, 2018, 4:28 p.m. UTC
Introduce CONFIG_STACKLEAK_METRICS providing STACKLEAK information about
tasks via the /proc file system. In particular, /proc/<pid>/stack_depth
shows the maximum kernel stack consumption for the current and previous
syscalls. Although this information is not precise, it can be useful for
estimating the STACKLEAK performance impact for your workloads.

Signed-off-by: Alexander Popov <alex.popov@linux.com>
---
 arch/Kconfig                 | 12 ++++++++++++
 arch/x86/kernel/process_32.c |  3 +++
 arch/x86/kernel/process_64.c |  3 +++
 fs/proc/base.c               | 18 ++++++++++++++++++
 include/linux/stackleak.h    |  3 +++
 kernel/stackleak.c           |  4 ++++
 6 files changed, 43 insertions(+)

Patch
diff mbox

diff --git a/arch/Kconfig b/arch/Kconfig
index e9d3841..4ebe06f 100644
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -572,6 +572,18 @@  config STACKLEAK_TRACK_MIN_SIZE
 	  frame size greater than or equal to this parameter.
 	  If unsure, leave the default value 100.
 
+config STACKLEAK_METRICS
+	bool "Show STACKLEAK metrics in the /proc file system"
+	depends on GCC_PLUGIN_STACKLEAK
+	depends on PROC_FS
+	help
+	  If this is set, STACKLEAK metrics for every task are available in
+	  the /proc file system. In particular, /proc/<pid>/stack_depth
+	  shows the maximum kernel stack consumption for the current and
+	  previous syscalls. Although this information is not precise, it
+	  can be useful for estimating the STACKLEAK performance impact for
+	  your workloads.
+
 config HAVE_CC_STACKPROTECTOR
 	bool
 	help
diff --git a/arch/x86/kernel/process_32.c b/arch/x86/kernel/process_32.c
index a19ea44..3f5f6b8 100644
--- a/arch/x86/kernel/process_32.c
+++ b/arch/x86/kernel/process_32.c
@@ -139,6 +139,9 @@  int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
 #ifdef CONFIG_GCC_PLUGIN_STACKLEAK
 	p->thread.lowest_stack.val = (unsigned long)end_of_stack(p) +
 						sizeof(unsigned long);
+# ifdef CONFIG_STACKLEAK_METRICS
+	p->thread.lowest_stack.prev_val = p->thread.lowest_stack.val;
+# endif
 #endif
 
 	if (unlikely(p->flags & PF_KTHREAD)) {
diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c
index f7412c6..a2d1af8 100644
--- a/arch/x86/kernel/process_64.c
+++ b/arch/x86/kernel/process_64.c
@@ -298,6 +298,9 @@  int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
 #ifdef CONFIG_GCC_PLUGIN_STACKLEAK
 	p->thread.lowest_stack.val = (unsigned long)end_of_stack(p) +
 						sizeof(unsigned long);
+# ifdef CONFIG_STACKLEAK_METRICS
+	p->thread.lowest_stack.prev_val = p->thread.lowest_stack.val;
+# endif
 #endif
 
 	savesegment(gs, p->thread.gsindex);
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 1b2ede6..a4d37a2 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2924,6 +2924,21 @@  static int proc_pid_patch_state(struct seq_file *m, struct pid_namespace *ns,
 }
 #endif /* CONFIG_LIVEPATCH */
 
+#ifdef CONFIG_STACKLEAK_METRICS
+static int proc_stack_depth(struct seq_file *m, struct pid_namespace *ns,
+				struct pid *pid, struct task_struct *task)
+{
+	unsigned long prev_depth = THREAD_SIZE -
+		(task->thread.lowest_stack.prev_val & (THREAD_SIZE - 1));
+	unsigned long depth = THREAD_SIZE -
+		(task->thread.lowest_stack.val & (THREAD_SIZE - 1));
+
+	seq_printf(m, "previous stack depth: %lu\nstack depth: %lu\n",
+							prev_depth, depth);
+	return 0;
+}
+#endif /* CONFIG_STACKLEAK_METRICS */
+
 /*
  * Thread groups
  */
@@ -3025,6 +3040,9 @@  static const struct pid_entry tgid_base_stuff[] = {
 #ifdef CONFIG_LIVEPATCH
 	ONE("patch_state",  S_IRUSR, proc_pid_patch_state),
 #endif
+#ifdef CONFIG_STACKLEAK_METRICS
+	ONE("stack_depth", S_IRUGO, proc_stack_depth),
+#endif
 };
 
 static int proc_tgid_base_readdir(struct file *file, struct dir_context *ctx)
diff --git a/include/linux/stackleak.h b/include/linux/stackleak.h
index 458c73b..73f18be 100644
--- a/include/linux/stackleak.h
+++ b/include/linux/stackleak.h
@@ -13,6 +13,9 @@ 
 struct lowest_stack {
 #ifdef CONFIG_GCC_PLUGIN_STACKLEAK
 	unsigned long		val;
+# ifdef CONFIG_STACKLEAK_METRICS
+	unsigned long		prev_val;
+# endif
 #endif
 };
 
diff --git a/kernel/stackleak.c b/kernel/stackleak.c
index 27565db..e49d694 100644
--- a/kernel/stackleak.c
+++ b/kernel/stackleak.c
@@ -50,6 +50,10 @@  asmlinkage void erase_kstack(void)
 	if (p == boundary)
 		p += sizeof(unsigned long);
 
+#ifdef CONFIG_STACKLEAK_METRICS
+	current->thread.lowest_stack.prev_val = p;
+#endif
+
 	/*
 	 * So let's write the poison value to the kernel stack.
 	 * Start from the address in p and move up till the new boundary.