From 17853e2316aed32d56343b2c4a73fa82b43a078d Mon Sep 17 00:00:00 2001
From: Martin Milata <mmilata@redhat.com>
Date: Mon, 21 Oct 2013 14:53:02 +0200
Subject: [SATYR PATCH 2/3] unwind: Port to current API of elfutils unwinder

Related to rhbz#1051569.

Signed-off-by: Martin Milata <mmilata@redhat.com>
---
 configure.ac               |   2 +-
 lib/core_unwind_elfutils.c | 164 +++++++++++++++++++++++++++++----------------
 lib/internal_unwind.h      |   2 +-
 3 files changed, 110 insertions(+), 58 deletions(-)

diff --git a/configure.ac b/configure.ac
index af6cb3f..cf3a193 100644
--- a/configure.ac
+++ b/configure.ac
@@ -104,7 +104,7 @@ AC_CHECK_LIB([elf], [main])
 AC_CHECK_LIB([dw], [main])
 AC_CHECK_LIB([dwfl], [main])
 AC_CHECK_LIB([dl], [main])
-AC_CHECK_FUNC(dwfl_frame_state_core, AC_DEFINE(HAVE_DWFL_FRAME_STATE_CORE, [], [Have function dwfl_frame_state_core for coredump unwinding]))
+AC_CHECK_FUNC(dwfl_getthreads, AC_DEFINE(HAVE_DWFL_NEXT_THREAD, [], [Have function dwfl_getthreads for coredump unwinding]))
 
 # libunwind
 AC_CHECK_HEADERS([libunwind-coredump.h])
diff --git a/lib/core_unwind_elfutils.c b/lib/core_unwind_elfutils.c
index 9a489ac..a8d8b3f 100644
--- a/lib/core_unwind_elfutils.c
+++ b/lib/core_unwind_elfutils.c
@@ -29,59 +29,108 @@
 #include <stdio.h>
 #include <string.h>
 
-static struct sr_core_thread *
-unwind_thread(Dwfl *dwfl, Dwfl_Frame_State *state, char **error_msg)
+struct frame_callback_arg
 {
-    struct sr_core_frame *head = NULL, *tail = NULL;
-    pid_t tid = 0;
+    struct sr_core_thread *thread;
+    char *error_msg;
+};
 
-    if (state)
+struct thread_callback_arg
+{
+    struct sr_core_stacktrace *stacktrace;
+    char *error_msg;
+};
+
+static int CB_STOP_UNWIND = DWARF_CB_ABORT+1;
+
+static int
+frame_callback(Dwfl_Frame *frame, void *data)
+{
+    struct frame_callback_arg *frame_arg = data;
+    char **error_msg = &frame_arg->error_msg;
+
+    Dwarf_Addr pc;
+    bool minus_one;
+    if (!dwfl_frame_pc(frame, &pc, &minus_one))
     {
-        tid = dwfl_frame_tid_get(state);
+        set_error_dwfl("dwfl_frame_pc");
+        return DWARF_CB_ABORT;
     }
 
-    while (state)
+    Dwfl *dwfl = dwfl_thread_dwfl(dwfl_frame_thread(frame));
+    struct sr_core_frame *result = resolve_frame(dwfl, pc, minus_one);
+
+    /* Do not unwind below __libc_start_main. */
+    if (0 == sr_strcmp0(result->function_name, "__libc_start_main"))
     {
-        Dwarf_Addr pc;
-        bool minus_one;
-        if (!dwfl_frame_state_pc(state, &pc, &minus_one))
-        {
-            warn("Failed to obtain PC: %s", dwfl_errmsg(-1));
-            break;
-        }
-
-        struct sr_core_frame *frame = resolve_frame(dwfl, pc, minus_one);
-        list_append(head, tail, frame);
-
-        /* Do not unwind below __libc_start_main. */
-        if (0 == sr_strcmp0(frame->function_name, "__libc_start_main"))
-            break;
-
-        if (!dwfl_frame_unwind(&state))
-        {
-            warn("Cannot unwind frame: %s", dwfl_errmsg(-1));
-            break;
-        }
+        sr_core_frame_free(result);
+        return CB_STOP_UNWIND;
     }
 
-    if (!error_msg && !head)
+    frame_arg->thread->frames =
+        sr_core_frame_append(frame_arg->thread->frames, result);
+
+    return DWARF_CB_OK;
+}
+
+static int
+unwind_thread(Dwfl_Thread *thread, void *data)
+{
+    struct thread_callback_arg *thread_arg = data;
+    char **error_msg = &thread_arg->error_msg;
+
+    struct sr_core_thread *result = sr_core_thread_new();
+    if (!result)
     {
-        set_error("No frames found for thread id %d", (int)tid);
+        set_error("Failed to initialize stacktrace memory");
+        return DWARF_CB_ABORT;
     }
+    result->id = (int64_t)dwfl_thread_tid(thread);
+
+    struct frame_callback_arg frame_arg =
+    {
+        .thread = result,
+        .error_msg = NULL
+    };
 
-    struct sr_core_thread *thread = sr_core_thread_new();
-    thread->id = (int64_t)tid;
-    thread->frames = head;
-    return thread;
+    int ret = dwfl_thread_getframes(thread, frame_callback, &frame_arg);
+    if (ret == -1)
+    {
+        warn("dwfl_thread_getframes failed for thread id %d: %s",
+             (int)result->id, dwfl_errmsg(-1));
+    }
+    else if (ret == DWARF_CB_ABORT)
+    {
+        *error_msg = frame_arg.error_msg;
+        goto abort;
+    }
+    else if (ret != 0 && ret != CB_STOP_UNWIND)
+    {
+        *error_msg = sr_strdup("Unknown error in dwfl_thread_getframes");
+        goto abort;
+    }
+
+    if (!error_msg && !frame_arg.thread->frames)
+    {
+        set_error("No frames found for thread id %d", (int)result->id);
+        goto abort;
+    }
+
+    thread_arg->stacktrace->threads =
+        sr_core_thread_append(thread_arg->stacktrace->threads, result);
+    return DWARF_CB_OK;
+
+abort:
+    sr_core_thread_free(result);
+    return DWARF_CB_ABORT;
 }
 
 struct sr_core_stacktrace *
 sr_parse_coredump(const char *core_file,
-                   const char *exe_file,
-                   char **error_msg)
+                  const char *exe_file,
+                  char **error_msg)
 {
     struct sr_core_stacktrace *stacktrace = NULL;
-    short signal = 0;
 
     /* Initialize error_msg to 'no error'. */
     if (error_msg)
@@ -91,11 +140,9 @@ sr_parse_coredump(const char *core_file,
     if (*error_msg)
         return NULL;
 
-    Dwfl_Frame_State *state = dwfl_frame_state_core(ch->dwfl, core_file);
-    if (!state)
+    if (dwfl_core_file_attach(ch->dwfl, ch->eh) < 0)
     {
-        set_error("Failed to initialize frame state from core '%s'",
-                   core_file);
+        set_error_dwfl("dwfl_core_file_attach");
         goto fail_destroy_handle;
     }
 
@@ -105,20 +152,30 @@ sr_parse_coredump(const char *core_file,
         set_error("Failed to initialize stacktrace memory");
         goto fail_destroy_handle;
     }
-    struct sr_core_thread *threads_tail = NULL;
 
-    do
+    struct thread_callback_arg thread_arg =
     {
-        struct sr_core_thread *t = unwind_thread(ch->dwfl, state, error_msg);
-        if (*error_msg)
-        {
-            goto fail_destroy_trace;
-        }
-        list_append(stacktrace->threads, threads_tail, t);
-        state = dwfl_frame_thread_next(state);
-    } while (state);
+        .stacktrace = stacktrace,
+        .error_msg = NULL
+    };
 
-    signal = get_signal_number(ch->eh, core_file);
+    int ret = dwfl_getthreads(ch->dwfl, unwind_thread, &thread_arg);
+    if (ret != 0)
+    {
+        if (ret == -1)
+            set_error_dwfl("dwfl_getthreads");
+        else if (ret == DWARF_CB_ABORT)
+            *error_msg = thread_arg.error_msg;
+        else
+            *error_msg = sr_strdup("Unknown error in dwfl_getthreads");
+
+        goto fail_destroy_trace;
+    }
+
+    stacktrace->executable = sr_strdup(exe_file);
+    stacktrace->signal = get_signal_number(ch->eh, core_file);
+    /* FIXME: is this the best we can do? */
+    stacktrace->crash_thread = stacktrace->threads;
 
 fail_destroy_trace:
     if (*error_msg)
@@ -128,11 +185,6 @@ fail_destroy_trace:
     }
 fail_destroy_handle:
     core_handle_free(ch);
-
-    stacktrace->executable = sr_strdup(exe_file);
-    stacktrace->signal = signal;
-    /* FIXME: is this the best we can do? */
-    stacktrace->crash_thread = stacktrace->threads;
     return stacktrace;
 }
 
diff --git a/lib/internal_unwind.h b/lib/internal_unwind.h
index d537f86..2c9abb7 100644
--- a/lib/internal_unwind.h
+++ b/lib/internal_unwind.h
@@ -27,7 +27,7 @@
 #include "config.h"
 
 /* define macros indicating what unwinder are we using */
-#if (defined HAVE_LIBELF_H && defined HAVE_GELF_H && defined HAVE_LIBELF && defined HAVE_LIBDW && defined HAVE_ELFUTILS_LIBDWFL_H && defined HAVE_DWFL_FRAME_STATE_CORE)
+#if (defined HAVE_LIBELF_H && defined HAVE_GELF_H && defined HAVE_LIBELF && defined HAVE_LIBDW && defined HAVE_ELFUTILS_LIBDWFL_H && defined HAVE_DWFL_NEXT_THREAD)
 #  define WITH_LIBDWFL
 #endif
 
-- 
1.8.3.1