From 91cdbeb45d11cfd1dd62afe50f80a7c5d4342f5b Mon Sep 17 00:00:00 2001
From: Martin Milata <mmilata@redhat.com>
Date: Mon, 24 Nov 2014 14:36:14 +0100
Subject: [SATYR PATCH] unwind: support unwinding from core hook
In-memory unwinding of dying processes, related to abrt/abrt#gh829. The
implementation mostly mirrors code in src/stack.c of elfutils repo
(jankratochvil/corepattern branch).
Related to abrt/abrt#829.
Signed-off-by: Martin Milata <mmilata@redhat.com>
---
include/abrt.h | 8 +++
include/core/unwind.h | 18 ++++++
lib/abrt.c | 35 ++++++++++++
lib/core_unwind.c | 14 +++++
lib/core_unwind_elfutils.c | 136 +++++++++++++++++++++++++++++++++++++++++++++
5 files changed, 211 insertions(+)
diff --git a/include/abrt.h b/include/abrt.h
index 0a8f5ac..5116446 100644
--- a/include/abrt.h
+++ b/include/abrt.h
@@ -26,6 +26,7 @@ extern "C" {
#include "report_type.h"
#include <stdbool.h>
+#include <sys/types.h>
bool
sr_abrt_print_report_from_dir(const char *directory,
@@ -43,6 +44,13 @@ sr_abrt_create_core_stacktrace_from_gdb(const char *directory,
bool hash_fingerprints,
char **error_message);
+bool
+sr_abrt_create_core_stacktrace_from_core_hook(const char *directory,
+ pid_t thread_id,
+ const char *executable,
+ int signum,
+ char **error_message);
+
struct sr_rpm_package *
sr_abrt_parse_dso_list(const char *text);
diff --git a/include/core/unwind.h b/include/core/unwind.h
index 8ab9d52..b128c76 100644
--- a/include/core/unwind.h
+++ b/include/core/unwind.h
@@ -24,6 +24,8 @@
extern "C" {
#endif
+#include <sys/types.h>
+
struct sr_core_stacktrace;
struct sr_gdb_stacktrace;
@@ -38,6 +40,22 @@ sr_core_stacktrace_from_gdb(const char *gdb_output,
const char *executable_filename,
char **error_message);
+/* This function can be used to unwind stack of live ("dying") process, invoked
+ * from the core dump hook (/proc/sys/kernel/core_pattern).
+ *
+ * Beware:
+ *
+ * - It can only unwind one thread of the process, the thread that caused the
+ * terminating signal to be sent. You must supply that thread's tid.
+ * - The function calls close() on stdin, meaning that in the core handler you
+ * cannot access the core image after calling this function.
+ */
+struct sr_core_stacktrace *
+sr_core_stacktrace_from_core_hook(pid_t thread_id,
+ const char *executable_filename,
+ int signum,
+ char **error_message);
+
#ifdef __cplusplus
}
#endif
diff --git a/lib/abrt.c b/lib/abrt.c
index 39bc45d..585fdfb 100644
--- a/lib/abrt.c
+++ b/lib/abrt.c
@@ -138,6 +138,41 @@ sr_abrt_create_core_stacktrace(const char *directory,
error_message);
}
+bool
+sr_abrt_create_core_stacktrace_from_core_hook(const char *directory,
+ pid_t thread_id,
+ const char *executable,
+ int signum,
+ char **error_message)
+{
+
+ struct sr_core_stacktrace *core_stacktrace;
+ core_stacktrace = sr_core_stacktrace_from_core_hook(thread_id, executable,
+ signum, error_message);
+
+ if (!core_stacktrace)
+ return false;
+
+ fulfill_missing_values(core_stacktrace);
+
+ char *json = sr_core_stacktrace_to_json(core_stacktrace);
+
+ // Add newline to the end of core stacktrace file to make text
+ // editors happy.
+ json = sr_realloc(json, strlen(json) + 2);
+ strcat(json, "\n");
+
+ char *core_backtrace_filename = sr_build_path(directory, "core_backtrace", NULL);
+ bool success = sr_string_to_file(core_backtrace_filename,
+ json,
+ error_message);
+
+ free(core_backtrace_filename);
+ free(json);
+ sr_core_stacktrace_free(core_stacktrace);
+ return success;
+}
+
struct sr_rpm_package *
sr_abrt_parse_dso_list(const char *text)
{
diff --git a/lib/core_unwind.c b/lib/core_unwind.c
index 8b7cc22..7ea66da 100644
--- a/lib/core_unwind.c
+++ b/lib/core_unwind.c
@@ -52,6 +52,20 @@ sr_parse_coredump(const char *coredump_filename,
#endif /* !defined WITH_LIBDWFL && !defined WITH_LIBUNWIND */
+#if !defined WITH_LIBDWFL
+
+struct sr_core_stacktrace *
+sr_core_stacktrace_from_core_hook(pid_t thread_id,
+ const char *executable_filename,
+ int signum,
+ char **error_message);
+{
+ *error_message = sr_asprintf("satyr is built without live process unwind support");
+ return NULL;
+}
+
+#endif /* !defined WITH_LIBDWFL */
+
/* FIXME: is there another way to pass the executable name to the find_elf
* callback? */
const char *executable_file = NULL;
diff --git a/lib/core_unwind_elfutils.c b/lib/core_unwind_elfutils.c
index bbd4813..bea9b5f 100644
--- a/lib/core_unwind_elfutils.c
+++ b/lib/core_unwind_elfutils.c
@@ -28,6 +28,10 @@
#include <stdio.h>
#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/ptrace.h>
+#include <sys/wait.h>
#define FRAME_LIMIT 256
@@ -202,4 +206,136 @@ fail:
return stacktrace;
}
+struct sr_core_stacktrace *
+sr_core_stacktrace_from_core_hook(pid_t tid,
+ const char *executable,
+ int signum,
+ char **error_msg)
+{
+ struct sr_core_stacktrace *stacktrace = NULL;
+
+ /* Initialize error_msg to 'no error'. */
+ if (error_msg)
+ *error_msg = NULL;
+
+ const Dwfl_Callbacks proc_cb =
+ {
+ .find_elf = dwfl_linux_proc_find_elf,
+ .find_debuginfo = find_debuginfo_none,
+ };
+
+ Dwfl *dwfl = dwfl_begin(&proc_cb);
+
+ if (dwfl_linux_proc_report(dwfl, tid) != 0)
+ {
+ set_error_dwfl("dwfl_linux_proc_report");
+ goto fail;
+ }
+
+ if (dwfl_report_end(dwfl, NULL, NULL) != 0)
+ {
+ set_error_dwfl("dwfl_report_end");
+ goto fail;
+ }
+
+ if (ptrace(PTRACE_SEIZE, tid, NULL, (void *)(uintptr_t)PTRACE_O_TRACEEXIT) != 0)
+ {
+ set_error("PTRACE_SEIZE (tid %u) failed: %s", (unsigned)tid, strerror(errno));
+ goto fail;
+ }
+
+ if (close(STDIN_FILENO) != 0)
+ {
+ set_error("Failed to close stdin: %s", strerror(errno));
+ goto fail;
+ }
+
+ int status;
+ pid_t got = waitpid(tid, &status, 0);
+ if (got == -1)
+ {
+ set_error("waitpid failed: %s", strerror(errno));
+ goto fail;
+ }
+
+ if (got != tid)
+ {
+ set_error("waitpid returned %u but %u was expected", (unsigned)got, (unsigned)tid);
+ goto fail;
+ }
+
+ if (!WIFSTOPPED(status))
+ {
+ set_error("waitpid returned 0x%x but WIFSTOPPED was expected", status);
+ goto fail;
+ }
+
+ if ((status >> 8) != (SIGTRAP | (PTRACE_EVENT_EXIT << 8)))
+ {
+ set_error("waitpid returned 0x%x but (status >> 8) == "
+ "(SIGTRAP | (PTRACE_EVENT_EXIT << 8)) was expected", status);
+ goto fail;
+ }
+
+ if (dwfl_linux_proc_attach(dwfl, tid, true) != 0)
+ {
+ set_error_dwfl("dwfl_linux_proc_attach");
+ goto fail;
+ }
+
+ stacktrace = sr_core_stacktrace_new();
+ if (!stacktrace)
+ {
+ set_error("Failed to initialize stacktrace memory");
+ goto fail;
+ }
+
+ stacktrace->threads = sr_core_thread_new();
+ if (!stacktrace->threads)
+ {
+ set_error("Failed to initialize thread memory");
+ sr_core_stacktrace_free(stacktrace);
+ stacktrace = 0;
+ goto fail;
+ }
+ stacktrace->threads->id = tid;
+
+ struct frame_callback_arg frame_arg =
+ {
+ .frames_tail = &(stacktrace->threads->frames),
+ .error_msg = NULL,
+ .nframes = 0
+ };
+
+ int ret = dwfl_getthread_frames(dwfl, tid, frame_callback, &frame_arg);
+ if (ret != 0 && ret != CB_STOP_UNWIND)
+ {
+ if (ret == -1)
+ set_error_dwfl("dwfl_getthread_frames");
+ else if (ret == DWARF_CB_ABORT)
+ {
+ set_error("%s", frame_arg.error_msg);
+ free(frame_arg.error_msg);
+ }
+ else
+ set_error("Unknown error in dwfl_getthreads");
+
+ sr_core_stacktrace_free(stacktrace);
+ stacktrace = NULL;
+ goto fail;
+ }
+
+ truncate_long_thread(stacktrace->threads, &frame_arg);
+
+ if (executable)
+ stacktrace->executable = sr_strdup(executable);
+ if (signum > 0)
+ stacktrace->signal = (uint16_t)signum;
+ stacktrace->crash_thread = stacktrace->threads;
+
+fail:
+ dwfl_end(dwfl);
+ return stacktrace;
+}
+
#endif /* WITH_LIBDWFL */
--
2.4.3