erts: Improve crash dumps

This commit improves crash dumps in several ways:
  *  Suspends schedulers to get a current snapshot
  *  Dumps information about scheduler
  *  Dumps stack trace of current running process
     (including Garbing processes)

1 files changed, 171 insertions, 3 deletions

diff --git a/erts/emulator/beam/erl_process_dump.c b/erts/emulator/beam/erl_process_dump.c
index 2f3cf23b00..36bb6b2f0e 100644
--- a/erts/emulator/beam/erl_process_dump.c
+++ b/erts/emulator/beam/erl_process_dump.c
@@ -43,8 +43,9 @@ static void dump_process_info(int to, void *to_arg, Process *p);
 static void dump_element(int to, void *to_arg, Eterm x);
 static void dump_dist_ext(int to, void *to_arg, ErtsDistExternal *edep);
 static void dump_element_nl(int to, void *to_arg, Eterm x);
-static int stack_element_dump(int to, void *to_arg, Process* p, Eterm* sp,
+static int stack_element_dump(int to, void *to_arg, Eterm* sp,
 			      int yreg);
+static void stack_trace_dump(int to, void *to_arg, Eterm* sp);
 static void print_function_from_pc(int to, void *to_arg, BeamInstr* x);
 static void heap_dump(int to, void *to_arg, Eterm x);
 static void dump_binaries(int to, void *to_arg, Binary* root);
@@ -148,7 +149,7 @@ dump_process_info(int to, void *to_arg, Process *p)
     if ((ERTS_TRACE_FLAGS(p) & F_SENSITIVE) == 0) {
 	erts_print(to, to_arg, "=proc_stack:%T\n", p->common.id);
 	for (sp = p->stop; sp < STACK_START(p); sp++) {
-	    yreg = stack_element_dump(to, to_arg, p, sp, yreg);
+	    yreg = stack_element_dump(to, to_arg, sp, yreg);
 	}
 
 	erts_print(to, to_arg, "=proc_heap:%T\n", p->common.id);
@@ -243,9 +244,65 @@ dump_element_nl(int to, void *to_arg, Eterm x)
     erts_putc(to, to_arg, '\n');
 }
 
+static void
+stack_trace_dump(int to, void *to_arg, Eterm *sp) {
+    Eterm x = *sp;
+    if (is_CP(x)) {
+        erts_print(to, to_arg, "%p:", sp);
+        erts_print(to, to_arg, "SReturn addr 0x%X (", cp_val(x));
+        print_function_from_pc(to, to_arg, cp_val(x));
+        erts_print(to, to_arg, ")\n");
+    }
+}
+
+void
+erts_limited_stack_trace(int to, void *to_arg, Process *p)
+{
+    Eterm* sp;
+
+
+    if (ERTS_TRACE_FLAGS(p) & F_SENSITIVE) {
+	return;
+    }
+
+    if (STACK_START(p) < STACK_TOP(p)) {
+        return;
+    }
+
+    if ((STACK_START(p) - STACK_TOP(p)) < 512) {
+        if (erts_sys_is_area_readable((char*)STACK_TOP(p),
+                                      (char*)STACK_START(p)))
+            for (sp = STACK_TOP(p); sp < STACK_START(p); sp++)
+                stack_trace_dump(to, to_arg, sp);
+        else
+            erts_print(to, to_arg, "Could not read from stack memory: %p - %p\n",
+                       STACK_TOP(p), STACK_START(p));
+    } else {
+        sp = STACK_TOP(p);
+        if (erts_sys_is_area_readable((char*)STACK_TOP(p),
+                                      (char*)(STACK_TOP(p) + 25)))
+            for (; sp < (STACK_TOP(p) + 256); sp++)
+                stack_trace_dump(to, to_arg, sp);
+        else
+            erts_print(to, to_arg, "Could not read from stack memory: %p - %p\n",
+                       STACK_TOP(p), STACK_TOP(p) + 256);
+
+        erts_print(to, to_arg, "%p: skipping %d frames\n",
+                   sp, STACK_START(p) - STACK_TOP(p) - 512);
+
+        if (erts_sys_is_area_readable((char*)(STACK_START(p) - 256),
+                                      (char*)STACK_START(p)))
+            for (sp = STACK_START(p) - 256; sp < STACK_START(p); sp++)
+                stack_trace_dump(to, to_arg, sp);
+        else
+            erts_print(to, to_arg, "Could not read from stack memory: %p - %p\n",
+                       STACK_START(p) - 256, STACK_START(p));
+    }
+
+}
 
 static int
-stack_element_dump(int to, void *to_arg, Process* p, Eterm* sp, int yreg)
+stack_element_dump(int to, void *to_arg, Eterm* sp, int yreg)
 {
     Eterm x = *sp;
 
@@ -508,3 +565,114 @@ dump_externally(int to, void *to_arg, Eterm term)
 	erts_print(to, to_arg, "%02X", *s++);
     }
 }
+
+void erts_dump_process_state(int to, void *to_arg, erts_aint32_t psflg) {
+    if (psflg & ERTS_PSFLG_FREE)
+	erts_print(to, to_arg, "Non Existing\n"); /* Should never happen */
+    else if (psflg & ERTS_PSFLG_EXITING)
+	erts_print(to, to_arg, "Exiting\n");
+    else if (psflg & ERTS_PSFLG_GC) {
+	erts_print(to, to_arg, "Garbing\n");
+    }
+    else if (psflg & ERTS_PSFLG_SUSPENDED)
+	erts_print(to, to_arg, "Suspended\n");
+    else if (psflg & ERTS_PSFLG_RUNNING) {
+	erts_print(to, to_arg, "Running\n");
+    }
+    else if (psflg & ERTS_PSFLG_ACTIVE)
+	erts_print(to, to_arg, "Scheduled\n");
+    else
+	erts_print(to, to_arg, "Waiting\n");
+}
+
+void
+erts_dump_extended_process_state(int to, void *to_arg, erts_aint32_t psflg) {
+
+    int i;
+
+    switch (ERTS_PSFLGS_GET_ACT_PRIO(psflg)) {
+    case PRIORITY_MAX: erts_print(to, to_arg, "ACT_PRIO_MAX | "); break;
+    case PRIORITY_HIGH: erts_print(to, to_arg, "ACT_PRIO_HIGH | "); break;
+    case PRIORITY_NORMAL: erts_print(to, to_arg, "ACT_PRIO_NORMAL | "); break;
+    case PRIORITY_LOW: erts_print(to, to_arg, "ACT_PRIO_LOW | "); break;
+    }
+    switch (ERTS_PSFLGS_GET_USR_PRIO(psflg)) {
+    case PRIORITY_MAX: erts_print(to, to_arg, "USR_PRIO_MAX | "); break;
+    case PRIORITY_HIGH: erts_print(to, to_arg, "USR_PRIO_HIGH | "); break;
+    case PRIORITY_NORMAL: erts_print(to, to_arg, "USR_PRIO_NORMAL | "); break;
+    case PRIORITY_LOW: erts_print(to, to_arg, "USR_PRIO_LOW | "); break;
+    }
+    switch (ERTS_PSFLGS_GET_PRQ_PRIO(psflg)) {
+    case PRIORITY_MAX: erts_print(to, to_arg, "PRQ_PRIO_MAX"); break;
+    case PRIORITY_HIGH: erts_print(to, to_arg, "PRQ_PRIO_HIGH"); break;
+    case PRIORITY_NORMAL: erts_print(to, to_arg, "PRQ_PRIO_NORMAL"); break;
+    case PRIORITY_LOW: erts_print(to, to_arg, "PRQ_PRIO_LOW"); break;
+    }
+
+    psflg &= ~(ERTS_PSFLGS_ACT_PRIO_MASK |
+               ERTS_PSFLGS_USR_PRIO_MASK |
+               ERTS_PSFLGS_PRQ_PRIO_MASK);
+
+    if (psflg)
+        erts_print(to, to_arg, " | ");
+
+    for (i = 0; i < ERTS_PSFLG_MAX && psflg; i++) {
+        erts_aint32_t chk = (1 << i);
+        if (psflg & chk) {
+            switch (chk) {
+            case ERTS_PSFLG_IN_PRQ_MAX:
+                erts_print(to, to_arg, "IN_PRQ_MAX"); break;
+            case ERTS_PSFLG_IN_PRQ_HIGH:
+                erts_print(to, to_arg, "IN_PRQ_HIGH"); break;
+            case ERTS_PSFLG_IN_PRQ_NORMAL:
+                erts_print(to, to_arg, "IN_PRQ_NORMAL"); break;
+            case ERTS_PSFLG_IN_PRQ_LOW:
+                erts_print(to, to_arg, "IN_PRQ_LOW"); break;
+            case ERTS_PSFLG_FREE:
+                erts_print(to, to_arg, "FREE"); break;
+            case ERTS_PSFLG_EXITING:
+                erts_print(to, to_arg, "EXITING"); break;
+            case ERTS_PSFLG_PENDING_EXIT:
+                erts_print(to, to_arg, "PENDING_EXIT"); break;
+            case ERTS_PSFLG_ACTIVE:
+                erts_print(to, to_arg, "ACTIVE"); break;
+            case ERTS_PSFLG_IN_RUNQ:
+                erts_print(to, to_arg, "IN_RUNQ"); break;
+            case ERTS_PSFLG_RUNNING:
+                erts_print(to, to_arg, "RUNNING"); break;
+            case ERTS_PSFLG_SUSPENDED:
+                erts_print(to, to_arg, "SUSPENDED"); break;
+            case ERTS_PSFLG_GC:
+                erts_print(to, to_arg, "GC"); break;
+            case ERTS_PSFLG_BOUND:
+                erts_print(to, to_arg, "BOUND"); break;
+            case ERTS_PSFLG_TRAP_EXIT:
+                erts_print(to, to_arg, "TRAP_EXIT"); break;
+            case ERTS_PSFLG_ACTIVE_SYS:
+                erts_print(to, to_arg, "ACTIVE_SYS"); break;
+            case ERTS_PSFLG_RUNNING_SYS:
+                erts_print(to, to_arg, "RUNNING_SYS"); break;
+            case ERTS_PSFLG_PROXY:
+                erts_print(to, to_arg, "PROXY"); break;
+            case ERTS_PSFLG_DELAYED_SYS:
+                erts_print(to, to_arg, "DELAYED_SYS"); break;
+#ifdef ERTS_DIRTY_SCHEDULERS
+            case ERTS_PSFLG_DIRTY_CPU_PROC:
+                erts_print(to, to_arg, "DIRTY_CPU_PROC"); break;
+            case ERTS_PSFLG_DIRTY_IO_PROC:
+                erts_print(to, to_arg, "DIRTY_IO_PROC"); break;
+            case ERTS_PSFLG_DIRTY_CPU_PROC_IN_Q:
+                erts_print(to, to_arg, "DIRTY_CPU_PROC_IN_Q"); break;
+            case ERTS_PSFLG_DIRTY_IO_PROC_IN_Q:
+                erts_print(to, to_arg, "DIRTY_IO_PROC_IN_Q"); break;
+#endif
+            default:
+                erts_print(to, to_arg, "UNKNOWN(%d)", chk); break;
+            }
+            if (psflg > chk)
+                erts_print(to, to_arg, " | ");
+            psflg -= chk;
+        }
+    }
+    erts_print(to, to_arg, "\n");
+}