SwitchEmu/breakpad
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/breakpad.git synced 2026-03-25 17:52:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add utilities for processing Linux core dump files.

Browse Source 
This patch is part of a bigger patch that helps merging the breakpad code
with the modified version in Chromium OS.

Specifically, this patch makes the following changes:
1. Add an ElfCoreDump class for processing Linux core dump files, which will
   later be used to implement the core dump to minidump conversion.
2. Add a CrashGenerator class for generating a crash with a core dump file
   for testing the functionalities of ElfCoreDump.
3. Move some utility functions for reading/writing files to file_utils.h.

BUG=455
TEST=Tested the following:
1. Build on 32-bit and 64-bit Linux with gcc 4.4.3 and gcc 4.6.
2. Build on Mac OS X 10.6.8 with gcc 4.2 and clang 3.0 (with latest gmock).
3. All unit tests pass.
Review URL: http://breakpad.appspot.com/337001

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@900 4c0a9323-5329-0410-9bdc-e9ce6186880e
This commit is contained in:
benchan@chromium.org
2012-01-07 02:25:22 +00:00
parent 33f62804fd
commit 07e521c396
11 changed files with 1171 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
src/common/linux/tests/crash_generator.cc Normal file
View File

@@ -0,0 +1,206 @@
// Copyright (c) 2011, 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.
// crash_generator.cc: Implement google_breakpad::CrashGenerator.
// See crash_generator.h for details.
#include "common/linux/tests/crash_generator.h"
#include <pthread.h>
#include <signal.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
#include <string>
#include "common/linux/eintr_wrapper.h"
#include "common/tests/auto_tempdir.h"
#include "common/tests/file_utils.h"
namespace {
struct ThreadData {
pthread_t thread;
pthread_barrier_t* barrier;
pid_t* thread_id_ptr;
};
// Core file size limit set to 1 MB, which is big enough for test purposes.
const rlim_t kCoreSizeLimit = 1024 * 1024;
void *thread_function(void *data) {
ThreadData* thread_data = reinterpret_cast<ThreadData*>(data);
volatile pid_t thread_id = syscall(__NR_gettid);
*(thread_data->thread_id_ptr) = thread_id;
int result = pthread_barrier_wait(thread_data->barrier);
if (result != 0 && result != PTHREAD_BARRIER_SERIAL_THREAD) {
exit(1);
}
while (true) {
pthread_yield();
}
}
} // namespace
namespace google_breakpad {
CrashGenerator::CrashGenerator()
: shared_memory_(NULL),
shared_memory_size_(0) {
}
CrashGenerator::~CrashGenerator() {
UnmapSharedMemory();
}
bool CrashGenerator::HasDefaultCorePattern() const {
char buffer[8];
ssize_t buffer_size = sizeof(buffer);
return ReadFile("/proc/sys/kernel/core_pattern", buffer, &buffer_size) &&
buffer_size == 5 && memcmp(buffer, "core", 4) == 0;
}
std::string CrashGenerator::GetCoreFilePath() const {
return temp_dir_.path() + "/core";
}
pid_t CrashGenerator::GetThreadId(unsigned index) const {
return reinterpret_cast<pid_t*>(shared_memory_)[index];
}
pid_t* CrashGenerator::GetThreadIdPointer(unsigned index) {
return reinterpret_cast<pid_t*>(shared_memory_) + index;
}
bool CrashGenerator::MapSharedMemory(size_t memory_size) {
if (!UnmapSharedMemory())
return false;
void* mapped_memory = mmap(0, memory_size, PROT_READ | PROT_WRITE,
MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (mapped_memory == MAP_FAILED)
return false;
memset(mapped_memory, 0, memory_size);
shared_memory_ = mapped_memory;
shared_memory_size_ = memory_size;
return true;
}
bool CrashGenerator::UnmapSharedMemory() {
if (!shared_memory_)
return true;
if (munmap(shared_memory_, shared_memory_size_) == 0) {
shared_memory_ = NULL;
shared_memory_size_ = 0;
return true;
}
return false;
}
bool CrashGenerator::SetCoreFileSizeLimit(rlim_t limit) const {
struct rlimit limits = { limit, limit };
return setrlimit(RLIMIT_CORE, &limits) == 0;
}
bool CrashGenerator::CreateChildCrash(
unsigned num_threads, unsigned crash_thread, int crash_signal) {
if (num_threads == 0 || crash_thread >= num_threads)
return false;
if (!MapSharedMemory(num_threads * sizeof(pid_t)))
return false;
pid_t pid = fork();
if (pid == 0) {
if (chdir(temp_dir_.path().c_str()) == 0 &&
SetCoreFileSizeLimit(kCoreSizeLimit)) {
CreateThreadsInChildProcess(num_threads);
kill(*GetThreadIdPointer(crash_thread), crash_signal);
}
exit(1);
}
int status;
if (HANDLE_EINTR(waitpid(pid, &status, 0)) == -1 ||
!WIFSIGNALED(status) || WTERMSIG(status) != crash_signal)
return false;
return true;
}
void CrashGenerator::CreateThreadsInChildProcess(unsigned num_threads) {
*GetThreadIdPointer(0) = getpid();
if (num_threads <= 1)
return;
// This method does not clean up any pthread resource, as the process
// is expected to be killed anyway.
ThreadData* thread_data = new ThreadData[num_threads];
// Create detached threads so that we do not worry about pthread_join()
// later being called or not.
pthread_attr_t thread_attributes;
if (pthread_attr_init(&thread_attributes) != 0 ||
pthread_attr_setdetachstate(&thread_attributes,
PTHREAD_CREATE_DETACHED) != 0) {
exit(1);
}
pthread_barrier_t thread_barrier;
if (pthread_barrier_init(&thread_barrier, NULL, num_threads) != 0) {
exit(1);
}
for (unsigned i = 1; i < num_threads; ++i) {
thread_data[i].barrier = &thread_barrier;
thread_data[i].thread_id_ptr = GetThreadIdPointer(i);
if (pthread_create(&thread_data[i].thread, &thread_attributes,
thread_function, &thread_data[i]) != 0) {
exit(1);
}
}
int result = pthread_barrier_wait(&thread_barrier);
if (result != 0 && result != PTHREAD_BARRIER_SERIAL_THREAD) {
exit(1);
}
pthread_barrier_destroy(&thread_barrier);
pthread_attr_destroy(&thread_attributes);
delete[] thread_data;
}
} // namespace google_breakpad

108
src/common/linux/tests/crash_generator.h Normal file
View File

@@ -0,0 +1,108 @@
// Copyright (c) 2011, 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.
// crash_generator.h: Define the google_breakpad::CrashGenerator class,
// which is used to generate a crash (and a core dump file) for testing.
#ifndef COMMON_LINUX_TESTS_CRASH_GENERATOR_H_
#define COMMON_LINUX_TESTS_CRASH_GENERATOR_H_
#include <sys/resource.h>
#include <string>
#include "common/tests/auto_tempdir.h"
namespace google_breakpad {
// A utility class for generating a crash (and a core dump file) for
// testing. It creates a child process with the specified number of
// threads, which is then termainated by the specified signal. A core
// dump file is expected to be created upon the termination of the child
// process, which can then be used for testing code that processes core
// dump files.
class CrashGenerator {
public:
CrashGenerator();
~CrashGenerator();
// Returns true if a core dump file named 'core' will be generated in
// the current directory for a test that produces a crash by checking
// if /proc/sys/kernel/core_pattern has the default value 'core'.
bool HasDefaultCorePattern() const;
// Sets the maximum size of core dump file (both the soft and hard limit)
// to |limit| bytes. Returns true on success.
bool SetCoreFileSizeLimit(rlim_t limit) const;
// Returns the expected path of the core dump file.
std::string GetCoreFilePath() const;
// Creates a crash (and a core dump file) by creating a child process with
// |num_threads| threads, and the terminating the child process by sending
// a signal with number |crash_signal| to the |crash_thread|-th thread.
// Returns true on success.
bool CreateChildCrash(unsigned num_threads, unsigned crash_thread,
int crash_signal);
// Creates |num_threads| threads in the child process.
void CreateThreadsInChildProcess(unsigned num_threads);
// Returns the thread ID of the |index|-th thread in the child process.
// This method does not validate |index|.
pid_t GetThreadId(unsigned index) const;
private:
// Creates a shared memory of |memory_size| bytes for communicating thread
// IDs between the parent and child process. Returns true on success.
bool MapSharedMemory(size_t memory_size);
// Releases any shared memory created by MapSharedMemory(). Returns true on
// success.
bool UnmapSharedMemory();
// Returns the pointer to the thread ID of the |index|-th thread in the child
// process. This method does not validate |index|.
pid_t* GetThreadIdPointer(unsigned index);
// Temporary directory in which a core file is generated.
AutoTempDir temp_dir_;
// Shared memory for communicating thread IDs between the parent and
// child process.
void* shared_memory_;
// Number of bytes mapped for |shared_memory_|.
size_t shared_memory_size_;
};
} // namespace google_breakpad
#endif // COMMON_LINUX_TESTS_CRASH_GENERATOR_H_