Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-15 06:15:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 391359. update to breakpad revision 198. r=ted.mielczarek.

Browse Source
This commit is contained in:
alfred.peng@sun.com 2007-08-09 19:56:15 -07:00
parent ad74d94b42
commit ce76fb317c
19 changed files with 2247 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
toolkit/crashreporter/google-breakpad/src/client/minidump_file_writer.cc
View File

@ -53,7 +53,7 @@ MinidumpFileWriter::~MinidumpFileWriter() {
bool MinidumpFileWriter::Open(const char *path) {
assert(file_ == -1);
file_ = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
file_ = open(path, O_WRONLY | O_CREAT | O_EXCL, 0600);
return file_ != -1;
}

292
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/exception_handler.cc Normal file
View File

@ -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

213
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/exception_handler.h Normal file
View File

@ -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__

119
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/exception_handler_test.cc Normal file
View File

@ -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;
}

486
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/minidump_generator.cc Normal file
View File

@ -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

113
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/minidump_generator.h Normal file
View File

@ -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_

75
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/minidump_test.cc Normal file
View File

@ -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;
}

327
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/solaris_lwp.cc Normal file
View File

@ -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

144
toolkit/crashreporter/google-breakpad/src/client/solaris/handler/solaris_lwp.h Normal file
View File

@ -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__

4
toolkit/crashreporter/google-breakpad/src/client/windows/handler/exception_handler.cc
View File

@ -452,9 +452,9 @@ bool ExceptionHandler::WriteMinidumpWithException(
if (minidump_write_dump_) {
HANDLE dump_file = CreateFile(next_minidump_path_c_,
GENERIC_WRITE,
FILE_SHARE_WRITE,
0, // no sharing
NULL,
CREATE_ALWAYS,
CREATE_NEW, // fail if exists
FILE_ATTRIBUTE_NORMAL,
NULL);
if (dump_file != INVALID_HANDLE_VALUE) {

198
toolkit/crashreporter/google-breakpad/src/common/solaris/file_id.cc Normal file
View File

@ -0,0 +1,198 @@
// 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.
// file_id.cc: Return a unique identifier for a file
//
// See file_id.h for documentation
//
// Author: Alfred Peng
#include <elf.h>
#include <fcntl.h>
#include <gelf.h>
#include <gnutls/openssl.h>
#include <link.h>
#include <sys/mman.h>
#include <sys/ksyms.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <cassert>
#include <cstdio>
#include "common/solaris/file_id.h"
#include "common/solaris/message_output.h"
#include "google_breakpad/common/minidump_format.h"
namespace google_breakpad {
class AutoElfEnder {
public:
AutoElfEnder(Elf *elf) : elf_(elf) {}
~AutoElfEnder() { if (elf_) elf_end(elf_); }
private:
Elf *elf_;
};
// Find the text section in elf object file.
// Return the section start address and the size.
static bool FindElfTextSection(int fd, const void *elf_base,
const void **text_start,
int *text_size) {
assert(text_start);
assert(text_size);
*text_start = NULL;
*text_size = 0;
if (elf_version(EV_CURRENT) == EV_NONE) {
print_message2(2, "elf_version() failed: %s\n", elf_errmsg(0));
return false;
}
GElf_Ehdr elf_header;
lseek(fd, 0L, 0);
Elf *elf = elf_begin(fd, ELF_C_READ, NULL);
AutoElfEnder elfEnder(elf);
if (gelf_getehdr(elf, &elf_header) == (GElf_Ehdr *)NULL) {
print_message2(2, "failed to read elf header: %s\n", elf_errmsg(-1));
return false;
}
if (elf_header.e_ident[EI_MAG0] != ELFMAG0 ||
elf_header.e_ident[EI_MAG1] != ELFMAG1 ||
elf_header.e_ident[EI_MAG2] != ELFMAG2 ||
elf_header.e_ident[EI_MAG3] != ELFMAG3) {
print_message1(2, "header magic doesn't match\n");
return false;
}
static const char kTextSectionName[] = ".text";
const GElf_Shdr *text_section = NULL;
Elf_Scn *scn = NULL;
GElf_Shdr shdr;
while ((scn = elf_nextscn(elf, scn)) != NULL) {
if (gelf_getshdr(scn, &shdr) == (GElf_Shdr *)0) {
print_message2(2, "failed to read section header: %s\n", elf_errmsg(0));
return false;
}
if (shdr.sh_type == SHT_PROGBITS) {
const char *section_name = elf_strptr(elf, elf_header.e_shstrndx,
shdr.sh_name);
if (!section_name) {
print_message2(2, "Section name error: %s\n", elf_errmsg(-1));
continue;
}
if (strcmp(section_name, kTextSectionName) == 0) {
text_section = &shdr;
break;
}
}
}
if (text_section != NULL && text_section->sh_size > 0) {
*text_start = (char *)elf_base + text_section->sh_offset;
*text_size = text_section->sh_size;
return true;
}
return false;
}
FileID::FileID(const char *path) {
strncpy(path_, path, strlen(path));
}
class AutoCloser {
public:
AutoCloser(int fd) : fd_(fd) {}
~AutoCloser() { if (fd_) close(fd_); }
private:
int fd_;
};
bool FileID::ElfFileIdentifier(unsigned char identifier[16]) {
int fd = 0;
if ((fd = open(path_, O_RDONLY)) < 0)
return false;
AutoCloser autocloser(fd);
struct stat st;
if (fstat(fd, &st) != 0 || st.st_size <= 0)
return false;
void *base = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (!base)
return false;
bool success = false;
const void *text_section = NULL;
int text_size = 0;
if (FindElfTextSection(fd, base, &text_section, &text_size)) {
MD5_CTX md5;
MD5_Init(&md5);
MD5_Update(&md5, text_section, text_size);
MD5_Final(identifier, &md5);
success = true;
}
munmap((char *)base, st.st_size);
return success;
}
// static
bool FileID::ConvertIdentifierToString(const unsigned char identifier[16],
char *buffer, int buffer_length) {
if (buffer_length < 34)
return false;
int buffer_idx = 0;
for (int idx = 0; idx < 16; ++idx) {
int hi = (identifier[idx] >> 4) & 0x0F;
int lo = (identifier[idx]) & 0x0F;
buffer[buffer_idx++] = (hi >= 10) ? 'A' + hi - 10 : '0' + hi;
buffer[buffer_idx++] = (lo >= 10) ? 'A' + lo - 10 : '0' + lo;
}
// Add an extra "0" by the end.
buffer[buffer_idx++] = '0';
// NULL terminate
buffer[buffer_idx] = 0;
return true;
}
} // namespace google_breakpad

66
toolkit/crashreporter/google-breakpad/src/common/solaris/file_id.h Normal file
View File

@ -0,0 +1,66 @@
// 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.
// file_id.h: Return a unique identifier for a file
//
// Author: Alfred Peng
#ifndef COMMON_SOLARIS_FILE_ID_H__
#define COMMON_SOLARIS_FILE_ID_H__
#include <limits.h>
namespace google_breakpad {
class FileID {
public:
FileID(const char *path);
~FileID() {};
// Load the identifier for the elf file path specified in the constructor into
// |identifier|. Return false if the identifier could not be created for the
// file.
// The current implementation will return the MD5 hash of the file's bytes.
bool ElfFileIdentifier(unsigned char identifier[16]);
// Convert the |identifier| data to a NULL terminated string. The string will
// be formatted as a MDCVInfoPDB70 struct.
// The |buffer| should be at least 34 bytes long to receive all of the data
// and termination. Shorter buffers will return false.
static bool ConvertIdentifierToString(const unsigned char identifier[16],
char *buffer, int buffer_length);
private:
// Storage for the path specified
char path_[PATH_MAX];
};
} // namespace google_breakpad
#endif // COMMON_SOLARIS_FILE_ID_H__

84
toolkit/crashreporter/google-breakpad/src/common/solaris/guid_creator.cc Normal file
View File

@ -0,0 +1,84 @@
// 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 <cassert>
#include <ctime>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "common/solaris/guid_creator.h"
//
// GUIDGenerator
//
// This class is used to generate random GUID.
// Currently use random number to generate a GUID. This should be OK since
// we don't expect crash to happen very offen.
//
class GUIDGenerator {
public:
GUIDGenerator() {
srandom(time(NULL));
}
bool CreateGUID(GUID *guid) const {
guid->data1 = random();
guid->data2 = (u_int16_t)(random());
guid->data3 = (u_int16_t)(random());
*reinterpret_cast<u_int32_t*>(&guid->data4[0]) = random();
*reinterpret_cast<u_int32_t*>(&guid->data4[4]) = random();
return true;
}
};
// Guid generator.
const GUIDGenerator kGuidGenerator;
bool CreateGUID(GUID *guid) {
return kGuidGenerator.CreateGUID(guid);
};
// Parse guid to string.
bool GUIDToString(const GUID *guid, char *buf, int buf_len) {
// Should allow more space the the max length of GUID.
assert(buf_len > kGUIDStringLength);
int num = snprintf(buf, buf_len, kGUIDFormatString,
guid->data1, guid->data2, guid->data3,
*reinterpret_cast<const u_int32_t *>(&(guid->data4[0])),
*reinterpret_cast<const u_int32_t *>(&(guid->data4[4])));
if (num != kGUIDStringLength)
return false;
buf[num] = '\0';
return true;
}

50
toolkit/crashreporter/google-breakpad/src/common/solaris/guid_creator.h Normal file
View File

@ -0,0 +1,50 @@
// 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 COMMON_SOLARIS_GUID_CREATOR_H__
#define COMMON_SOLARIS_GUID_CREATOR_H__
#include "google_breakpad/common/minidump_format.h"
typedef MDGUID GUID;
// Format string for parsing GUID.
#define kGUIDFormatString "%08x-%04x-%04x-%08x-%08x"
// Length of GUID string. Don't count the ending '\0'.
#define kGUIDStringLength 36
// Create a guid.
bool CreateGUID(GUID *guid);
// Get the string from guid.
bool GUIDToString(const GUID *guid, char *buf, int buf_len);
#endif // COMMON_SOLARIS_GUID_CREATOR_H__

54
toolkit/crashreporter/google-breakpad/src/common/solaris/message_output.h Normal file
View File

@ -0,0 +1,54 @@
// 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 COMMON_SOLARIS_MESSAGE_OUTPUT_H__
#define COMMON_SOLARIS_MESSAGE_OUTPUT_H__
namespace google_breakpad {
const int MESSAGE_MAX = 1000;
// Message output macros.
// snprintf doesn't operate heap on Solaris, while printf and fprintf do.
// Use snprintf here to avoid heap allocation.
#define print_message1(std, message) \
char buffer[MESSAGE_MAX]; \
int len = snprintf(buffer, MESSAGE_MAX, message); \
write(std, buffer, len)
#define print_message2(std, message, para) \
char buffer[MESSAGE_MAX]; \
int len = snprintf(buffer, MESSAGE_MAX, message, para); \
write(std, buffer, len);
} // namespace google_breakpad
#endif // COMMON_SOLARIS_MESSAGE_OUTPUT_H__

1
toolkit/crashreporter/google-breakpad/src/common/string_conversion.h
View File

@ -34,6 +34,7 @@
#include <string>
#include <vector>
#include "google_breakpad/common/breakpad_types.h"
namespace google_breakpad {

7
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/breakpad_types.h
View File

@ -44,6 +44,13 @@
#include <sys/types.h>
#if defined(__SUNPRO_CC) || (defined(__GNUC__) && defined(__sun__))
typedef uint8_t u_int8_t;
typedef uint16_t u_int16_t;
typedef uint32_t u_int32_t;
typedef uint64_t u_int64_t;
#endif
#else /* !_WIN32 */
#include <WTypes.h>

13
toolkit/crashreporter/google-breakpad/src/google_breakpad/common/minidump_format.h
View File

@ -609,6 +609,15 @@ static const size_t MDCVInfoPDB70_minsize = offsetof(MDCVInfoPDB70,
#define MD_CVINFOPDB70_SIGNATURE 0x53445352 /* cvSignature = 'SDSR' */
typedef struct {
u_int32_t data1[2];
u_int32_t data2;
u_int32_t data3;
u_int32_t data4;
u_int32_t data5[3];
u_int8_t extra[2];
} MDCVInfoELF;
/* In addition to the two CodeView record formats above, used for linking
* to external pdb files, it is possible for debugging data to be carried
* directly in the CodeView record itself. These signature values will
@ -990,6 +999,7 @@ typedef enum {
MD_CPU_ARCHITECTURE_AMD64 = 9, /* PROCESSOR_ARCHITECTURE_AMD64 */
MD_CPU_ARCHITECTURE_X86_WIN64 = 10,
/* PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 (WoW64) */
MD_CPU_ARCHITECTURE_SPARC = 0x8001, /* Breakpad-defined value for SPARC */
MD_CPU_ARCHITECTURE_UNKNOWN = 0xffff /* PROCESSOR_ARCHITECTURE_UNKNOWN */
} MDCPUArchitecture;
@ -1004,7 +1014,8 @@ typedef enum {
/* The following values are Breakpad-defined. */
MD_OS_UNIX = 0x8000, /* Generic Unix-ish */
MD_OS_MAC_OS_X = 0x8101, /* Mac OS X/Darwin */
MD_OS_LINUX = 0x8201 /* Linux */
MD_OS_LINUX = 0x8201, /* Linux */
MD_OS_SOLARIS = 0x8202 /* Solaris */
} MDOSPlatform;

5
toolkit/crashreporter/google-breakpad/src/processor/simple_symbol_supplier.cc
View File

@ -110,8 +110,9 @@ SymbolSupplier::SymbolResult SimpleSymbolSupplier::GetSymbolFileAtPath(
// name ends in .pdb, strip the .pdb. Otherwise, add .sym to the non-.pdb
// name.
path.append("/");
string debug_file_extension =
debug_file_name.substr(debug_file_name.size() - 4);
string debug_file_extension;
if (debug_file_name.size() > 4)
debug_file_extension = debug_file_name.substr(debug_file_name.size() - 4);
transform(debug_file_extension.begin(), debug_file_extension.end(),
debug_file_extension.begin(), tolower);
if (debug_file_extension == ".pdb") {