issue 223 - Fixes for SOlaris handler during integration with Firefox. patch by Alfred Peng, r=mento,me

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@250 4c0a9323-5329-0410-9bdc-e9ce6186880e

src/client/solaris/handler/exception_handler.cc

@@ -42,12 +42,9 @@
 #include "common/solaris/guid_creator.h"
 #include "common/solaris/message_output.h"
 #include "google_breakpad/common/minidump_format.h"
-#include "processor/scoped_ptr.h"
 
 namespace google_breakpad {
 
-static const int kStackSize = 1024 * 1024;
-
 // Signals that we are interested.
 static const int kSigTable[] = {
   SIGSEGV,
@@ -68,10 +65,9 @@ ExceptionHandler::ExceptionHandler(const string &dump_path,
                                    void *callback_context,
                                    bool install_handler)
     : filter_(filter),
-      handler_thread_(0),
-      handler_return_value_(false),
       callback_(callback),
       callback_context_(callback_context),
+      dump_path_(),
       installed_handler_(install_handler) {
   set_dump_path(dump_path);
 
@@ -79,19 +75,6 @@ ExceptionHandler::ExceptionHandler(const string &dump_path,
     SetupHandler();
   }
 
-  sem_init(&handler_start_semaphore_, 0, 0);
-  sem_init(&handler_finish_semaphore_, 0, 0);
-  pthread_attr_t attr;
-  scoped_array<char> thread_stack;
-
-  pthread_attr_init(&attr);
-  thread_stack.reset(new char[kStackSize]);
-  pthread_attr_setstackaddr(&attr, thread_stack.get());
-  pthread_attr_setstacksize(&attr, kStackSize);
-  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-  pthread_create(&handler_thread_, &attr, ExceptionHandlerThreadMain, this);
-  pthread_attr_destroy(&attr);
-
   if (install_handler) {
     pthread_mutex_lock(&handler_stack_mutex_);
 
@@ -125,34 +108,11 @@ ExceptionHandler::~ExceptionHandler() {
     delete handler_stack_;
     handler_stack_ = NULL;
   }
-  pthread_exit((void *)handler_thread_);
-  sem_destroy(&handler_start_semaphore_);
-  sem_destroy(&handler_finish_semaphore_);
   pthread_mutex_unlock(&handler_stack_mutex_);
 }
 
-// static
-void* ExceptionHandler::ExceptionHandlerThreadMain(void *lpParameter) {
-  ExceptionHandler *self = reinterpret_cast<ExceptionHandler *>(lpParameter);
-  assert(self);
-
-  while (true) {
-    if (!sem_wait(&(self->handler_start_semaphore_))) {
-      // Perform the requested action.
-      self->handler_return_value_ = self->InternalWriteMinidump();
-
-      // Allow the requesting thread to proceed.
-      sem_post(&(self->handler_finish_semaphore_));
-    }
-  }
-
-  // Not reached.  This thread will be terminated by ExceptionHandler's
-  // destructor.
-  return 0;
-}
-
 bool ExceptionHandler::WriteMinidump() {
-  return WriteMinidumpOnHandlerThread(0);
+  return InternalWriteMinidump(0, 0, NULL);
 }
 
 // static
@@ -161,7 +121,7 @@ bool ExceptionHandler::WriteMinidump(const string &dump_path,
                                      void *callback_context) {
   ExceptionHandler handler(dump_path, NULL, callback,
                            callback_context, false);
-  return handler.WriteMinidumpOnHandlerThread(0);
+  return handler.InternalWriteMinidump(0, 0, NULL);
 }
 
 void ExceptionHandler::SetupHandler() {
@@ -204,22 +164,22 @@ void ExceptionHandler::TeardownAllHandlers() {
   }
 }
 
-bool ExceptionHandler::WriteMinidumpOnHandlerThread(int signo) {
-  // Set up data to be passed in to the handler thread.
-  signo_ = signo;
-
-  // This causes the handler thread to call InternalWriteMinidump.
-  sem_post(&handler_start_semaphore_);
-
-  // Wait until InternalWriteMinidump is done and collect its return value.
-  sem_wait(&handler_finish_semaphore_);
-  bool status = handler_return_value_;
-
-  return status;
-}
-
 // static
 void ExceptionHandler::HandleException(int signo) {
+//void ExceptionHandler::HandleException(int signo, siginfo_t *sip, ucontext_t *sig_ctx) {
+  // The context information about the signal is put on the stack of
+  // the signal handler frame as value parameter. For some reasons, the
+  // prototype of the handler doesn't declare this information as parameter, we
+  // will do it by hand. The stack layout for a signal handler frame is here:
+  // http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/lib/libproc/common/Pstack.c#81
+  //
+  // However, if we are being called by another signal handler passing the
+  // signal up the chain, then we may not have this random extra parameter,
+  // so we may have to walk the stack to find it.  We do the actual work
+  // on another thread, where it's a little safer, but we want the ebp
+  // from this frame to find it.
+  uintptr_t current_ebp = (uintptr_t)_getfp();
+
   pthread_mutex_lock(&handler_stack_mutex_);
   ExceptionHandler *current_handler =
     handler_stack_->at(handler_stack_->size() - ++handler_stack_index_);
@@ -227,7 +187,10 @@ void ExceptionHandler::HandleException(int signo) {
 
   // Restore original handler.
   current_handler->TeardownHandler(signo);
-  if (current_handler->WriteMinidumpOnHandlerThread(signo)) {
+
+  ucontext_t *sig_ctx = NULL;
+  if (current_handler->InternalWriteMinidump(signo, current_ebp, &sig_ctx)) {
+//  if (current_handler->InternalWriteMinidump(signo, &sig_ctx)) {
     // Fully handled this exception, safe to exit.
     exit(EXIT_FAILURE);
   } else {
@@ -253,7 +216,9 @@ void ExceptionHandler::HandleException(int signo) {
   pthread_mutex_unlock(&handler_stack_mutex_);
 }
 
-bool ExceptionHandler::InternalWriteMinidump() {
+bool ExceptionHandler::InternalWriteMinidump(int signo,
+                                             uintptr_t sighandler_ebp,
+                                             ucontext_t **sig_ctx) {
   if (filter_ && !filter_(callback_context_))
     return false;
 
@@ -277,7 +242,8 @@ bool ExceptionHandler::InternalWriteMinidump() {
       print_message1(2, "HandleException: failed to block signals.\n");
     }
 
-    success = minidump_generator_.WriteMinidumpToFile(minidump_path, signo_);
+    success = minidump_generator_.WriteMinidumpToFile(
+                       minidump_path, signo, sighandler_ebp, sig_ctx);
 
     // Unblock the signals.
     if (blocked)

src/client/solaris/handler/exception_handler.h

@@ -32,9 +32,6 @@
 #ifndef CLIENT_SOLARIS_HANDLER_EXCEPTION_HANDLER_H__
 #define CLIENT_SOLARIS_HANDLER_EXCEPTION_HANDLER_H__
 
-#include <pthread.h>
-#include <semaphore.h>
-
 #include <map>
 #include <string>
 #include <vector>
@@ -119,9 +116,11 @@ class ExceptionHandler {
                    bool install_handler);
   ~ExceptionHandler();
 
-  // Set the minidump path.
+  // Get and Set the minidump path.
+  string dump_path() const { return dump_path_; }
   void set_dump_path(const string &dump_path) {
-    dump_path_c_ = dump_path.c_str();
+    dump_path_ = dump_path;
+    dump_path_c_ = dump_path_.c_str();
   }
 
   // Writes a minidump immediately.  This can be used to capture the
@@ -150,36 +149,25 @@ class ExceptionHandler {
   // Signal handler.
   static void HandleException(int signo);
 
-  // Trigger the call to InternalWriteMinidump and wait for the return value.
-  bool WriteMinidumpOnHandlerThread(int signo);
-
   // Write all the information to the dump file.
-  bool InternalWriteMinidump();
+  // If called from a signal handler, sighandler_ebp is the ebp of
+  // that signal handler's frame, and sig_ctx is an out parameter
+  // that will be set to point at the ucontext_t that was placed
+  // on the stack by the kernel.  You can pass zero and NULL
+  // for the second and third parameters if you are not calling
+  // this from a signal handler.
+  bool InternalWriteMinidump(int signo, uintptr_t sighandler_ebp,
+                             ucontext_t **sig_ctx);
 
  private:
-  // Signal number when crash happed. Can be 0 if this is a requested dump.
-  int signo_;
-
-  // The exception handler thread.
-  pthread_t handler_thread_;
-
-  // Semaphores used to move exception handling between the exception thread
-  // and the handler thread.  handler_start_semaphore_ is signalled by the
-  // exception thread to wake up the handler thread when an exception occurs.
-  // handler_finish_semaphore_ is signalled by the handler thread to wake up
-  // the exception thread when handling is complete.
-  sem_t handler_start_semaphore_;
-  sem_t handler_finish_semaphore_;
-
-  // The return value of the handler, passed from the handler thread back to
-  // the requesting thread.
-  bool handler_return_value_;
-
   // The callbacks before and after writing the dump file.
   FilterCallback filter_;
   MinidumpCallback callback_;
   void *callback_context_;
 
+  // The directory in which a minidump will be written, set by the dump_path
+  // argument to the constructor, or set_dump_path.
+  string dump_path_;
   // C style dump path. Keep this when setting dump path, since calling
   // c_str() of std::string when crashing may not be safe.
   const char *dump_path_c_;

src/client/solaris/handler/minidump_generator.cc

@@ -30,12 +30,11 @@
 // Author: Alfred Peng
 
 #include <fcntl.h>
-#include <pthread.h>
+#include <sys/frame.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/utsname.h>
 #include <sys/wait.h>
-#include <ucontext.h>
 #include <unistd.h>
 
 #include <cstdlib>
@@ -45,21 +44,98 @@
 #include "client/minidump_file_writer-inl.h"
 #include "common/solaris/file_id.h"
 
-namespace google_breakpad {
+namespace {
 
-MinidumpGenerator::MinidumpGenerator()
+using namespace google_breakpad;
-    : requester_pid_(0),
+
-      signo_(0),
+// Argument for the writer function.
-      lwp_lister_(NULL) {
+struct WriterArgument {
+  MinidumpFileWriter *minidump_writer;
+
+  // Pid of the lwp who called WriteMinidumpToFile
+  int requester_pid;
+
+  // The stack bottom of the lwp which caused the dump.
+  // Mainly used to find the lwp id of the crashed lwp since signal
+  // handler may not be called in the lwp who caused it.
+  uintptr_t crashed_stack_bottom;
+
+  // Id of the crashing lwp.
+  int crashed_lwpid;
+
+  // Signal number when crash happened. Can be 0 if this is a requested dump.
+  int signo;
+
+  // The ebp of the signal handler frame on x86.  Can be 0 if this is a
+  // requested dump.
+  uintptr_t sighandler_ebp;
+
+  // User context when crash happens. Can be NULL if this is a requested dump.
+  // This is actually an out parameter, but it will be filled in at the start
+  // of the writer LWP.
+  ucontext_t *sig_ctx;
+
+  // Used to get information about the lwps.
+  SolarisLwp *lwp_lister;
+};
+
+// Holding context information for the callback of finding the crashing lwp.
+struct FindCrashLwpContext {
+  const SolarisLwp *lwp_lister;
+  uintptr_t crashing_stack_bottom;
+  int crashing_lwpid;
+
+  FindCrashLwpContext() :
+    lwp_lister(NULL),
+    crashing_stack_bottom(0UL),
+    crashing_lwpid(-1) {
+  }
+};
+
+// Callback for list lwps.
+// It will compare the stack bottom of the provided lwp with the stack
+// bottom of the crashed lwp, it they are eqaul, this lwp is the one
+// who crashed.
+bool IsLwpCrashedCallback(lwpstatus_t *lsp, void *context) {
+  FindCrashLwpContext *crashing_context =
+    static_cast<FindCrashLwpContext *>(context);
+  const SolarisLwp *lwp_lister = crashing_context->lwp_lister;
+  const prgregset_t *gregs = &(lsp->pr_reg);
+#if TARGET_CPU_SPARC
+  uintptr_t last_ebp = (*gregs)[R_FP];
+#elif TARGET_CPU_X86
+  uintptr_t last_ebp = (*gregs)[EBP];
+#endif
+  uintptr_t stack_bottom = lwp_lister->GetLwpStackBottom(last_ebp);
+  if (stack_bottom > last_ebp &&
+      stack_bottom == crashing_context->crashing_stack_bottom) {
+    // Got it. Stop iteration.
+    crashing_context->crashing_lwpid = lsp->pr_lwpid;
+    return false;
+  }
+
+  return true;
 }
 
-MinidumpGenerator::~MinidumpGenerator() {
+// Find the crashing lwpid.
+// This is done based on stack bottom comparing.
+int FindCrashingLwp(uintptr_t crashing_stack_bottom,
+                    int requester_pid,
+                    const SolarisLwp *lwp_lister) {
+  FindCrashLwpContext context;
+  context.lwp_lister = lwp_lister;
+  context.crashing_stack_bottom = crashing_stack_bottom;
+  CallbackParam<LwpCallback> callback_param(IsLwpCrashedCallback,
+                                            &context);
+  lwp_lister->Lwp_iter_all(lwp_lister->getpid(), &callback_param);
+  return context.crashing_lwpid;
 }
 
-bool MinidumpGenerator::WriteLwpStack(uintptr_t last_esp,
+bool WriteLwpStack(const SolarisLwp *lwp_lister,
-                                      UntypedMDRVA *memory,
+                   uintptr_t last_esp,
-                                      MDMemoryDescriptor *loc) {
+                   UntypedMDRVA *memory,
-  uintptr_t stack_bottom = lwp_lister_->GetLwpStackBottom(last_esp);
+                   MDMemoryDescriptor *loc) {
+  uintptr_t stack_bottom = lwp_lister->GetLwpStackBottom(last_esp);
   if (stack_bottom >= last_esp) {
     int size = stack_bottom - last_esp;
     if (size > 0) {
@@ -75,29 +151,52 @@ bool MinidumpGenerator::WriteLwpStack(uintptr_t last_esp,
 }
 
 #if TARGET_CPU_SPARC
-bool MinidumpGenerator::WriteContext(MDRawContextSPARC *context, prgregset_t regs,
+bool WriteContext(MDRawContextSPARC *context, ucontext_t *sig_ctx) {
-                                     prfpregset_t *fp_regs) {
+  assert(sig_ctx != NULL);
+  int* regs = sig_ctx->uc_mcontext.gregs;
+  context->context_flags = MD_CONTEXT_SPARC_FULL;
+
+  context->ccr = (unsigned int)(regs[0]);
+  context->pc = (unsigned int)(regs[REG_PC]);
+  context->npc = (unsigned int)(regs[REG_nPC]);
+  context->y = (unsigned int)(regs[REG_Y]);
+  context->asi = (unsigned int)(regs[19]);
+  context->fprs = (unsigned int)(regs[20]);
+
+  for ( int i = 0 ; i < 32; ++i ) {
+    context->g_r[i] = 0;
+  }
+
+  for ( int i = 1 ; i < 16; ++i ) {
+    context->g_r[i] = (uintptr_t)(sig_ctx->uc_mcontext.gregs[i + 3]);
+  }
+  context->g_r[30] = (uintptr_t)(((struct frame *)context->g_r[14])->fr_savfp);
+
+  return true;
+}
+
+bool WriteContext(MDRawContextSPARC *context, prgregset_t regs,
+                  prfpregset_t *fp_regs) {
   if (!context || !regs)
     return false;
 
   context->context_flags = MD_CONTEXT_SPARC_FULL;
 
-  context->ccr = (unsigned int)(regs[32]);
+  context->ccr = (uintptr_t)(regs[32]);
-  context->pc = (unsigned int)(regs[R_PC]);
+  context->pc = (uintptr_t)(regs[R_PC]);
-  context->npc = (unsigned int)(regs[R_nPC]);
+  context->npc = (uintptr_t)(regs[R_nPC]);
-  context->y = (unsigned int)(regs[R_Y]);
+  context->y = (uintptr_t)(regs[R_Y]);
-  context->asi = (unsigned int)(regs[36]);
+  context->asi = (uintptr_t)(regs[36]);
-  context->fprs = (unsigned int)(regs[37]);
+  context->fprs = (uintptr_t)(regs[37]);
-
   for ( int i = 0 ; i < 32 ; ++i ){
-    context->g_r[i] = (unsigned int)(regs[i]);
+    context->g_r[i] = (uintptr_t)(regs[i]);
   }
 
   return true;
 }
 #elif TARGET_CPU_X86
-bool MinidumpGenerator::WriteContext(MDRawContextX86 *context, prgregset_t regs,
+bool WriteContext(MDRawContextX86 *context, prgregset_t regs,
-                                     prfpregset_t *fp_regs) {
+                  prfpregset_t *fp_regs) {
   if (!context || !regs)
     return false;
 
@@ -124,18 +223,67 @@ bool MinidumpGenerator::WriteContext(MDRawContextX86 *context, prgregset_t regs,
 }
 #endif /* TARGET_CPU_XXX */
 
-bool MinidumpGenerator::WriteLwpStream(lwpstatus_t *lsp, MDRawThread *lwp) {
+// Write information about a crashed Lwp.
-  prfpregset_t fp_regs = lsp->pr_fpreg;
+// When a lwp crash, kernel will write something on the stack for processing
-  prgregset_t *gregs = &(lsp->pr_reg);
+// signal. This makes the current stack not reliable, and our stack walker
-  UntypedMDRVA memory(&writer_);
+// won't figure out the whole call stack for this. So we write the stack at the
+// time of the crash into the minidump file, not the current stack.
+bool WriteCrashedLwpStream(MinidumpFileWriter *minidump_writer,
+                           const WriterArgument *writer_args,
+                           const lwpstatus_t *lsp,
+                           MDRawThread *lwp) {
+  assert(writer_args->sig_ctx != NULL);
+
+  lwp->thread_id = lsp->pr_lwpid;
+
 #if TARGET_CPU_SPARC
-  if (!WriteLwpStack((*gregs)[R_SP],
+  UntypedMDRVA memory(minidump_writer);
+  if (!WriteLwpStack(writer_args->lwp_lister,
+                     writer_args->sig_ctx->uc_mcontext.gregs[REG_O6],
+                     &memory,
+                     &lwp->stack))
+    return false;
+
+  TypedMDRVA<MDRawContextSPARC> context(minidump_writer);
+  if (!context.Allocate())
+    return false;
+  lwp->thread_context = context.location();
+  memset(context.get(), 0, sizeof(MDRawContextSPARC));
+  return WriteContext(context.get(), writer_args->sig_ctx);
+#elif TARGET_CPU_X86
+  UntypedMDRVA memory(minidump_writer);
+  if (!WriteLwpStack(writer_args->lwp_lister,
+                     writer_args->sig_ctx->uc_mcontext.gregs[UESP],
+                     &memory,
+                     &lwp->stack))
+    return false;
+
+  TypedMDRVA<MDRawContextX86> context(minidump_writer);
+  if (!context.Allocate())
+    return false;
+  lwp->thread_context = context.location();
+  memset(context.get(), 0, sizeof(MDRawContextX86));
+  return WriteContext(context.get(),
+                      (int *)&writer_args->sig_ctx->uc_mcontext.gregs,
+                      &writer_args->sig_ctx->uc_mcontext.fpregs);
+#endif
+}
+
+bool WriteLwpStream(MinidumpFileWriter *minidump_writer,
+                    const SolarisLwp *lwp_lister,
+                    const lwpstatus_t *lsp, MDRawThread *lwp) {
+  prfpregset_t fp_regs = lsp->pr_fpreg;
+  const prgregset_t *gregs = &(lsp->pr_reg);
+  UntypedMDRVA memory(minidump_writer);
+#if TARGET_CPU_SPARC
+  if (!WriteLwpStack(lwp_lister,
+                     (*gregs)[R_SP],
                      &memory,
                      &lwp->stack))
     return false;
 
   // Write context
-  TypedMDRVA<MDRawContextSPARC> context(&writer_);
+  TypedMDRVA<MDRawContextSPARC> context(minidump_writer);
   if (!context.Allocate())
     return false;
   // should be the thread_id
@@ -143,13 +291,14 @@ bool MinidumpGenerator::WriteLwpStream(lwpstatus_t *lsp, MDRawThread *lwp) {
   lwp->thread_context = context.location();
   memset(context.get(), 0, sizeof(MDRawContextSPARC));
 #elif TARGET_CPU_X86
-  if (!WriteLwpStack((*gregs)[UESP],
+  if (!WriteLwpStack(lwp_lister,
+                     (*gregs)[UESP],
                      &memory,
                      &lwp->stack))
   return false;
 
   // Write context
-  TypedMDRVA<MDRawContextX86> context(&writer_);
+  TypedMDRVA<MDRawContextX86> context(minidump_writer);
   if (!context.Allocate())
     return false;
   // should be the thread_id
@@ -160,7 +309,7 @@ bool MinidumpGenerator::WriteLwpStream(lwpstatus_t *lsp, MDRawThread *lwp) {
   return WriteContext(context.get(), (int *)gregs, &fp_regs);
 }
 
-bool MinidumpGenerator::WriteCPUInformation(MDRawSystemInfo *sys_info) {
+bool WriteCPUInformation(MDRawSystemInfo *sys_info) {
   struct utsname uts;
   char *major, *minor, *build;
 
@@ -188,7 +337,8 @@ bool MinidumpGenerator::WriteCPUInformation(MDRawSystemInfo *sys_info) {
   return true;
 }
 
-bool MinidumpGenerator::WriteOSInformation(MDRawSystemInfo *sys_info) {
+bool WriteOSInformation(MinidumpFileWriter *minidump_writer,
+                        MDRawSystemInfo *sys_info) {
   sys_info->platform_id = MD_OS_SOLARIS;
 
   struct utsname uts;
@@ -220,7 +370,7 @@ bool MinidumpGenerator::WriteOSInformation(MDRawSystemInfo *sys_info) {
     }
 
     MDLocationDescriptor location;
-    if (!writer_.WriteString(os_version, 0, &location))
+    if (!minidump_writer->WriteString(os_version, 0, &location))
       return false;
     sys_info->csd_version_rva = location.rva;
   }
@@ -229,21 +379,34 @@ bool MinidumpGenerator::WriteOSInformation(MDRawSystemInfo *sys_info) {
 
 // Callback context for get writting lwp information.
 struct LwpInfoCallbackCtx {
-  MinidumpGenerator *generator;
+  MinidumpFileWriter *minidump_writer;
+  const WriterArgument *writer_args;
   TypedMDRVA<MDRawThreadList> *list;
   int lwp_index;
 };
 
 bool LwpInformationCallback(lwpstatus_t *lsp, void *context) {
   bool success = true;
-  // The current thread is the one to handle the crash. Ignore it.
+  LwpInfoCallbackCtx *callback_context =
+    static_cast<LwpInfoCallbackCtx *>(context);
+
+  // The current lwp is the one to handle the crash. Ignore it.
   if (lsp->pr_lwpid != pthread_self()) {
     LwpInfoCallbackCtx *callback_context =
       static_cast<LwpInfoCallbackCtx *>(context);
     MDRawThread lwp;
     memset(&lwp, 0, sizeof(MDRawThread));
 
-    success = callback_context->generator->WriteLwpStream(lsp, &lwp);
+    if (lsp->pr_lwpid != callback_context->writer_args->crashed_lwpid ||
+        callback_context->writer_args->sig_ctx == NULL) {
+      success = WriteLwpStream(callback_context->minidump_writer,
+                               callback_context->writer_args->lwp_lister,
+                               lsp, &lwp);
+    } else {
+      success = WriteCrashedLwpStream(callback_context->minidump_writer,
+                                      callback_context->writer_args,
+                                      lsp, &lwp);
+    }
     if (success) {
       callback_context->list->CopyIndexAfterObject(
           callback_context->lwp_index++,
@@ -254,12 +417,15 @@ bool LwpInformationCallback(lwpstatus_t *lsp, void *context) {
   return success;
 }
 
-bool MinidumpGenerator::WriteLwpListStream(MDRawDirectory *dir) {
+bool WriteLwpListStream(MinidumpFileWriter *minidump_writer,
+                        const WriterArgument *writer_args,
+                        MDRawDirectory *dir) {
   // Get the lwp information.
-  int lwp_count = lwp_lister_->GetLwpCount();
+  const SolarisLwp *lwp_lister = writer_args->lwp_lister;
+  int lwp_count = lwp_lister->GetLwpCount();
   if (lwp_count < 0)
     return false;
-  TypedMDRVA<MDRawThreadList> list(&writer_);
+  TypedMDRVA<MDRawThreadList> list(minidump_writer);
   if (!list.AllocateObjectAndArray(lwp_count - 1, sizeof(MDRawThread)))
     return false;
   dir->stream_type = MD_THREAD_LIST_STREAM;
@@ -267,31 +433,32 @@ bool MinidumpGenerator::WriteLwpListStream(MDRawDirectory *dir) {
   list.get()->number_of_threads = lwp_count - 1;
 
   LwpInfoCallbackCtx context;
-  context.generator = this;
+  context.minidump_writer = minidump_writer;
+  context.writer_args = writer_args;
   context.list = &list;
   context.lwp_index = 0;
   CallbackParam<LwpCallback> callback_param(LwpInformationCallback,
                                             &context);
   int written =
-    lwp_lister_->Lwp_iter_all(lwp_lister_->getpid(), &callback_param);
+    lwp_lister->Lwp_iter_all(lwp_lister->getpid(), &callback_param);
   return written == lwp_count;
 }
 
-bool MinidumpGenerator::WriteCVRecord(MDRawModule *module,
+bool WriteCVRecord(MinidumpFileWriter *minidump_writer,
-                                      const char *module_path) {
+                   MDRawModule *module,
-  TypedMDRVA<MDCVInfoPDB70> cv(&writer_);
+                   const char *module_path,
+                   char *realname) {
+  TypedMDRVA<MDCVInfoPDB70> cv(minidump_writer);
 
   char path[PATH_MAX];
   const char *module_name = module_path ? module_path : "<Unknown>";
   snprintf(path, sizeof(path), "/proc/self/object/%s", module_name);
 
-  size_t module_name_length = strlen(module_name);
+  size_t module_name_length = strlen(realname);
   if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(u_int8_t)))
     return false;
-  if (!cv.CopyIndexAfterObject(0, const_cast<char *>(module_name),
+  if (!cv.CopyIndexAfterObject(0, realname, module_name_length))
-                               module_name_length)) {
     return false;
-  }
 
   module->cv_record = cv.location();
   MDCVInfoPDB70 *cv_ptr = cv.get();
@@ -322,8 +489,8 @@ bool MinidumpGenerator::WriteCVRecord(MDRawModule *module,
 }
 
 struct ModuleInfoCallbackCtx {
-  MinidumpGenerator *generator;
   MinidumpFileWriter *minidump_writer;
+  const WriterArgument *writer_args;
   TypedMDRVA<MDRawModuleList> *list;
   int module_index;
 };
@@ -338,16 +505,29 @@ bool ModuleInfoCallback(const ModuleInfo &module_info, void *context) {
   MDRawModule module;
   memset(&module, 0, sizeof(module));
   MDLocationDescriptor loc;
-  if (!callback_context->minidump_writer->WriteString(module_info.name,
+  char path[PATH_MAX];
-                                                      0, &loc)) {
+  char buf[PATH_MAX];
+  char *realname;
+  int count;
+
+  snprintf(path, sizeof (path), "/proc/self/path/%s", module_info.name);
+  if ((count = readlink(path, buf, PATH_MAX)) < 0)
+    return false;
+  buf[count] = '\0';
+
+  if ((realname = strrchr(buf, '/')) == NULL)
+    return false;
+  realname++;
+
+  if (!callback_context->minidump_writer->WriteString(realname, 0, &loc))
     return false;
-  }
 
   module.base_of_image = (u_int64_t)module_info.start_addr;
   module.size_of_image = module_info.size;
   module.module_name_rva = loc.rva;
 
-  if (!callback_context->generator->WriteCVRecord(&module, module_info.name))
+  if (!WriteCVRecord(callback_context->minidump_writer, &module,
+                     module_info.name, realname))
     return false;
 
   callback_context->list->CopyIndexAfterObject(
@@ -355,9 +535,11 @@ bool ModuleInfoCallback(const ModuleInfo &module_info, void *context) {
   return true;
 }
 
-bool MinidumpGenerator::WriteModuleListStream(MDRawDirectory *dir) {
+bool WriteModuleListStream(MinidumpFileWriter *minidump_writer,
-  TypedMDRVA<MDRawModuleList> list(&writer_);
+                           const WriterArgument *writer_args,
-  int module_count = lwp_lister_->GetModuleCount();
+                           MDRawDirectory *dir) {
+  TypedMDRVA<MDRawModuleList> list(minidump_writer);
+  int module_count = writer_args->lwp_lister->GetModuleCount();
 
   if (module_count <= 0 ||
       !list.AllocateObjectAndArray(module_count, MD_MODULE_SIZE)) {
@@ -368,16 +550,18 @@ bool MinidumpGenerator::WriteModuleListStream(MDRawDirectory *dir) {
   dir->location = list.location();
   list.get()->number_of_modules = module_count;
   ModuleInfoCallbackCtx context;
-  context.generator = this;
+  context.minidump_writer = minidump_writer;
-  context.minidump_writer = &writer_;
+  context.writer_args = writer_args;
   context.list = &list;
   context.module_index = 0;
   CallbackParam<ModuleCallback> callback(ModuleInfoCallback, &context);
-  return lwp_lister_->ListModules(&callback) == module_count;
+  return writer_args->lwp_lister->ListModules(&callback) == module_count;
 }
 
-bool MinidumpGenerator::WriteSystemInfoStream(MDRawDirectory *dir) {
+bool WriteSystemInfoStream(MinidumpFileWriter *minidump_writer,
-  TypedMDRVA<MDRawSystemInfo> sys_info(&writer_);
+                           const WriterArgument *writer_args,
+                           MDRawDirectory *dir) {
+  TypedMDRVA<MDRawSystemInfo> sys_info(minidump_writer);
 
   if (!sys_info.Allocate())
     return false;
@@ -386,69 +570,65 @@ bool MinidumpGenerator::WriteSystemInfoStream(MDRawDirectory *dir) {
   dir->location = sys_info.location();
 
   return WriteCPUInformation(sys_info.get()) &&
-         WriteOSInformation(sys_info.get());
+         WriteOSInformation(minidump_writer, sys_info.get());
 }
 
-bool MinidumpGenerator::WriteExceptionStream(MDRawDirectory *dir) {
+bool WriteExceptionStream(MinidumpFileWriter *minidump_writer,
-  ucontext_t uc;
+                          const WriterArgument *writer_args,
-  gregset_t *gregs;
+                          MDRawDirectory *dir) {
-  fpregset_t fp_regs;
+  // This happenes when this is not a crash, but a requested dump.
-
+  if (writer_args->sig_ctx == NULL)
-  if (getcontext(&uc) != 0)
     return false;
 
-  TypedMDRVA<MDRawExceptionStream> exception(&writer_);
+  TypedMDRVA<MDRawExceptionStream> exception(minidump_writer);
   if (!exception.Allocate())
     return false;
 
   dir->stream_type = MD_EXCEPTION_STREAM;
   dir->location = exception.location();
-  exception.get()->thread_id = requester_pid_;
+  exception.get()->thread_id = writer_args->crashed_lwpid;
-  exception.get()->exception_record.exception_code = signo_;
+  exception.get()->exception_record.exception_code = writer_args->signo;
   exception.get()->exception_record.exception_flags = 0;
 
-  gregs = &(uc.uc_mcontext.gregs);
-  fp_regs = uc.uc_mcontext.fpregs;
 #if TARGET_CPU_SPARC
-  exception.get()->exception_record.exception_address = ((unsigned int *)gregs)[1];
+  if (writer_args->sig_ctx != NULL) {
+    exception.get()->exception_record.exception_address = 
+      writer_args->sig_ctx->uc_mcontext.gregs[REG_PC];
+  } else {
+    return true;
+  }
+
   // Write context of the exception.
-  TypedMDRVA<MDRawContextSPARC> context(&writer_);
+  TypedMDRVA<MDRawContextSPARC> context(minidump_writer);
   if (!context.Allocate())
     return false;
   exception.get()->thread_context = context.location();
   memset(context.get(), 0, sizeof(MDRawContextSPARC));
-  
+  return WriteContext(context.get(), writer_args->sig_ctx);
-  // On Solaris i386, gregset_t = prgregset_t, fpregset_t = prfpregset_t
-  // But on Solaris Sparc are diffrent, see sys/regset.h and sys/procfs_isa.h
-  context.get()->context_flags = MD_CONTEXT_SPARC_FULL;
-  context.get()->ccr = ((unsigned int *)gregs)[0];
-  context.get()->pc = ((unsigned int *)gregs)[1];
-  context.get()->npc = ((unsigned int *)gregs)[2];
-  context.get()->y = ((unsigned int *)gregs)[3];
-  context.get()->asi = ((unsigned int *)gregs)[19];
-  context.get()->fprs = ((unsigned int *)gregs)[20];
-  for (int i = 0; i < 32; ++i) {
-    context.get()->g_r[i] = 0;
-  }
-  for (int i = 1; i < 16; ++i) {
-    context.get()->g_r[i] = ((unsigned int *)gregs)[i + 3];
-  }
- 
-  return true;
 #elif TARGET_CPU_X86
-  exception.get()->exception_record.exception_address = (*gregs)[EIP];
+  if (writer_args->sig_ctx != NULL) {
+    exception.get()->exception_record.exception_address =
+      writer_args->sig_ctx->uc_mcontext.gregs[EIP];
+  } else {
+    return true;
+  }
+
   // Write context of the exception.
-  TypedMDRVA<MDRawContextX86> context(&writer_);
+  TypedMDRVA<MDRawContextX86> context(minidump_writer);
   if (!context.Allocate())
     return false;
   exception.get()->thread_context = context.location();
   memset(context.get(), 0, sizeof(MDRawContextX86));
-  return WriteContext(context.get(), (int *)gregs, &fp_regs);
+  return WriteContext(context.get(),
-#endif /* TARGET_CPU_XXX */
+                      (int *)&writer_args->sig_ctx->uc_mcontext.gregs,
+                      NULL);
+#endif
 }
 
-bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *dir) {
+bool WriteMiscInfoStream(MinidumpFileWriter *minidump_writer,
-  TypedMDRVA<MDRawMiscInfo> info(&writer_);
+                         const WriterArgument *writer_args,
+                         MDRawDirectory *dir) {
+  TypedMDRVA<MDRawMiscInfo> info(minidump_writer);
 
   if (!info.Allocate())
     return false;
@@ -457,13 +637,15 @@ bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *dir) {
   dir->location = info.location();
   info.get()->size_of_info = sizeof(MDRawMiscInfo);
   info.get()->flags1 = MD_MISCINFO_FLAGS1_PROCESS_ID;
-  info.get()->process_id = requester_pid_;
+  info.get()->process_id = writer_args->requester_pid;
 
   return true;
 }
 
-bool MinidumpGenerator::WriteBreakpadInfoStream(MDRawDirectory *dir) {
+bool WriteBreakpadInfoStream(MinidumpFileWriter *minidump_writer,
-  TypedMDRVA<MDRawBreakpadInfo> info(&writer_);
+                             const WriterArgument *writer_args,
+                             MDRawDirectory *dir) {
+  TypedMDRVA<MDRawBreakpadInfo> info(minidump_writer);
 
   if (!info.Allocate())
     return false;
@@ -474,7 +656,7 @@ bool MinidumpGenerator::WriteBreakpadInfoStream(MDRawDirectory *dir) {
   info.get()->validity = MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID |
                          MD_BREAKPAD_INFO_VALID_REQUESTING_THREAD_ID;
   info.get()->dump_thread_id = getpid();
-  info.get()->requesting_thread_id = requester_pid_;
+  info.get()->requesting_thread_id = writer_args->requester_pid;
   return true;
 }
 
@@ -486,25 +668,53 @@ class AutoLwpResumer {
   SolarisLwp *lwp_;
 };
 
-// Will call each writer function in the writers table.
+// Prototype of writer functions.
-void* MinidumpGenerator::Write() {
+typedef bool (*WriteStreamFN)(MinidumpFileWriter *,
-  // Function table to writer a full minidump.
+                              const WriterArgument *,
-  const WriteStreamFN writers[] = {
+                              MDRawDirectory *);
-    &MinidumpGenerator::WriteLwpListStream,
-    &MinidumpGenerator::WriteModuleListStream,
-    &MinidumpGenerator::WriteSystemInfoStream,
-    &MinidumpGenerator::WriteExceptionStream,
-    &MinidumpGenerator::WriteMiscInfoStream,
-    &MinidumpGenerator::WriteBreakpadInfoStream,
-  };
 
-  if (!lwp_lister_->ControlAllLwps(true))
+// Function table to writer a full minidump.
+const WriteStreamFN writers[] = {
+  WriteLwpListStream,
+  WriteModuleListStream,
+  WriteSystemInfoStream,
+  WriteExceptionStream,
+  WriteMiscInfoStream,
+  WriteBreakpadInfoStream,
+};
+
+// Will call each writer function in the writers table.
+//void* MinidumpGenerator::Write(void *argument) {
+void* Write(void *argument) {
+  WriterArgument *writer_args = static_cast<WriterArgument *>(argument);
+
+  if (!writer_args->lwp_lister->ControlAllLwps(true))
     return NULL;
 
-  AutoLwpResumer lwpResumer(lwp_lister_);
+  AutoLwpResumer lwpResumer(writer_args->lwp_lister);
 
-  TypedMDRVA<MDRawHeader> header(&writer_);
+  if (writer_args->sighandler_ebp != 0 &&
-  TypedMDRVA<MDRawDirectory> dir(&writer_);
+      writer_args->lwp_lister->FindSigContext(writer_args->sighandler_ebp,
+                                              &writer_args->sig_ctx)) {
+    writer_args->crashed_stack_bottom = 
+      writer_args->lwp_lister->GetLwpStackBottom(
+#if TARGET_CPU_SPARC
+          writer_args->sig_ctx->uc_mcontext.gregs[REG_O6]
+#elif TARGET_CPU_X86
+          writer_args->sig_ctx->uc_mcontext.gregs[UESP]
+#endif
+      );
+
+    int crashed_lwpid = FindCrashingLwp(writer_args->crashed_stack_bottom,
+                                        writer_args->requester_pid,
+                                        writer_args->lwp_lister);
+    if (crashed_lwpid > 0)
+      writer_args->crashed_lwpid = crashed_lwpid;
+  }
+
+  MinidumpFileWriter *minidump_writer = writer_args->minidump_writer;
+  TypedMDRVA<MDRawHeader> header(minidump_writer);
+  TypedMDRVA<MDRawDirectory> dir(minidump_writer);
   if (!header.Allocate())
     return 0;
 
@@ -521,29 +731,53 @@ void* MinidumpGenerator::Write() {
   int dir_index = 0;
   MDRawDirectory local_dir;
   for (int i = 0; i < writer_count; ++i) {
-    if ((this->*writers[i])(&local_dir))
+    if ((*writers[i])(minidump_writer, writer_args, &local_dir))
       dir.CopyIndex(dir_index++, &local_dir);
   }
 
   return 0;
 }
 
+}  // namespace
+
+namespace google_breakpad {
+
+MinidumpGenerator::MinidumpGenerator() {
+}
+
+MinidumpGenerator::~MinidumpGenerator() {
+}
+
 // Write minidump into file.
 // It runs in a different thread from the crashing thread.
 bool MinidumpGenerator::WriteMinidumpToFile(const char *file_pathname,
-                                            int signo) {
+                                            int signo,
+                                            uintptr_t sighandler_ebp,
+                                            ucontext_t **sig_ctx) const {
+  // The exception handler thread.
+  pthread_t handler_thread;
+
   assert(file_pathname != NULL);
 
   if (file_pathname == NULL)
     return false;
 
-  if (writer_.Open(file_pathname)) {
+  MinidumpFileWriter minidump_writer;
+  if (minidump_writer.Open(file_pathname)) {
+    WriterArgument argument;
+    memset(&argument, 0, sizeof(argument));
     SolarisLwp lwp_lister(getpid());
-    lwp_lister_ = &lwp_lister;
+    argument.lwp_lister = &lwp_lister;
-    requester_pid_ = getpid();
+    argument.minidump_writer = &minidump_writer;
-    signo_ = signo;
+    argument.requester_pid = getpid();
-    if (Write())
+    argument.crashed_lwpid = pthread_self();
-      return true;
+    argument.signo = signo;
+    argument.sighandler_ebp = sighandler_ebp;
+    argument.sig_ctx = NULL;
+
+    pthread_create(&handler_thread, NULL, Write, (void *)&argument);
+    pthread_join(handler_thread, NULL);
+    return true;
   }
 
   return false;

src/client/solaris/handler/minidump_generator.h

@@ -32,13 +32,7 @@
 #ifndef CLIENT_SOLARIS_HANDLER_MINIDUMP_GENERATOR_H__
 #define CLIENT_SOLARIS_HANDLER_MINIDUMP_GENERATOR_H__
 
-#if defined(sparc) || defined(__sparc__)
+#include <ucontext.h>
-#define TARGET_CPU_SPARC 1
-#elif defined(i386) || defined(__i386__)
-#define TARGET_CPU_X86 1
-#else
-#error "cannot determine cpu type"
-#endif
 
 #include "client/minidump_file_writer.h"
 #include "client/solaris/handler/solaris_lwp.h"
@@ -66,59 +60,9 @@ class MinidumpGenerator {
 
   // Write minidump.
   bool WriteMinidumpToFile(const char *file_pathname,
-                           int signo);
+                           int signo,
-
+                           uintptr_t sighandler_ebp,
- private:
+                           ucontext_t **sig_ctx) const;
-  // Helpers
-  bool WriteCVRecord(MDRawModule *module, const char *module_path);
-
-  // Write the lwp stack information to dump file.
-  bool WriteLwpStack(uintptr_t last_esp, UntypedMDRVA *memory,
-                     MDMemoryDescriptor *loc);
-
-  // Write CPU context based on provided registers.
-#if TARGET_CPU_SPARC
-  bool WriteContext(MDRawContextSPARC *context, prgregset_t regs,
-                    prfpregset_t *fp_regs);
-#elif TARGET_CPU_X86
-  bool WriteContext(MDRawContextX86 *context, prgregset_t regs,
-                    prfpregset_t *fp_regs);
-#endif /* TARGET_CPU_XXX */
-
-  // Write information about a lwp.
-  // Only processes lwp running normally at the crash.
-  bool WriteLwpStream(lwpstatus_t *lsp, MDRawThread *lwp);
-
-  // Write the CPU information to the dump file.
-  bool WriteCPUInformation(MDRawSystemInfo *sys_info);
-
-  //Write the OS information to the dump file.
-  bool WriteOSInformation(MDRawSystemInfo *sys_info);
-
-  typedef bool (MinidumpGenerator::*WriteStreamFN)(MDRawDirectory *);
-
-  // Write all the information to the dump file.
-  void *Write();
-
-  // Stream writers
-  bool WriteLwpListStream(MDRawDirectory *dir);
-  bool WriteModuleListStream(MDRawDirectory *dir);
-  bool WriteSystemInfoStream(MDRawDirectory *dir);
-  bool WriteExceptionStream(MDRawDirectory *dir);
-  bool WriteMiscInfoStream(MDRawDirectory *dir);
-  bool WriteBreakpadInfoStream(MDRawDirectory *dir);
-
- private:
-  MinidumpFileWriter writer_;
-
-  // Pid of the lwp who called WriteMinidumpToFile
-  int requester_pid_;
-
-  // Signal number when crash happed. Can be 0 if this is a requested dump.
-  int signo_;
-
-  // Used to get information about the lwps.
-  SolarisLwp *lwp_lister_;
 };
 
 }  // namespace google_breakpad

src/client/solaris/handler/minidump_test.cc

@@ -48,7 +48,7 @@ static void *Reporter(void *) {
   snprintf(buffer, sizeof(buffer), "./minidump_test.out");
   fprintf(stdout, "Writing %s\n", buffer);
 
-  md.WriteMinidumpToFile(buffer, 0);
+  md.WriteMinidumpToFile(buffer, 0, 0, NULL);
   doneWritingReport = true;
 
   return NULL;

src/client/solaris/handler/solaris_lwp.cc

@@ -30,9 +30,11 @@
 // Author: Alfred Peng
 
 #include <dirent.h>
+#include <elf.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
+#include <sys/frame.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@@ -56,6 +58,16 @@ uintptr_t stack_base_address = 0;
 static const int HEADER_MAX = 2000;
 static const int MAP_MAX = 1000;
 
+// Context information for the callbacks when validating address by listing
+// modules.
+struct AddressValidatingContext {
+  uintptr_t address;
+  bool is_mapped;
+
+  AddressValidatingContext() : address(0UL), is_mapped(false) {
+  }
+};
+
 // Convert from string to int.
 static bool LocalAtoi(char *s, int *r) {
   assert(s != NULL);
@@ -69,18 +81,19 @@ static bool LocalAtoi(char *s, int *r) {
 }
 
 // Callback invoked for each mapped module.
-// It use the module's adderss range to validate the address.
+// It uses the module's adderss range to validate the address.
 static bool AddressNotInModuleCallback(const ModuleInfo &module_info,
                                        void *context) {
-  uintptr_t addr = reinterpret_cast<uintptr_t>(context);
+  AddressValidatingContext *addr =
-  if ((module_info.start_addr > 0) &&
+    reinterpret_cast<AddressValidatingContext *>(context);
-      (addr >= module_info.start_addr) &&
+  if (addr->is_mapped = ((module_info.start_addr > 0) &&
-      (addr <= module_info.start_addr + module_info.size)) {
+                         (addr->address >= module_info.start_addr) &&
+                         (addr->address <= module_info.start_addr +
+                          module_info.size))) {
     stack_base_address = module_info.start_addr + module_info.size;
-    return false;
   }
 
-  return true;
+  return !addr->is_mapped;
 }
 
 static int IterateLwpAll(int pid,
@@ -114,6 +127,28 @@ static int IterateLwpAll(int pid,
   return count;
 }
 
+#if defined(__i386) && !defined(NO_FRAME_POINTER)
+void *GetNextFrame(void **last_ebp) {
+  void *sp = *last_ebp;
+  if ((unsigned long)sp == (unsigned long)last_ebp)
+    return NULL;
+  if ((unsigned long)sp & (sizeof(void *) - 1))
+    return NULL;
+  if ((unsigned long)sp - (unsigned long)last_ebp > 100000)
+    return NULL;
+  return sp;
+}
+#elif defined(__sparc)
+void *GetNextFrame(void *last_ebp) {
+  return reinterpret_cast<struct frame *>(last_ebp)->fr_savfp;
+}
+#else
+void *GetNextFrame(void **last_ebp) {
+  return reinterpret_cast<void*>(last_ebp);
+}
+#endif
+
+
 class AutoCloser {
  public:
   AutoCloser(int fd) : fd_(fd) {}
@@ -250,8 +285,10 @@ int SolarisLwp::Lwp_iter_all(int pid,
 }
 
 uintptr_t SolarisLwp::GetLwpStackBottom(uintptr_t current_esp) const {
+  AddressValidatingContext addr;
+  addr.address = current_esp;
   CallbackParam<ModuleCallback> callback_param(AddressNotInModuleCallback,
-                                               (void *)current_esp);
+                                               &addr);
   ListModules(&callback_param);
   return stack_base_address;
 }
@@ -313,7 +350,28 @@ int SolarisLwp::ListModules(
     memset(&module, 0, sizeof (module));
     module.start_addr = _maps->pr_vaddr;
     module.size = _maps->pr_size;
-    if ((strlen(name) > 0) && (strcmp(name, "a.out") != 0)) {
+    if (strlen(name) > 0) {
+      int objectfd = 0;
+      char path[PATH_MAX];
+      char buf[SELFMAG];
+
+      snprintf(path, sizeof (path), "/proc/self/object/%s", name);
+      if ((objectfd = open(path, O_RDONLY)) < 0) {
+        print_message1(2, "can't open module file\n");
+        continue;
+      }
+
+      AutoCloser autocloser(objectfd);
+
+      if (read(objectfd, buf, SELFMAG) != SELFMAG) {
+        print_message1(2, "can't read module file\n");
+        continue;
+      }
+      if (buf[0] != ELFMAG0 || buf[1] != ELFMAG1 ||
+          buf[2] != ELFMAG2 || buf[3] != ELFMAG3) {
+        continue;
+      }
+
       strncpy(module.name, name, sizeof (module.name) - 1);
       ++module_count;
     }
@@ -326,4 +384,53 @@ int SolarisLwp::ListModules(
   return module_count;
 }
 
+// Check if the address is a valid virtual address.
+// If the address is in any of the mapped modules, we take it as valid.
+// Otherwise it is invalid.
+bool SolarisLwp::IsAddressMapped(uintptr_t address) const {
+  AddressValidatingContext addr;
+  addr.address = address;
+  CallbackParam<ModuleCallback> callback_param(AddressNotInModuleCallback,
+                                               &addr);
+  ListModules(&callback_param);
+  return addr.is_mapped;
+}
+
+// We're looking for a ucontext_t as the second parameter
+// to a signal handler function call.  Luckily, the ucontext_t
+// has an ebp(fp on SPARC) member which should match the ebp(fp)
+// pointed to by the ebp(fp) of the signal handler frame.
+// The Solaris stack looks like this:
+// http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/lib/libproc/common/Pstack.c#81
+bool SolarisLwp::FindSigContext(uintptr_t sighandler_ebp,
+                                ucontext_t **sig_ctx) {
+  uintptr_t previous_ebp;
+  uintptr_t sig_ebp;
+  const int MAX_STACK_DEPTH = 50;
+  int depth_counter = 0;
+
+  do {
+#if TARGET_CPU_SPARC
+    previous_ebp = reinterpret_cast<uintptr_t>(GetNextFrame(
+                                  reinterpret_cast<void*>(sighandler_ebp)));
+    *sig_ctx = reinterpret_cast<ucontext_t*>(sighandler_ebp + sizeof (struct frame));
+    uintptr_t sig_esp = (*sig_ctx)->uc_mcontext.gregs[REG_O6];
+    if (sig_esp < previous_ebp && sig_esp > sighandler_ebp)
+      sig_ebp = (uintptr_t)(((struct frame *)sig_esp)->fr_savfp);
+
+#elif TARGET_CPU_X86
+    previous_ebp = reinterpret_cast<uintptr_t>(GetNextFrame(
+                                  reinterpret_cast<void**>(sighandler_ebp)));
+    *sig_ctx = reinterpret_cast<ucontext_t*>(sighandler_ebp + sizeof (struct frame) +
+                                             3 * sizeof(uintptr_t));
+    sig_ebp = (*sig_ctx)->uc_mcontext.gregs[EBP];
+#endif
+    sighandler_ebp = previous_ebp;
+    depth_counter++;
+  } while(previous_ebp != sig_ebp && sighandler_ebp != 0 &&
+          IsAddressMapped(sighandler_ebp) && depth_counter < MAX_STACK_DEPTH);
+
+  return previous_ebp == sig_ebp && previous_ebp != 0;
+}
+
 }  // namespace google_breakpad

src/client/solaris/handler/solaris_lwp.h

@@ -32,9 +32,18 @@
 #ifndef CLIENT_SOLARIS_HANDLER_SOLARIS_LWP_H__
 #define CLIENT_SOLARIS_HANDLER_SOLARIS_LWP_H__
 
+#if defined(sparc) || defined(__sparc)
+#define TARGET_CPU_SPARC 1
+#elif defined(i386) || defined(__i386)
+#define TARGET_CPU_X86 1
+#else
+#error "cannot determine cpu type"
+#endif
+
 #include <signal.h>
 #include <stdint.h>
 #include <sys/user.h>
+#include <ucontext.h>
 
 #ifndef _KERNEL
 #define _KERNEL
@@ -134,6 +143,13 @@ class SolarisLwp {
   // Get the bottom of the stack from esp.
   uintptr_t GetLwpStackBottom(uintptr_t current_esp) const;
 
+  // Finds a signal context on the stack given the ebp of our signal handler.
+  bool FindSigContext(uintptr_t sighandler_ebp, ucontext_t **sig_ctx);
+
+ private:
+  // Check if the address is a valid virtual address.
+  bool IsAddressMapped(uintptr_t address) const;
+
  private:
   // The pid of the process we are listing lwps.
   int pid_;

src/common/solaris/dump_symbols.cc

@@ -40,6 +40,7 @@
 #include <unistd.h>
 
 #include <functional>
+#include <map>
 #include <vector>
 
 #include "common/solaris/dump_symbols.h"
@@ -50,7 +51,15 @@
 // This namespace contains helper functions.
 namespace {
 
-// Symbol table entry for stabs. Sun CC specific.
+using std::make_pair;
+
+#if defined(_LP64)
+typedef Elf64_Sym   Elf_Sym;
+#else
+typedef Elf32_Sym   Elf_Sym;
+#endif
+
+// Symbol table entry from stabs. Sun CC specific.
 struct slist {
   // String table index.
   unsigned int n_strx;
@@ -61,6 +70,14 @@ struct slist {
   unsigned long n_value;
 };
 
+// Symbol table entry
+struct SymbolEntry {
+  // Offset from the start of the file.
+  GElf_Addr offset;
+  // Function size.
+  GElf_Word size;
+};
+
 // Infomation of a line.
 struct LineInfo {
   // Offset from start of the function.
@@ -107,10 +124,20 @@ struct SourceFileInfo {
   std::vector<struct FuncInfo> func_info;
 };
 
+struct CompareString {
+  bool operator()(const char *s1, const char *s2) const {
+    return strcmp(s1, s2) < 0;
+  }
+};
+
+typedef std::map<const char *, struct SymbolEntry *, CompareString> SymbolMap;
+
 // Information of a symbol table.
 // This is the root of all types of symbol.
 struct SymbolInfo {
   std::vector<struct SourceFileInfo> source_file_info;
+  // Symbols information.
+  SymbolMap symbol_entries;
 };
 
 // Stab section name.
@@ -119,8 +146,32 @@ const char *kStabName = ".stab";
 // Stab str section name.
 const char *kStabStrName = ".stabstr";
 
+// Symtab section name.
+const char *kSymtabName = ".symtab";
+
+// Strtab section name.
+const char *kStrtabName = ".strtab";
+
 // Default buffer lenght for demangle.
-const int demangleLen = 2000;
+const int demangleLen = 20000;
+
+// Offset to the string table.
+u_int64_t stringOffset = 0;
+
+// Update the offset to the start of the string index of the next
+// object module for every N_ENDM stabs.
+inline void RecalculateOffset(struct slist* cur_list, char *stabstr) {
+  while ((--cur_list)->n_strx == 0) ;
+  stringOffset += cur_list->n_strx;
+
+  char *temp = stabstr + stringOffset;
+  while (*temp != '\0') {
+    ++stringOffset;
+    ++temp;
+  }
+  // Skip the extra '\0'
+  ++stringOffset;
+}
 
 // Demangle using demangle library on Solaris.
 std::string Demangle(const char *mangled) {
@@ -145,18 +196,6 @@ out:
   return std::string(mangled);
 }
 
-// Find the prefered loading address of the binary.
-GElf_Addr GetLoadingAddress(const GElf_Phdr *program_headers, int nheader) {
-  for (int i = 0; i < nheader; ++i) {
-    const GElf_Phdr &header = program_headers[i];
-    // For executable, it is the PT_LOAD segment with offset to zero.
-    if (header.p_type == PT_LOAD && header.p_offset == 0)
-      return header.p_vaddr;
-  }
-  // For other types of ELF, return 0.
-  return 0;
-}
-
 bool WriteFormat(int fd, const char *fmt, ...) {
   va_list list;
   char buffer[4096];
@@ -226,9 +265,11 @@ int LoadLineInfo(struct slist *list,
   do {
     // Skip non line information.
     while (cur_list < list_end && cur_list->n_type != N_SLINE) {
-      // Only exit when got another function, or source file.
+      // Only exit when got another function, or source file, or end stab.
-      if (cur_list->n_type == N_FUN || cur_list->n_type == N_SO)
+      if (cur_list->n_type == N_FUN || cur_list->n_type == N_SO ||
+          cur_list->n_type == N_ENDM) {
         return cur_list - list;
+      }
       ++cur_list;
     }
     struct LineInfo line;
@@ -248,7 +289,7 @@ int LoadLineInfo(struct slist *list,
 
 int LoadFuncSymbols(struct slist *list,
                     struct slist *list_end,
-                    const GElf_Shdr *stabstr_section,
+                    char *stabstr,
                     GElf_Word base,
                     struct SourceFileInfo *source_file_info) {
   struct slist *cur_list = list;
@@ -263,18 +304,20 @@ int LoadFuncSymbols(struct slist *list,
         return cur_list - list;
       }
       ++cur_list;
+      if (cur_list->n_type == N_ENDM)
+        RecalculateOffset(cur_list, stabstr);
       continue;
     }
     while (cur_list->n_type == N_FUN) {
       struct FuncInfo func_info;
       memset(&func_info, 0, sizeof(func_info));
-      func_info.name =
+      func_info.name = stabstr + cur_list->n_strx + stringOffset;
-        reinterpret_cast<char *>(cur_list->n_strx +
-                                 stabstr_section->sh_offset + base);
       // The n_value field is always 0 from stab generated by Sun CC.
       // TODO(Alfred): Find the correct value.
       func_info.addr = cur_list->n_value;
       ++cur_list;
+      if (cur_list->n_type == N_ENDM)
+        RecalculateOffset(cur_list, stabstr);
       if (cur_list->n_type != N_ESYM && cur_list->n_type != N_ISYM &&
           cur_list->n_type != N_FUN) {
         // Stack parameter size.
@@ -282,6 +325,8 @@ int LoadFuncSymbols(struct slist *list,
         // Line info.
         cur_list += LoadLineInfo(cur_list, list_end, &func_info);
       }
+      if (cur_list < list_end && cur_list->n_type == N_ENDM)
+        RecalculateOffset(cur_list, stabstr);
       // Functions in this module should have address bigger than the module
       // starting address.
       //
@@ -296,48 +341,70 @@ int LoadFuncSymbols(struct slist *list,
 }
 
 // Compute size and rva information based on symbols loaded from stab section.
-bool ComputeSizeAndRVA(GElf_Addr loading_addr, struct SymbolInfo *symbols) {
+bool ComputeSizeAndRVA(struct SymbolInfo *symbols) {
   std::vector<struct SourceFileInfo> *sorted_files =
     &(symbols->source_file_info);
+  SymbolMap *symbol_entries = &(symbols->symbol_entries);
   for (size_t i = 0; i < sorted_files->size(); ++i) {
     struct SourceFileInfo &source_file = (*sorted_files)[i];
     std::vector<struct FuncInfo> *sorted_functions = &(source_file.func_info);
-    for (size_t j = 0; j < sorted_functions->size(); ++j) {
+    int func_size = sorted_functions->size();
+
+    for (size_t j = 0; j < func_size; ++j) {
       struct FuncInfo &func_info = (*sorted_functions)[j];
-      assert(func_info.addr >= loading_addr);
-      func_info.rva_to_base = func_info.addr - loading_addr;
       int line_count = func_info.line_info.size();
-      func_info.size =
+
-        (line_count == 0) ? 0 :
+      // Discard the ending part of the name.
-                            func_info.line_info[line_count - 1].rva_to_func;
+      std::string func_name(func_info.name);
+      std::string::size_type last_colon = func_name.find_first_of(':');
+      if (last_colon != std::string::npos)
+        func_name = func_name.substr(0, last_colon);
+
+      // Fine the symbol offset from the loading address and size by name.
+      SymbolMap::const_iterator it = symbol_entries->find(func_name.c_str());
+      if (it->second) {
+        func_info.rva_to_base = it->second->offset;
+        func_info.size = (line_count == 0) ? 0 : it->second->size;
+      } else {
+        func_info.rva_to_base = 0;
+        func_info.size = 0;
+      }
+
       // Compute function and line size.
       for (size_t k = 0; k < line_count; ++k) {
         struct LineInfo &line_info = func_info.line_info[k];
-        if (k == 0) {
+
-          line_info.size = line_info.rva_to_func;
-        } else {
-          line_info.size =
-            line_info.rva_to_func - func_info.line_info[k - 1].rva_to_func;
-        }
         line_info.rva_to_base = line_info.rva_to_func + func_info.rva_to_base;
+        if (k == line_count - 1) {
+          line_info.size = func_info.size - line_info.rva_to_func;
+        } else {
+          struct LineInfo &next_line = func_info.line_info[k + 1];
+          line_info.size = next_line.rva_to_func - line_info.rva_to_func;
+        }
       }  // for each line.
     }  // for each function.
   }  // for each source file.
+  for (SymbolMap::iterator it = symbol_entries->begin();
+       it != symbol_entries->end(); ++it) {
+    free(it->second);
+  }
   return true;
 }
 
 bool LoadAllSymbols(const GElf_Shdr *stab_section,
                     const GElf_Shdr *stabstr_section,
-                    GElf_Addr loading_addr,
                     GElf_Word base,
                     struct SymbolInfo *symbols) {
   if (stab_section == NULL || stabstr_section == NULL)
     return false;
 
+  char *stabstr = 
+    reinterpret_cast<char *>(stabstr_section->sh_offset + base);
   struct slist *lists =
     reinterpret_cast<struct slist *>(stab_section->sh_offset + base);
   int nstab = stab_section->sh_size / sizeof(struct slist);
   int source_id = 0;
+
   // First pass, load all symbols from the object file.
   for (int i = 0; i < nstab; ) {
     int step = 1;
@@ -345,9 +412,7 @@ bool LoadAllSymbols(const GElf_Shdr *stab_section,
     if (cur_list->n_type == N_SO) {
       // FUNC <address> <size> <param_stack_size> <function>
       struct SourceFileInfo source_file_info;
-      source_file_info.name =
+      source_file_info.name = stabstr + cur_list->n_strx + stringOffset;
-        reinterpret_cast<char *>(cur_list->n_strx +
-                                 stabstr_section->sh_offset + base);
       // The n_value field is always 0 from stab generated by Sun CC.
       // TODO(Alfred): Find the correct value.
       source_file_info.addr = cur_list->n_value;
@@ -355,22 +420,19 @@ bool LoadAllSymbols(const GElf_Shdr *stab_section,
         source_file_info.source_id = source_id++;
       else
         source_file_info.source_id = -1;
-      step = LoadFuncSymbols(cur_list, lists + nstab - 1,
+      step = LoadFuncSymbols(cur_list, lists + nstab - 1, stabstr,
-                             stabstr_section, base, &source_file_info);
+                             base, &source_file_info);
       symbols->source_file_info.push_back(source_file_info);
     }
     i += step;
   }
   // Second pass, compute the size of functions and lines.
-  return ComputeSizeAndRVA(loading_addr, symbols);
+  return ComputeSizeAndRVA(symbols);
 }
 
 bool LoadSymbols(Elf *elf, GElf_Ehdr *elf_header, struct SymbolInfo *symbols,
                  void *obj_base) {
   GElf_Word base = reinterpret_cast<GElf_Word>(obj_base);
-  GElf_Addr loading_addr = GetLoadingAddress(
-      reinterpret_cast<GElf_Phdr *>(elf_header->e_phoff + base),
-      elf_header->e_phnum);
 
   const GElf_Shdr *sections =
     reinterpret_cast<GElf_Shdr *>(elf_header->e_shoff + base);
@@ -386,9 +448,34 @@ bool LoadSymbols(Elf *elf, GElf_Ehdr *elf_header, struct SymbolInfo *symbols,
     fprintf(stderr, "Stabstr section not found.\n");
     return false;
   }
+  GElf_Shdr symtab_section;
+  if (!FindSectionByName(elf, kSymtabName, elf_header->e_shstrndx,
+                         &symtab_section)) {
+    fprintf(stderr, "Symtab section not found.\n");
+    return false;
+  }
+  GElf_Shdr strtab_section;
+  if (!FindSectionByName(elf, kStrtabName, elf_header->e_shstrndx,
+                         &strtab_section)) {
+    fprintf(stderr, "Strtab section not found.\n");
+    return false;
+  }
+
+  Elf_Sym *symbol = (Elf_Sym *)((char *)base + symtab_section.sh_offset);
+  for (int i = 0; i < symtab_section.sh_size/symtab_section.sh_entsize; ++i) {
+    struct SymbolEntry *symbol_entry =
+        (struct SymbolEntry *)malloc(sizeof(struct SymbolEntry));
+    const char *name = reinterpret_cast<char *>(
+        strtab_section.sh_offset + (GElf_Word)base + symbol->st_name);
+    symbol_entry->offset = symbol->st_value;
+    symbol_entry->size = symbol->st_size;
+    symbols->symbol_entries.insert(make_pair(name, symbol_entry));
+    ++symbol;
+  }
+
 
   // Load symbols.
-  return LoadAllSymbols(&stab_section, &stabstr_section, loading_addr, base, symbols);
+  return LoadAllSymbols(&stab_section, &stabstr_section, base, symbols);
 }
 
 bool WriteModuleInfo(int fd, GElf_Half arch, const std::string &obj_file) {
@@ -397,8 +484,12 @@ bool WriteModuleInfo(int fd, GElf_Half arch, const std::string &obj_file) {
     arch_name = "x86";
   else if (arch == EM_X86_64)
     arch_name = "x86_64";
-  else
+  else if (arch == EM_SPARC32PLUS)
+    arch_name = "SPARC_32+";
+  else {
+    printf("Please add more ARCH support\n");
     return false;
+  }
 
   unsigned char identifier[16];
   google_breakpad::FileID file_id(obj_file.c_str());
@@ -437,18 +528,20 @@ bool WriteOneFunction(int fd, int source_id,
     func_name = func_name.substr(0, last_colon);
   func_name = Demangle(func_name.c_str());
 
-  if (func_info.size < 0)
+  if (func_info.size <= 0)
     return true;
 
   // rva_to_base could be unsigned long(32 bit) or unsigned long long(64 bit).
-  if (WriteFormat(fd, "FUNC %llx %d %d %s\n",
+  if (WriteFormat(fd, "FUNC %llx %x %d %s\n",
                   (long long)func_info.rva_to_base,
                   func_info.size,
                   func_info.stack_param_size,
                   func_name.c_str())) {
     for (size_t i = 0; i < func_info.line_info.size(); ++i) {
       const struct LineInfo &line_info = func_info.line_info[i];
-      if (!WriteFormat(fd, "%llx %d %d %d\n",
+      if (line_info.line_num == 0)
+        return true;
+      if (!WriteFormat(fd, "%llx %x %d %d\n",
                        (long long)line_info.rva_to_base,
                        line_info.size,
                        line_info.line_num,

src/google_breakpad/processor/minidump.h

@@ -79,6 +79,7 @@
 #ifndef GOOGLE_BREAKPAD_PROCESSOR_MINIDUMP_H__
 #define GOOGLE_BREAKPAD_PROCESSOR_MINIDUMP_H__
 
+#include <unistd.h>
 
 #include <map>
 #include <string>

src/google_breakpad/processor/stack_frame_cpu.h

@@ -128,9 +128,9 @@ struct StackFrameSPARC : public StackFrame {
   // to be confirmed
   enum ContextValidity {
     CONTEXT_VALID_NONE = 0,
-    CONTEXT_VALID_PC   = 0 << 0,
+    CONTEXT_VALID_PC   = 1 << 0,
-    CONTEXT_VALID_SP   = 0 << 1,
+    CONTEXT_VALID_SP   = 1 << 1,
-    CONTEXT_VALID_FP   = 0 << 2,
+    CONTEXT_VALID_FP   = 1 << 2,
     CONTEXT_VALID_ALL  = -1
   };
 

src/processor/minidump.cc

@@ -2885,6 +2885,10 @@ string MinidumpSystemInfo::GetCPU() {
       cpu = "ppc";
       break;
 
+    case MD_CPU_ARCHITECTURE_SPARC:
+      cpu = "sparc";
+      break;
+
     default:
       BPLOG(ERROR) << "MinidumpSystemInfo unknown CPU for architecture " <<
                       HexString(system_info_.processor_architecture);