Solaris port of minidump generator. Port by Alfred Peng. r=me

http://groups.google.com/group/google-breakpad-dev/browse_thread/thread/7d8945578e3dac3


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

9 files changed, 1845 insertions, 0 deletions

diff --git a/src/client/solaris/handler/Makefile b/src/client/solaris/handler/Makefile
new file mode 100644
index 00000000..425d66f2
--- /dev/null
+++ b/src/client/solaris/handler/Makefile
@@ -0,0 +1,76 @@
+# Copyright (c) 2007, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Author: Alfred Peng
+
+CC=cc
+CXX=CC
+
+CPPFLAGS=-g -I../../.. -DNDEBUG -features=extensions -D_REENTRANT
+LDFLAGS=-lpthread -lssl -lgnutls-openssl -lelf
+
+OBJ_DIR=.
+BIN_DIR=.
+
+THREAD_SRC=solaris_lwp.cc
+SHARE_SRC=../../minidump_file_writer.cc\
+	  ../../../common/string_conversion.cc\
+	  ../../../common/solaris/file_id.cc\
+	  minidump_generator.cc
+HANDLER_SRC=exception_handler.cc\
+	  ../../../common/solaris/guid_creator.cc
+SHARE_C_SRC=../../../common/convert_UTF.c
+
+MINIDUMP_TEST_SRC=minidump_test.cc
+EXCEPTION_TEST_SRC=exception_handler_test.cc
+
+THREAD_OBJ=$(patsubst %.cc,$(OBJ_DIR)/%.o,$(THREAD_SRC))
+SHARE_OBJ=$(patsubst %.cc,$(OBJ_DIR)/%.o,$(SHARE_SRC))
+HANDLER_OBJ=$(patsubst %.cc,$(OBJ_DIR)/%.o,$(HANDLER_SRC))
+SHARE_C_OBJ=$(patsubst %.c,$(OBJ_DIR)/%.o,$(SHARE_C_SRC))
+MINIDUMP_TEST_OBJ=$(patsubst %.cc,$(OBJ_DIR)/%.o, $(MINIDUMP_TEST_SRC))\
+		  $(THREAD_OBJ) $(SHARE_OBJ) $(SHARE_C_OBJ) $(HANDLER_OBJ)
+EXCEPTION_TEST_OBJ=$(patsubst %.cc,$(OBJ_DIR)/%.o, $(EXCEPTION_TEST_SRC))\
+          $(THREAD_OBJ) $(SHARE_OBJ) $(SHARE_C_OBJ) $(HANDLER_OBJ)
+
+BIN=$(BIN_DIR)/minidump_test\
+    $(BIN_DIR)/exception_handler_test
+
+.PHONY:all clean
+
+all:$(BIN)
+
+$(BIN_DIR)/minidump_test:$(MINIDUMP_TEST_OBJ)
+	$(CXX) $(CPPFLAGS) $(LDFLAGS) $^ -o $@
+
+$(BIN_DIR)/exception_handler_test:$(EXCEPTION_TEST_OBJ)
+	$(CXX) $(CPPFLAGS) $(LDFLAGS) $^ -o $@
+
+clean:
+	rm -f $(BIN) *.o *.out *.dmp core
diff --git a/src/client/solaris/handler/exception_handler.cc b/src/client/solaris/handler/exception_handler.cc
new file mode 100644
index 00000000..3d35b8eb
--- /dev/null
+++ b/src/client/solaris/handler/exception_handler.cc
@@ -0,0 +1,292 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: Alfred Peng
+
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+
+#include "client/solaris/handler/exception_handler.h"
+#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,
+  SIGABRT,
+  SIGFPE,
+  SIGILL,
+  SIGBUS
+};
+
+std::vector<ExceptionHandler*> *ExceptionHandler::handler_stack_ = NULL;
+int ExceptionHandler::handler_stack_index_ = 0;
+pthread_mutex_t ExceptionHandler::handler_stack_mutex_ =
+  PTHREAD_MUTEX_INITIALIZER;
+
+ExceptionHandler::ExceptionHandler(const string &dump_path,
+                                   FilterCallback filter,
+                                   MinidumpCallback callback,
+                                   void *callback_context,
+                                   bool install_handler)
+    : filter_(filter),
+      handler_thread_(0),
+      handler_return_value_(false),
+      callback_(callback),
+      callback_context_(callback_context),
+      installed_handler_(install_handler) {
+  set_dump_path(dump_path);
+
+  if (install_handler) {
+    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_);
+
+    if (handler_stack_ == NULL)
+      handler_stack_ = new std::vector<ExceptionHandler *>;
+    handler_stack_->push_back(this);
+    pthread_mutex_unlock(&handler_stack_mutex_);
+  }
+}
+
+ExceptionHandler::~ExceptionHandler() {
+  TeardownAllHandlers();
+  pthread_mutex_lock(&handler_stack_mutex_);
+  if (handler_stack_->back() == this) {
+    handler_stack_->pop_back();
+  } else {
+    print_message1(2, "warning: removing Breakpad handler out of order\n");
+    for (std::vector<ExceptionHandler *>::iterator iterator =
+         handler_stack_->begin();
+         iterator != handler_stack_->end();
+         ++iterator) {
+      if (*iterator == this) {
+        handler_stack_->erase(iterator);
+      }
+    }
+  }
+
+  if (handler_stack_->empty()) {
+    // When destroying the last ExceptionHandler that installed a handler,
+    // clean up the handler stack.
+    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);
+}
+
+// static
+bool ExceptionHandler::WriteMinidump(const string &dump_path,
+                                     MinidumpCallback callback,
+                                     void *callback_context) {
+  ExceptionHandler handler(dump_path, NULL, callback,
+                           callback_context, false);
+  return handler.WriteMinidumpOnHandlerThread(0);
+}
+
+void ExceptionHandler::SetupHandler() {
+  // Signal on a different stack to avoid using the stack
+  // of the crashing lwp.
+  struct sigaltstack sig_stack;
+  sig_stack.ss_sp = malloc(MINSIGSTKSZ);
+  if (sig_stack.ss_sp == NULL)
+    return;
+  sig_stack.ss_size = MINSIGSTKSZ;
+  sig_stack.ss_flags = 0;
+
+  if (sigaltstack(&sig_stack, NULL) < 0)
+    return;
+  for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i)
+    SetupHandler(kSigTable[i]);
+}
+
+void ExceptionHandler::SetupHandler(int signo) {
+  struct sigaction act, old_act;
+  act.sa_handler = HandleException;
+  act.sa_flags = SA_ONSTACK;
+  if (sigaction(signo, &act, &old_act) < 0)
+    return;
+  old_handlers_[signo] = old_act.sa_handler;
+}
+
+void ExceptionHandler::TeardownHandler(int signo) {
+  if (old_handlers_.find(signo) != old_handlers_.end()) {
+    struct sigaction act;
+    act.sa_handler = old_handlers_[signo];
+    act.sa_flags = 0;
+    sigaction(signo, &act, 0);
+  }
+}
+
+void ExceptionHandler::TeardownAllHandlers() {
+  for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i) {
+    TeardownHandler(kSigTable[i]);
+  }
+}
+
+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) {
+  pthread_mutex_lock(&handler_stack_mutex_);
+  ExceptionHandler *current_handler =
+    handler_stack_->at(handler_stack_->size() - ++handler_stack_index_);
+  pthread_mutex_unlock(&handler_stack_mutex_);
+
+  // Restore original handler.
+  current_handler->TeardownHandler(signo);
+  if (current_handler->WriteMinidumpOnHandlerThread(signo)) {
+    // Fully handled this exception, safe to exit.
+    exit(EXIT_FAILURE);
+  } else {
+    // Exception not fully handled, will call the next handler in stack to
+    // process it.
+    typedef void (*SignalHandler)(int signo);
+    SignalHandler old_handler =
+      reinterpret_cast<SignalHandler>(current_handler->old_handlers_[signo]);
+    if (old_handler != NULL)
+      old_handler(signo);
+  }
+
+  pthread_mutex_lock(&handler_stack_mutex_);
+  current_handler->SetupHandler(signo);
+  --handler_stack_index_;
+  // All the handlers in stack have been invoked to handle the exception,
+  // normally the process should be terminated and should not reach here.
+  // In case we got here, ask the OS to handle it to avoid endless loop,
+  // normally the OS will generate a core and termiate the process. This
+  // may be desired to debug the program.
+  if (handler_stack_index_ == 0)
+    signal(signo, SIG_DFL);
+  pthread_mutex_unlock(&handler_stack_mutex_);
+}
+
+bool ExceptionHandler::InternalWriteMinidump() {
+  if (filter_ && !filter_(callback_context_))
+    return false;
+
+  bool success = false;
+  GUID guid;
+  char guid_str[kGUIDStringLength + 1];
+  if (CreateGUID(&guid) && GUIDToString(&guid, guid_str, sizeof(guid_str))) {
+    char minidump_path[PATH_MAX];
+    snprintf(minidump_path, sizeof(minidump_path), "%s/%s.dmp",
+             dump_path_c_, guid_str);
+
+    // Block all the signals we want to process when writing minidump.
+    // We don't want it to be interrupted.
+    sigset_t sig_blocked, sig_old;
+    bool blocked = true;
+    sigfillset(&sig_blocked);
+    for (size_t i = 0; i < sizeof(kSigTable) / sizeof(kSigTable[0]); ++i)
+      sigdelset(&sig_blocked, kSigTable[i]);
+    if (sigprocmask(SIG_BLOCK, &sig_blocked, &sig_old) != 0) {
+      blocked = false;
+      print_message1(2, "HandleException: failed to block signals.\n");
+    }
+
+    success = minidump_generator_.WriteMinidumpToFile(minidump_path, signo_);
+
+    // Unblock the signals.
+    if (blocked)
+      sigprocmask(SIG_SETMASK, &sig_old, &sig_old);
+
+    if (callback_)
+      success = callback_(dump_path_c_, guid_str, callback_context_, success);
+  }
+  return success;
+}
+
+}  // namespace google_breakpad
diff --git a/src/client/solaris/handler/exception_handler.h b/src/client/solaris/handler/exception_handler.h
new file mode 100644
index 00000000..ab035905
--- /dev/null
+++ b/src/client/solaris/handler/exception_handler.h
@@ -0,0 +1,213 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Author: Alfred Peng
+
+#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>
+
+#include "client/solaris/handler/minidump_generator.h"
+
+namespace google_breakpad {
+
+using std::string;
+
+//
+// ExceptionHandler
+//
+// ExceptionHandler can write a minidump file when an exception occurs,
+// or when WriteMinidump() is called explicitly by your program.
+//
+// To have the exception handler write minidumps when an uncaught exception
+// (crash) occurs, you should create an instance early in the execution
+// of your program, and keep it around for the entire time you want to
+// have crash handling active (typically, until shutdown).
+// (NOTE): There should be only one this kind of exception handler
+// object per process.
+//
+// If you want to write minidumps without installing the exception handler,
+// you can create an ExceptionHandler with install_handler set to false,
+// then call WriteMinidump.  You can also use this technique if you want to
+// use different minidump callbacks for different call sites.
+//
+// In either case, a callback function is called when a minidump is written,
+// which receives the unqiue id of the minidump.  The caller can use this
+// id to collect and write additional application state, and to launch an
+// external crash-reporting application.
+//
+// Caller should try to make the callbacks as crash-friendly as possible,
+// it should avoid use heap memory allocation as much as possible.
+//
+class ExceptionHandler {
+ public:
+  // A callback function to run before Breakpad performs any substantial
+  // processing of an exception.  A FilterCallback is called before writing
+  // a minidump.  context is the parameter supplied by the user as
+  // callback_context when the handler was created.
+  //
+  // If a FilterCallback returns true, Breakpad will continue processing,
+  // attempting to write a minidump.  If a FilterCallback returns false,
+  // Breakpad  will immediately report the exception as unhandled without
+  // writing a minidump, allowing another handler the opportunity to handle it.
+  typedef bool (*FilterCallback)(void *context);
+
+  // A callback function to run after the minidump has been written.
+  // minidump_id is a unique id for the dump, so the minidump
+  // file is <dump_path>/<minidump_id>.dmp.  context is the parameter supplied
+  // by the user as callback_context when the handler was created.  succeeded
+  // indicates whether a minidump file was successfully written.
+  //
+  // If an exception occurred and the callback returns true, Breakpad will
+  // treat the exception as fully-handled, suppressing any other handlers from
+  // being notified of the exception.  If the callback returns false, Breakpad
+  // will treat the exception as unhandled, and allow another handler to handle
+  // it. If there are no other handlers, Breakpad will report the exception to
+  // the system as unhandled, allowing a debugger or native crash dialog the
+  // opportunity to handle the exception.  Most callback implementations
+  // should normally return the value of |succeeded|, or when they wish to
+  // not report an exception of handled, false.  Callbacks will rarely want to
+  // return true directly (unless |succeeded| is true).
+  typedef bool (*MinidumpCallback)(const char *dump_path,
+                                   const char *minidump_id,
+                                   void *context,
+                                   bool succeeded);
+
+  // Creates a new ExceptionHandler instance to handle writing minidumps.
+  // Before writing a minidump, the optional filter callback will be called.
+  // Its return value determines whether or not Breakpad should write a
+  // minidump.  Minidump files will be written to dump_path, and the optional
+  // callback is called after writing the dump file, as described above.
+  // If install_handler is true, then a minidump will be written whenever
+  // an unhandled exception occurs.  If it is false, minidumps will only
+  // be written when WriteMinidump is called.
+  ExceptionHandler(const string &dump_path,
+                   FilterCallback filter, MinidumpCallback callback,
+                   void *callback_context,
+                   bool install_handler);
+  ~ExceptionHandler();
+
+  // Set the minidump path.
+  void set_dump_path(const string &dump_path) {
+    dump_path_c_ = dump_path.c_str();
+  }
+
+  // Writes a minidump immediately.  This can be used to capture the
+  // execution state independently of a crash.  Returns true on success.
+  bool WriteMinidump();
+
+  // Convenience form of WriteMinidump which does not require an
+  // ExceptionHandler instance.
+  static bool WriteMinidump(const string &dump_path,
+                            MinidumpCallback callback,
+                            void *callback_context);
+
+ private:
+  // Setup crash handler.
+  void SetupHandler();
+  // Setup signal handler for a signal.
+  void SetupHandler(int signo);
+  // Teardown the handler for a signal.
+  void TeardownHandler(int signo);
+  // Teardown all handlers.
+  void TeardownAllHandlers();
+
+  // Runs the main loop for the exception handler thread.
+  static void* ExceptionHandlerThreadMain(void *lpParameter);
+
+  // 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();
+
+ 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_;
+
+  // 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_;
+
+  // True if the ExceptionHandler installed an unhandled exception filter
+  // when created (with an install_handler parameter set to true).
+  bool installed_handler_;
+
+  // Keep the previous handlers for the signal.
+  typedef void (*sighandler_t)(int);
+  std::map<int, sighandler_t> old_handlers_;
+
+  // The global exception handler stack. This is need becuase there may exist
+  // multiple ExceptionHandler instances in a process. Each will have itself
+  // registered in this stack.
+  static std::vector<ExceptionHandler *> *handler_stack_;
+  // The index of the handler that should handle the next exception.
+  static int handler_stack_index_;
+  static pthread_mutex_t handler_stack_mutex_;
+
+  // The minidump generator.
+  MinidumpGenerator minidump_generator_;
+
+  // disallow copy ctor and operator=
+  explicit ExceptionHandler(const ExceptionHandler &);
+  void operator=(const ExceptionHandler &);
+};
+
+}  // namespace google_breakpad
+
+#endif  // CLIENT_SOLARIS_HANDLER_EXCEPTION_HANDLER_H__
diff --git a/src/client/solaris/handler/exception_handler_test.cc b/src/client/solaris/handler/exception_handler_test.cc
new file mode 100644
index 00000000..6bb8e18d
--- /dev/null
+++ b/src/client/solaris/handler/exception_handler_test.cc
@@ -0,0 +1,119 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: Alfred Peng
+
+#include <pthread.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "client/solaris/handler/exception_handler.h"
+#include "client/solaris/handler/solaris_lwp.h"
+
+using namespace google_breakpad;
+
+// Thread use this to see if it should stop working.
+static bool should_exit = false;
+
+static int foo2(int arg) {
+  // Stack variable, used for debugging stack dumps.
+  int c = 0xcccccccc;
+  fprintf(stderr, "Thread trying to crash: %x\n", getpid());
+  c = *reinterpret_cast<int *>(0x5);
+  return c;
+}
+
+static int foo(int arg) {
+  // Stack variable, used for debugging stack dumps.
+  int b = 0xbbbbbbbb;
+  b = foo2(b);
+  return b;
+}
+
+static void *thread_crash(void *) {
+  // Stack variable, used for debugging stack dumps.
+  int a = 0xaaaaaaaa;
+  sleep(3);
+  a = foo(a);
+  printf("%x\n", a);
+  return NULL;
+}
+
+static void *thread_main(void *) {
+  while (!should_exit)
+    sleep(1);
+  return NULL;
+}
+
+static void CreateCrashThread() {
+  pthread_t h;
+  pthread_create(&h, NULL, thread_crash, NULL);
+  pthread_detach(h);
+}
+
+// Create working threads.
+static void CreateThread(int num) {
+  pthread_t h;
+  for (int i = 0; i < num; ++i) {
+    pthread_create(&h, NULL, thread_main, NULL);
+    pthread_detach(h);
+  }
+}
+
+// Callback when minidump written.
+static bool MinidumpCallback(const char *dump_path,
+                             const char *minidump_id,
+                             void *context,
+                             bool succeeded) {
+  int index = reinterpret_cast<int>(context);
+  if (index == 0) {
+    should_exit = true;
+    return true;
+  }
+  // Don't process it.
+  return false;
+}
+
+int main(int argc, char *argv[]) {
+  int handler_index = 1;
+  ExceptionHandler handler_ignore(".", NULL, MinidumpCallback,
+                                  (void*)handler_index, true);
+  CreateCrashThread();
+  CreateThread(10);
+
+  while (true)
+    sleep(20);
+  should_exit = true;
+
+  return 0;
+}
diff --git a/src/client/solaris/handler/minidump_generator.cc b/src/client/solaris/handler/minidump_generator.cc
new file mode 100644
index 00000000..bcb9d88b
--- /dev/null
+++ b/src/client/solaris/handler/minidump_generator.cc
@@ -0,0 +1,486 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: Alfred Peng
+
+#include <fcntl.h>
+#include <pthread.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>
+#include <ctime>
+
+#include "client/solaris/handler/minidump_generator.h"
+#include "client/minidump_file_writer-inl.h"
+#include "common/solaris/file_id.h"
+
+namespace google_breakpad {
+
+MinidumpGenerator::MinidumpGenerator()
+    : requester_pid_(0),
+      signo_(0),
+      lwp_lister_(NULL) {
+}
+
+MinidumpGenerator::~MinidumpGenerator() {
+}
+
+bool MinidumpGenerator::WriteLwpStack(uintptr_t last_esp,
+                                      UntypedMDRVA *memory,
+                                      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) {
+      if (!memory->Allocate(size))
+        return false;
+      memory->Copy(reinterpret_cast<void *>(last_esp), size);
+      loc->start_of_memory_range = last_esp;
+      loc->memory = memory->location();
+    }
+    return true;
+  }
+  return false;
+}
+
+bool MinidumpGenerator::WriteContext(MDRawContextX86 *context, prgregset_t regs,
+                                     prfpregset_t *fp_regs) {
+  if (!context || !regs)
+    return false;
+
+  context->context_flags = MD_CONTEXT_X86_FULL;
+
+  context->cs = regs[CS];
+  context->ds = regs[DS];
+  context->es = regs[ES];
+  context->fs = regs[FS];
+  context->gs = regs[GS];
+  context->ss = regs[SS];
+  context->edi = regs[EDI];
+  context->esi = regs[ESI];
+  context->ebx = regs[EBX];
+  context->edx = regs[EDX];
+  context->ecx = regs[ECX];
+  context->eax = regs[EAX];
+  context->ebp = regs[EBP];
+  context->eip = regs[EIP];
+  context->esp = regs[UESP];
+  context->eflags = regs[EFL];
+
+  return true;
+}
+
+bool MinidumpGenerator::WriteLwpStream(lwpstatus_t *lsp, MDRawThread *lwp) {
+  prfpregset_t fp_regs = lsp->pr_fpreg;
+  prgregset_t *gregs = &(lsp->pr_reg);
+  UntypedMDRVA memory(&writer_);
+  if (!WriteLwpStack((*gregs)[UESP],
+                     &memory,
+                     &lwp->stack))
+    return false;
+
+  // Write context
+  TypedMDRVA<MDRawContextX86> context(&writer_);
+  if (!context.Allocate())
+    return false;
+  lwp->thread_id = lwp_lister_->getpid();
+  lwp->thread_context = context.location();
+  memset(context.get(), 0, sizeof(MDRawContextX86));
+  return WriteContext(context.get(), (int *)gregs, &fp_regs);
+}
+
+bool MinidumpGenerator::WriteCPUInformation(MDRawSystemInfo *sys_info) {
+  struct utsname uts;
+  char *major, *minor, *build;
+
+  sys_info->number_of_processors = sysconf(_SC_NPROCESSORS_CONF);
+  sys_info->processor_architecture = MD_CPU_ARCHITECTURE_UNKNOWN;
+  if (uname(&uts) != -1) {
+    // Match "i86pc" as X86 architecture.
+    if (strcmp(uts.machine, "i86pc") == 0)
+      sys_info->processor_architecture = MD_CPU_ARCHITECTURE_X86;
+    else if (strcmp(uts.machine, "sun4u") == 0)
+      sys_info->processor_architecture = MD_CPU_ARCHITECTURE_SPARC;
+  }
+
+  major = uts.release;
+  minor = strchr(major, '.');
+  *minor = '\0';
+  ++minor;
+  sys_info->major_version = atoi(major);
+  sys_info->minor_version = atoi(minor);
+
+  build = strchr(uts.version, '_');
+  ++build;
+  sys_info->build_number = atoi(build);
+  
+  return true;
+}
+
+bool MinidumpGenerator::WriteOSInformation(MDRawSystemInfo *sys_info) {
+  sys_info->platform_id = MD_OS_SOLARIS;
+
+  struct utsname uts;
+  if (uname(&uts) != -1) {
+    char os_version[512];
+    size_t space_left = sizeof(os_version);
+    memset(os_version, 0, space_left);
+    const char *os_info_table[] = {
+      uts.sysname,
+      uts.release,
+      uts.version,
+      uts.machine,
+      "OpenSolaris",
+      NULL
+    };
+    for (const char **cur_os_info = os_info_table;
+         *cur_os_info != NULL;
+         ++cur_os_info) {
+      if (cur_os_info != os_info_table && space_left > 1) {
+        strcat(os_version, " ");
+        --space_left;
+      }
+      if (space_left > strlen(*cur_os_info)) {
+        strcat(os_version, *cur_os_info);
+        space_left -= strlen(*cur_os_info);
+      } else {
+        break;
+      }
+    }
+
+    MDLocationDescriptor location;
+    if (!writer_.WriteString(os_version, 0, &location))
+      return false;
+    sys_info->csd_version_rva = location.rva;
+  }
+  return true;
+}
+
+// Callback context for get writting lwp information.
+struct LwpInfoCallbackCtx {
+  MinidumpGenerator *generator;
+  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.
+  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 (success) {
+      callback_context->list->CopyIndexAfterObject(
+          callback_context->lwp_index++,
+          &lwp, sizeof(MDRawThread));
+    }
+  }
+
+  return success;
+}
+
+bool MinidumpGenerator::WriteLwpListStream(MDRawDirectory *dir) {
+  // Get the lwp information.
+  int lwp_count = lwp_lister_->GetLwpCount();
+  if (lwp_count < 0)
+    return false;
+  TypedMDRVA<MDRawThreadList> list(&writer_);
+  if (!list.AllocateObjectAndArray(lwp_count, sizeof(MDRawThread)))
+    return false;
+  dir->stream_type = MD_THREAD_LIST_STREAM;
+  dir->location = list.location();
+  list.get()->number_of_threads = lwp_count;
+
+  LwpInfoCallbackCtx context;
+  context.generator = this;
+  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);
+  return written == lwp_count;
+}
+
+bool MinidumpGenerator::WriteCVRecord(MDRawModule *module,
+                                      const char *module_path) {
+  TypedMDRVA<MDCVInfoPDB70> cv(&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);
+  if (!cv.AllocateObjectAndArray(module_name_length + 1, sizeof(u_int8_t)))
+    return false;
+  if (!cv.CopyIndexAfterObject(0, const_cast<char *>(module_name),
+                               module_name_length)) {
+    return false;
+  }
+
+  module->cv_record = cv.location();
+  MDCVInfoPDB70 *cv_ptr = cv.get();
+  memset(cv_ptr, 0, sizeof(MDCVInfoPDB70));
+  cv_ptr->cv_signature = MD_CVINFOPDB70_SIGNATURE;
+  cv_ptr->age = 0;
+
+  // Get the module identifier
+  FileID file_id(path);
+  unsigned char identifier[16];
+
+  if (file_id.ElfFileIdentifier(identifier)) {
+    cv_ptr->signature.data1 = (uint32_t)identifier[0] << 24 |
+      (uint32_t)identifier[1] << 16 | (uint32_t)identifier[2] << 8 |
+      (uint32_t)identifier[3];
+    cv_ptr->signature.data2 = (uint32_t)identifier[4] << 8 | identifier[5];
+    cv_ptr->signature.data3 = (uint32_t)identifier[6] << 8 | identifier[7];
+    cv_ptr->signature.data4[0] = identifier[8];
+    cv_ptr->signature.data4[1] = identifier[9];
+    cv_ptr->signature.data4[2] = identifier[10];
+    cv_ptr->signature.data4[3] = identifier[11];
+    cv_ptr->signature.data4[4] = identifier[12];
+    cv_ptr->signature.data4[5] = identifier[13];
+    cv_ptr->signature.data4[6] = identifier[14];
+    cv_ptr->signature.data4[7] = identifier[15];
+  }
+  return true;
+}
+
+struct ModuleInfoCallbackCtx {
+  MinidumpGenerator *generator;
+  MinidumpFileWriter *minidump_writer;
+  TypedMDRVA<MDRawModuleList> *list;
+  int module_index;
+};
+
+bool ModuleInfoCallback(const ModuleInfo &module_info, void *context) {
+  ModuleInfoCallbackCtx *callback_context =
+    static_cast<ModuleInfoCallbackCtx *>(context);
+  // Skip those modules without name, or those that are not modules.
+  if (strlen(module_info.name) == 0)
+    return true;
+
+  MDRawModule module;
+  memset(&module, 0, sizeof(module));
+  MDLocationDescriptor loc;
+  if (!callback_context->minidump_writer->WriteString(module_info.name,
+                                                      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))
+    return false;
+
+  callback_context->list->CopyIndexAfterObject(
+      callback_context->module_index++, &module, MD_MODULE_SIZE);
+  return true;
+}
+
+bool MinidumpGenerator::WriteModuleListStream(MDRawDirectory *dir) {
+  TypedMDRVA<MDRawModuleList> list(&writer_);
+  int module_count = lwp_lister_->GetModuleCount();
+
+  if (module_count <= 0 ||
+      !list.AllocateObjectAndArray(module_count, MD_MODULE_SIZE)) {
+    return false;
+  }
+
+  dir->stream_type = MD_MODULE_LIST_STREAM;
+  dir->location = list.location();
+  list.get()->number_of_modules = module_count;
+  ModuleInfoCallbackCtx context;
+  context.generator = this;
+  context.minidump_writer = &writer_;
+  context.list = &list;
+  context.module_index = 0;
+  CallbackParam<ModuleCallback> callback(ModuleInfoCallback, &context);
+  return lwp_lister_->ListModules(&callback) == module_count;
+}
+
+bool MinidumpGenerator::WriteSystemInfoStream(MDRawDirectory *dir) {
+  TypedMDRVA<MDRawSystemInfo> sys_info(&writer_);
+
+  if (!sys_info.Allocate())
+    return false;
+
+  dir->stream_type = MD_SYSTEM_INFO_STREAM;
+  dir->location = sys_info.location();
+
+  return WriteCPUInformation(sys_info.get()) &&
+         WriteOSInformation(sys_info.get());
+}
+
+bool MinidumpGenerator::WriteExceptionStream(MDRawDirectory *dir) {
+  ucontext_t uc;
+  prgregset_t *gregs;
+  prfpregset_t fp_regs;
+
+  if (getcontext(&uc) != 0)
+    return false;
+
+  TypedMDRVA<MDRawExceptionStream> exception(&writer_);
+  if (!exception.Allocate())
+    return false;
+
+  dir->stream_type = MD_EXCEPTION_STREAM;
+  dir->location = exception.location();
+  exception.get()->thread_id = requester_pid_;
+  exception.get()->exception_record.exception_code = signo_;
+  exception.get()->exception_record.exception_flags = 0;
+
+  gregs = &(uc.uc_mcontext.gregs);
+  fp_regs = uc.uc_mcontext.fpregs;
+  exception.get()->exception_record.exception_address = (*gregs)[EIP];
+
+  // Write context of the exception.
+  TypedMDRVA<MDRawContextX86> context(&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);
+}
+
+bool MinidumpGenerator::WriteMiscInfoStream(MDRawDirectory *dir) {
+  TypedMDRVA<MDRawMiscInfo> info(&writer_);
+
+  if (!info.Allocate())
+    return false;
+
+  dir->stream_type = MD_MISC_INFO_STREAM;
+  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_;
+
+  return true;
+}
+
+bool MinidumpGenerator::WriteBreakpadInfoStream(MDRawDirectory *dir) {
+  TypedMDRVA<MDRawBreakpadInfo> info(&writer_);
+
+  if (!info.Allocate())
+    return false;
+
+  dir->stream_type = MD_BREAKPAD_INFO_STREAM;
+  dir->location = info.location();
+
+  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_;
+  return true;
+}
+
+class AutoLwpResumer {
+ public:
+  AutoLwpResumer(SolarisLwp *lwp) : lwp_(lwp) {}
+  ~AutoLwpResumer() { lwp_->ControlAllLwps(false); }
+ private:
+  SolarisLwp *lwp_;
+};
+
+// Will call each writer function in the writers table.
+void* MinidumpGenerator::Write() {
+  // Function table to writer a full minidump.
+  const WriteStreamFN writers[] = {
+    &MinidumpGenerator::WriteLwpListStream,
+    &MinidumpGenerator::WriteModuleListStream,
+    &MinidumpGenerator::WriteSystemInfoStream,
+    &MinidumpGenerator::WriteExceptionStream,
+    &MinidumpGenerator::WriteMiscInfoStream,
+    &MinidumpGenerator::WriteBreakpadInfoStream,
+  };
+
+  if (!lwp_lister_->ControlAllLwps(true))
+    return NULL;
+
+  AutoLwpResumer lwpResumer(lwp_lister_);
+
+  TypedMDRVA<MDRawHeader> header(&writer_);
+  TypedMDRVA<MDRawDirectory> dir(&writer_);
+  if (!header.Allocate())
+    return 0;
+
+  int writer_count = sizeof(writers) / sizeof(writers[0]);
+  // Need directory space for all writers.
+  if (!dir.AllocateArray(writer_count))
+    return 0;
+  header.get()->signature = MD_HEADER_SIGNATURE;
+  header.get()->version = MD_HEADER_VERSION;
+  header.get()->time_date_stamp = time(NULL);
+  header.get()->stream_count = writer_count;
+  header.get()->stream_directory_rva = dir.position();
+
+  int dir_index = 0;
+  MDRawDirectory local_dir;
+  for (int i = 0; i < writer_count; ++i) {
+    if ((this->*writers[i])(&local_dir))
+      dir.CopyIndex(dir_index++, &local_dir);
+  }
+
+  return 0;
+}
+
+// Write minidump into file.
+// It runs in a different thread from the crashing thread.
+bool MinidumpGenerator::WriteMinidumpToFile(const char *file_pathname,
+                                            int signo) {
+  assert(file_pathname != NULL);
+  assert(stack_ != NULL);
+
+  if (file_pathname == NULL)
+    return false;
+
+  if (writer_.Open(file_pathname)) {
+    SolarisLwp lwp_lister(getpid());
+    lwp_lister_ = &lwp_lister;
+    requester_pid_ = getpid();
+    signo_ = signo;
+    if (Write())
+      return true;
+  }
+
+  return false;
+}
+
+}  // namespace google_breakpad
diff --git a/src/client/solaris/handler/minidump_generator.h b/src/client/solaris/handler/minidump_generator.h
new file mode 100644
index 00000000..36b92716
--- /dev/null
+++ b/src/client/solaris/handler/minidump_generator.h
@@ -0,0 +1,113 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: Alfred Peng
+
+#ifndef CLIENT_SOLARIS_HANDLER_MINIDUMP_GENERATOR_H__
+#define CLIENT_SOLARIS_HANDLER_MINIDUMP_GENERATOR_H__
+
+#include "client/minidump_file_writer.h"
+#include "client/solaris/handler/solaris_lwp.h"
+#include "google_breakpad/common/breakpad_types.h"
+#include "google_breakpad/common/minidump_format.h"
+
+namespace google_breakpad {
+
+//
+// MinidumpGenerator
+//
+// A minidump generator should be created before any exception happen.
+//
+class MinidumpGenerator {
+  // Callback run for writing lwp information in the process.
+  friend bool LwpInformationCallback(lwpstatus_t *lsp, void *context);
+
+  // Callback run for writing module information in the process.
+  friend bool ModuleInfoCallback(const ModuleInfo &module_info, void *context);
+
+ public:
+  MinidumpGenerator();
+
+  ~MinidumpGenerator();
+
+  // Write minidump.
+  bool WriteMinidumpToFile(const char *file_pathname,
+                           int signo);
+
+ private:
+  // 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.
+  bool WriteContext(MDRawContextX86 *context, prgregset_t regs,
+                    prfpregset_t *fp_regs);
+
+  // 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
+
+#endif   // CLIENT_SOLARIS_HANDLER_MINIDUMP_GENERATOR_H_
diff --git a/src/client/solaris/handler/minidump_test.cc b/src/client/solaris/handler/minidump_test.cc
new file mode 100644
index 00000000..03b7148c
--- /dev/null
+++ b/src/client/solaris/handler/minidump_test.cc
@@ -0,0 +1,75 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: Alfred Peng
+
+#include <pthread.h>
+#include <unistd.h>
+
+#include "client/minidump_file_writer.h"
+#include "client/solaris/handler/minidump_generator.h"
+
+using std::string;
+using google_breakpad::MinidumpGenerator;
+
+static bool doneWritingReport = false;
+
+static void *Reporter(void *) {
+  char buffer[PATH_MAX];
+  MinidumpGenerator md;
+
+  // Write it to the desktop
+  snprintf(buffer, sizeof(buffer), "./minidump_test.out");
+  fprintf(stdout, "Writing %s\n", buffer);
+
+  md.WriteMinidumpToFile(buffer, 0);
+  doneWritingReport = true;
+
+  return NULL;
+}
+
+static void SleepyFunction() {
+  while (!doneWritingReport) {
+    usleep(100);
+  }
+}
+
+int main(int argc, char * const argv[]) {
+  pthread_t reporter_thread;
+
+  if (pthread_create(&reporter_thread, NULL, Reporter, NULL) == 0) {
+    pthread_detach(reporter_thread);
+  } else {
+    perror("pthread_create");
+  }
+
+  SleepyFunction();
+
+  return 0;
+}
diff --git a/src/client/solaris/handler/solaris_lwp.cc b/src/client/solaris/handler/solaris_lwp.cc
new file mode 100644
index 00000000..763e1977
--- /dev/null
+++ b/src/client/solaris/handler/solaris_lwp.cc
@@ -0,0 +1,327 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: Alfred Peng
+
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <functional>
+
+#include "client/solaris/handler/solaris_lwp.h"
+#include "common/solaris/message_output.h"
+
+using namespace google_breakpad;
+
+// This unamed namespace contains helper function.
+namespace {
+
+uintptr_t stack_base_address = 0;
+static const int HEADER_MAX = 2000;
+static const int MAP_MAX = 1000;
+
+// Convert from string to int.
+static bool LocalAtoi(char *s, int *r) {
+  assert(s != NULL);
+  assert(r != NULL);
+  char *endptr = NULL;
+  int ret = strtol(s, &endptr, 10);
+  if (endptr == s)
+    return false;
+  *r = ret;
+  return true;
+}
+
+// Callback invoked for each mapped module.
+// It use 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);
+  if ((module_info.start_addr > 0) &&
+      (addr >= module_info.start_addr) &&
+      (addr <= module_info.start_addr + module_info.size)) {
+    stack_base_address = module_info.start_addr + module_info.size;
+    return false;
+  }
+
+  return true;
+}
+
+static int IterateLwpAll(int pid,
+                         CallbackParam<LwpidCallback> *callback_param) {
+  char lwp_path[40];
+  DIR *dir;
+  int count = 0;
+
+  snprintf(lwp_path, sizeof (lwp_path), "/proc/%d/lwp", (int)pid);
+  if ((dir = opendir(lwp_path)) == NULL)
+    return -1;
+
+  struct dirent *entry = NULL;
+  while ((entry = readdir(dir)) != NULL) {
+    if ((strcmp(entry->d_name, ".") != 0) &&
+        (strcmp(entry->d_name, "..") != 0)) {
+      int lwpid = 0;
+      int last_pid = 0;
+      if (LocalAtoi(entry->d_name, &lwpid) && last_pid != lwpid) {
+        last_pid = lwpid;
+        ++count;
+        if (callback_param &&
+            !(callback_param->call_back)(lwpid, callback_param->context)) {
+          break;
+        }
+      }
+    }
+  }
+
+  closedir(dir);
+  return count;
+}
+
+class AutoCloser {
+ public:
+  AutoCloser(int fd) : fd_(fd) {}
+  ~AutoCloser() { if (fd_) close(fd_); }
+ private:
+  int fd_;
+};
+
+// Control the execution of the lwp.
+// Suspend/Resume lwp based on the value of context.
+static bool ControlLwp(int lwpid, void *context) {
+  // The current thread is the one to handle the crash. Ignore it.
+  if (lwpid != pthread_self()) {
+    int ctlfd;
+    char procname[PATH_MAX];
+    bool suspend = *(bool *)context;
+
+    // Open the /proc/$pid/lwp/$lwpid/lwpctl files
+    snprintf(procname, sizeof (procname), "/proc/self/lwp/%d/lwpctl", lwpid);
+
+    if ((ctlfd = open(procname, O_WRONLY|O_EXCL)) < 0) {
+      print_message2(2, "failed to open %s in ControlLwp\n", procname);
+      return false;
+    }
+
+    AutoCloser autocloser(ctlfd);
+
+    long ctl[2];
+    ctl[0] = suspend ? PCSTOP : PCRUN;
+    ctl[1] = 0;
+    if (write(ctlfd, ctl, sizeof (ctl)) != sizeof (ctl)) {
+      print_message2(2, "failed in lwp %d\n", lwpid);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/*
+ * Utility function to read the contents of a file that contains a
+ * prheader_t at the start (/proc/$pid/lstatus or /proc/$pid/lpsinfo).
+ * Return true on success.
+ */
+static bool read_lfile(int pid, const char *lname, prheader_t *lhp) {
+  char lpath[PATH_MAX];
+  struct stat statb;
+  int fd;
+  size_t size;
+
+  snprintf(lpath, sizeof (lpath), "/proc/%d/%s", pid, lname);
+  if ((fd = open(lpath, O_RDONLY)) < 0) {
+    print_message2(2, "failed to open %s in read_lfile\n", lpath);
+    return false;
+  }
+
+  AutoCloser autocloser(fd);
+
+  if (fstat(fd, &statb) != 0)
+    return false;
+
+  size = statb.st_size;
+  if ((size / sizeof (prheader_t)) + 32 > HEADER_MAX) {
+    print_message1(2, "map size overflow\n");
+    return false;
+  }
+
+  if (pread(fd, lhp, size, 0) <= sizeof (prheader_t))
+    return false;
+
+  return true;
+}
+
+}  // namespace
+
+namespace google_breakpad {
+
+SolarisLwp::SolarisLwp(int pid) : pid_(pid) {
+}
+
+SolarisLwp::~SolarisLwp() {
+}
+
+int SolarisLwp::ControlAllLwps(bool suspend) {
+  CallbackParam<LwpidCallback> callback_param(ControlLwp, &suspend);
+  return IterateLwpAll(pid_, &callback_param);
+}
+
+int SolarisLwp::GetLwpCount() const {
+  return IterateLwpAll(pid_, NULL);
+}
+
+int SolarisLwp::Lwp_iter_all(int pid,
+                             CallbackParam<LwpCallback> *callback_param) const {
+  lwpstatus_t *Lsp;
+  lwpstatus_t *sp;
+  prheader_t lphp[HEADER_MAX];
+  prheader_t lhp[HEADER_MAX];
+  prheader_t *Lphp = lphp;
+  prheader_t *Lhp = lhp;
+  lwpsinfo_t *Lpsp;
+  long nstat;
+  long ninfo;
+  int rv;
+
+  /*
+   * The /proc/pid/lstatus file has the array of lwpstatus_t's and the
+   * /proc/pid/lpsinfo file has the array of lwpsinfo_t's.
+   */
+  if (read_lfile(pid, "lstatus", Lhp) == NULL)
+    return -1;
+  if (read_lfile(pid, "lpsinfo", Lphp) == NULL) {
+    return -1;
+  }
+
+  Lsp = (lwpstatus_t *)(uintptr_t)(Lhp + 1);
+  Lpsp = (lwpsinfo_t *)(uintptr_t)(Lphp + 1);
+
+  for (ninfo = Lphp->pr_nent; ninfo != 0; --ninfo) {
+    if (Lpsp->pr_sname != 'Z') {
+      sp = Lsp;
+      Lsp = (lwpstatus_t *)((uintptr_t)Lsp + Lhp->pr_entsize);
+    } else {
+      sp = NULL;
+    }
+    if (callback_param &&
+        !(rv = (callback_param->call_back)(sp, callback_param->context)))
+      break;
+    Lpsp = (lwpsinfo_t *)((uintptr_t)Lpsp + Lphp->pr_entsize);
+  }
+
+  return rv;
+}
+
+uintptr_t SolarisLwp::GetLwpStackBottom(uintptr_t current_esp) const {
+  CallbackParam<ModuleCallback> callback_param(AddressNotInModuleCallback,
+                                               (void *)current_esp);
+  ListModules(&callback_param);
+  return stack_base_address;
+}
+
+int SolarisLwp::GetModuleCount() const {
+  return ListModules(NULL);
+}
+
+int SolarisLwp::ListModules(
+    CallbackParam<ModuleCallback> *callback_param) const {
+  const char *maps_path = "/proc/self/map";
+  struct stat status;
+  int fd = 0, num;
+  prmap_t map_array[MAP_MAX];
+  prmap_t *maps = map_array;
+  size_t size;
+
+  if ((fd = open(maps_path, O_RDONLY)) == -1) {
+    print_message2(2, "failed to open %s in ListModules\n", maps_path);
+    return -1;
+  }
+
+  AutoCloser autocloser(fd);
+
+  if (fstat(fd, &status))
+    return -1;
+
+  /*
+   * Determine number of mappings.
+   */
+  size = status.st_size;
+  if ((num = (int)(size / sizeof (prmap_t))) > MAP_MAX) {
+    print_message1(2, "map size overflow\n");
+    return -1;
+  }
+
+  if (!callback_param)
+    return num;           // return the Module count
+
+  if (read(fd, (void *)maps, size) < 0) {
+    print_message2(2, "failed to read %d\n", fd);
+    return -1;
+  }
+
+  prmap_t *_maps;
+  int _num;
+
+  /*
+   * Scan each mapping - note it is assummed that the mappings are
+   * presented in order.  We fill holes between mappings.  On intel
+   * the last mapping is usually the data segment of ld.so.1, after
+   * this comes a red zone into which non-fixed mapping won't get
+   * place.  Thus we can simply bail from the loop after seeing the
+   * last mapping.
+   */
+  for (_num = 0, _maps = maps; _num < num; ++_num, ++_maps) {
+    ModuleInfo module;
+    char *name = _maps->pr_mapname;
+
+    memset(&module, 0, sizeof (module));
+    module.start_addr = _maps->pr_vaddr;
+    module.size = _maps->pr_size;
+    if (name && (strcmp(name, "a.out") != 0))
+      strncpy(module.name, name, sizeof (module.name) - 1);
+    if (callback_param &&
+        (!callback_param->call_back(module, callback_param->context))) {
+      break;
+    }
+  }
+
+  return num;
+}
+
+}  // namespace google_breakpad
diff --git a/src/client/solaris/handler/solaris_lwp.h b/src/client/solaris/handler/solaris_lwp.h
new file mode 100644
index 00000000..d859111b
--- /dev/null
+++ b/src/client/solaris/handler/solaris_lwp.h
@@ -0,0 +1,144 @@
+// Copyright (c) 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: Alfred Peng
+
+#ifndef CLIENT_SOLARIS_HANDLER_SOLARIS_LWP_H__
+#define CLIENT_SOLARIS_HANDLER_SOLARIS_LWP_H__
+
+#include <signal.h>
+#include <stdint.h>
+#include <sys/user.h>
+
+#ifndef _KERNEL
+#define _KERNEL
+#define MUST_UNDEF_KERNEL
+#endif  // _KERNEL
+#include <sys/procfs.h>
+#ifdef MUST_UNDEF_KERNEL
+#undef _KERNEL
+#undef MUST_UNDEF_KERNEL
+#endif  // MUST_UNDEF_KERNEL
+
+namespace google_breakpad {
+
+// Max module path name length.
+static const int kMaxModuleNameLength = 256;
+
+// Holding infomaton about a module in the process.
+struct ModuleInfo {
+  char name[kMaxModuleNameLength];
+  uintptr_t start_addr;
+  int size;
+};
+
+// A callback to run when getting a lwp in the process.
+// Return true will go on to the next lwp while return false will stop the
+// iteration.
+typedef bool (*LwpCallback)(lwpstatus_t* lsp, void *context); 
+
+// A callback to run when a new module is found in the process.
+// Return true will go on to the next module while return false will stop the
+// iteration.
+typedef bool (*ModuleCallback)(const ModuleInfo &module_info, void *context);
+
+// A callback to run when getting a lwpid in the process.
+// Return true will go on to the next lwp while return false will stop the
+// iteration.
+typedef bool (*LwpidCallback)(int lwpid, void *context);
+
+// Holding the callback information.
+template<class CallbackFunc>
+struct CallbackParam {
+  // Callback function address.
+  CallbackFunc call_back;
+  // Callback context;
+  void *context;
+
+  CallbackParam() : call_back(NULL), context(NULL) {
+  }
+
+  CallbackParam(CallbackFunc func, void *func_context) :
+    call_back(func), context(func_context) {
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+//
+// SolarisLwp
+//
+// Provides handy support for operation on Solaris lwps.
+// It uses proc file system to get lwp information.
+//
+// TODO(Alfred): Currently it only supports x86. Add SPARC support.
+//
+class SolarisLwp {
+ public:
+  // Create a SolarisLwp instance to list all the lwps in a process.
+  explicit SolarisLwp(int pid);
+  ~SolarisLwp();
+
+  int getpid() const { return this->pid_; }
+
+  // Control all the lwps in the process.
+  // Return the number of suspended/resumed lwps in the process.
+  // Return -1 means failed to control lwps.
+  int ControlAllLwps(bool suspend);
+
+  // Get the count of lwps in the process.
+  // Return -1 means error.
+  int GetLwpCount() const;
+
+  // Iterate the lwps of process.
+  // Whenever there is a lwp found, the callback will be invoked to process
+  // the information.
+  // Return the callback return value or -1 on error.
+  int Lwp_iter_all(int pid, CallbackParam<LwpCallback> *callback_param) const;
+
+  // Get the module count of the current process.
+  int GetModuleCount() const;
+
+  // Get the mapped modules in the address space.
+  // Whenever a module is found, the callback will be invoked to process the
+  // information.
+  // Return how may modules are found.
+  int ListModules(CallbackParam<ModuleCallback> *callback_param) const;
+
+  // Get the bottom of the stack from esp.
+  uintptr_t GetLwpStackBottom(uintptr_t current_esp) const;
+
+ private:
+  // The pid of the process we are listing lwps.
+  int pid_;
+};
+
+}  // namespace google_breakpad
+
+#endif  // CLIENT_SOLARIS_HANDLER_SOLARIS_LWP_H__