xxx crash logging works

---
 hurd/paths.h  |   1 +
 trans/crash.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 117 insertions(+)

Index: hurd-debian/hurd/paths.h
===================================================================
--- hurd-debian.orig/hurd/paths.h
+++ hurd-debian/hurd/paths.h
@@ -61,6 +61,7 @@ the Free Software Foundation, 675 Mass A
 
 /* Symbolic names for all non-essential translators.  */
 #define _HURD_MAGIC	_HURD "magic"
+#define _HURD_CRASH	_HURD "crash"
 #define _HURD_MTAB	_HURD "mtab"
 
 #endif	/* hurd/paths.h */
Index: hurd-debian/trans/crash.c
===================================================================
--- hurd-debian.orig/trans/crash.c
+++ hurd-debian/trans/crash.c
@@ -25,6 +25,7 @@
 #include <fcntl.h>
 #include <hurd/trivfs.h>
 #include <hurd/msg.h>
+#include <hurd/paths.h>
 #include <sys/wait.h>
 #include <error.h>
 #include <argp.h>
@@ -243,6 +244,229 @@ stop_pgrp (process_t userproc, mach_port
     munmap (pids, numpids);
 }
 
+void mach_print(const char *);
+
+#ifndef EXTERNAL_MACH_PRINT
+asm (".global mach_print;"
+     " mach_print:;"
+#ifdef __x86_64__
+     " mov $0xffffffffffffffe2, %rax;"
+     " syscall;"
+#else
+     " mov $0xffffffe2, %eax;"
+     " lcall $0x7, $0x0;"
+#endif
+     " ret;");
+#endif /* EXTERNAL_MACH_PRINT */
+
+#include <mach/thread_status.h>
+
+static error_t
+get_pointer (task_t task, vm_offset_t va, vm_offset_t *value)
+{
+  error_t err;
+  vm_offset_t data;
+  mach_msg_type_number_t count;
+  vm_offset_t page = trunc_page (va);
+
+  if (va - page > vm_page_size - sizeof (vm_offset_t))
+    /* Spans two pages.  */
+    err = vm_read (task, page, vm_page_size * 2, &data, &count);
+  else
+    err = vm_read (task, page, vm_page_size, &data, &count);
+
+  if (err)
+    return err;
+
+  *value = *(vm_offset_t *) (data + (va - page));
+
+  vm_deallocate (mach_task_self (), data, count);
+
+  return 0;
+}
+
+static error_t
+get_pcs (task_t task, char **pcs)
+{
+  error_t err;
+  thread_t *threads;
+  mach_msg_type_number_t i, j, k, nthreads;
+  char **stacks;
+  char *cur;
+
+#ifdef i386_THREAD_STATE
+  struct i386_thread_state state;
+  mach_msg_type_number_t count = i386_THREAD_STATE_COUNT;
+  int flavor = i386_THREAD_STATE;
+  int len = 0;
+
+  err = task_threads (task, &threads, &nthreads);
+  if (err)
+    return err;
+
+  stacks = malloc (nthreads * sizeof *stacks);
+
+#define N 10
+#define STACK_MAX (8 << 20)
+  for (i = 0; i < nthreads; i++)
+    {
+      vm_offset_t stack[N], bp, sp, prev_bp, ra;
+      err = thread_get_state (threads[i], flavor,
+                             (thread_state_t) &state, &count);
+      if (err)
+	goto error;
+
+#ifdef __x86_64__
+      stack[0] = state.rip;
+      bp = state.rbp;
+      sp = state.ursp;
+#else
+      stack[0] = state.eip;
+      bp = state.ebp;
+      sp = state.uesp;
+#endif
+
+      /* Try to get backtrace in a trivial way.
+         Hopefully the application was built with -fno-omit-frame-pointer.  */
+      for (j = 1; j < N; j++)
+	{
+	  if (bp < sp || bp > sp + STACK_MAX)
+	    /* Bogus frame pointer.  */
+	    break;
+
+	  /* Get previous bp.  */
+	  err = get_pointer (task, bp, &prev_bp);
+	  if (err)
+	    /* Bogus frame pointer.  */
+	    break;
+
+	  /* Get return address.  */
+	  err = get_pointer (task, bp + sizeof (vm_offset_t), &ra);
+	  if (err)
+	    /* Bogus frame pointer.  */
+	    break;
+
+	  if (!ra)
+	    /* End of stack */
+	    break;
+
+	  stack[j] = ra;
+
+	  if (prev_bp == bp)
+	    {
+	      /* End of stack */
+	      j++;
+	      break;
+	    }
+
+	  bp = prev_bp;
+	}
+
+      cur = stacks[i] = malloc (j * (2 + sizeof (vm_offset_t) * 2 + 1));
+
+      for (k = 0; k < j; k++)
+	cur += sprintf (cur, "%s0x%lx", k ? " " : "", (unsigned long) stack[k]);
+
+      len += cur - stacks[i];
+    }
+
+  len += strlen(",\n") * (nthreads-1);
+  cur = *pcs = malloc(len);
+
+  for (i = 0; i < nthreads; i++)
+    {
+      if (i && !strcmp (stacks[i-1], stacks[i]))
+	 /* Avoid cluttering output with server threads */
+	 cur = stpncpy (cur, ", DUP", len - (cur - *pcs));
+      else
+        {
+          if (i)
+            cur = stpncpy (cur, ",\n", len - (cur - *pcs));
+          cur = stpncpy (cur, stacks[i], len - (cur - *pcs));
+        }
+    }
+
+  for (i = 0; i < nthreads; i++)
+    free (stacks[i]);
+#else
+  *pcs = strdup ("architecture not supported");
+#endif
+  return 0;
+
+error:
+  for (j = 0; j < i; j++)
+    free (stacks[j]);
+
+  for (i = 0; i < nthreads; i++)
+    {
+      err = mach_port_deallocate (mach_task_self (), threads[i]);
+      assert_perror_backtrace (err);
+    }
+
+  return err;
+}
+
+error_t
+log_crash (task_t task,
+          int signo, integer_t sigcode, int sigerror,
+          natural_t exc, natural_t code, natural_t subcode,
+          enum crash_action how)
+{
+  error_t err;
+  pid_t pid;
+  char argz_buf[128], *argz = argz_buf;
+  mach_msg_type_number_t argz_len = sizeof argz;
+  char *msg;
+  char *how_msg;
+  char *pcs;
+
+  switch (how)
+    {
+    case crash_suspend:
+      how_msg = "suspending task";
+      break;
+    case crash_kill:
+      how_msg = "killing task";
+      break;
+    case crash_corefile:
+      how_msg = "writing core file";
+      break;
+    default:
+      assert_backtrace (! "reached");
+    }
+
+  err = proc_task2pid (procserver, task, &pid);
+  if (err)
+    return err;
+
+  err = proc_getprocargs (procserver, pid, &argz, &argz_len);
+  if (err)
+    return err;
+
+  err = get_pcs (task, &pcs);
+  if (err)
+    return err;
+
+  argz_stringify (argz, argz_len, ' ');
+  asprintf (&msg, "%s: %s(%d) crashed, signal {no:%d, code:%d, error:%d}, "
+           "exception {%d, code:%d, subcode:%d}, PCs: {\n%s\n}, %s.\n",
+           _HURD_CRASH, argz, pid,
+           signo, sigcode, sigerror,
+           exc, code, subcode,
+           pcs,
+           how_msg);
+  if (argz != argz_buf)
+    vm_deallocate (mach_task_self (), (vm_address_t) argz, argz_len);
+  free (pcs);
+  if (! msg)
+    return ENOMEM;
+
+  fprintf (stderr, "%s", msg);
+  mach_print (msg);
+  free (msg);
+
+  return 0;
+}
 
 kern_return_t
 S_crash_dump_task (mach_port_t port,
@@ -276,6 +499,8 @@ S_crash_dump_task (mach_port_t port,
 	}
     }
 
+  log_crash (task, signo, sigcode, sigerror, exc, code, subcode, how);
+
   switch (how)
     {
     default:			/* NOTREACHED */