From 43c933d7f8e490d9dbf3f939f3b2f095a170dc84 Mon Sep 17 00:00:00 2001 From: "jcivelli@chromium.org" Date: Thu, 9 Aug 2012 22:59:58 +0000 Subject: Adding a way to create an ExceptionHandler that takes in a file descriptor where the minidump should be created, without the need of opening any other file. BUG=None TEST=Run unit-tests. git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@1007 4c0a9323-5329-0410-9bdc-e9ce6186880e --- .../linux/minidump_writer/minidump_writer.cc | 124 +++++++++++++++------ src/client/linux/minidump_writer/minidump_writer.h | 18 ++- .../minidump_writer/minidump_writer_unittest.cc | 39 ++++++- 3 files changed, 137 insertions(+), 44 deletions(-) (limited to 'src/client/linux/minidump_writer') diff --git a/src/client/linux/minidump_writer/minidump_writer.cc b/src/client/linux/minidump_writer/minidump_writer.cc index 89fc96ff..fefef1d2 100644 --- a/src/client/linux/minidump_writer/minidump_writer.cc +++ b/src/client/linux/minidump_writer/minidump_writer.cc @@ -43,6 +43,7 @@ // a canonical instance in the LinuxDumper object. We use the placement // new form to allocate objects and we don't delete them. +#include "client/linux/handler/minidump_descriptor.h" #include "client/linux/minidump_writer/minidump_writer.h" #include "client/minidump_file_writer-inl.h" @@ -81,6 +82,22 @@ #include "google_breakpad/common/minidump_format.h" #include "third_party/lss/linux_syscall_support.h" +namespace { + +using google_breakpad::ExceptionHandler; +using google_breakpad::LineReader; +using google_breakpad::LinuxDumper; +using google_breakpad::LinuxPtraceDumper; +using google_breakpad::MappingEntry; +using google_breakpad::MappingInfo; +using google_breakpad::MappingList; +using google_breakpad::MinidumpFileWriter; +using google_breakpad::PageAllocator; +using google_breakpad::ThreadInfo; +using google_breakpad::TypedMDRVA; +using google_breakpad::UntypedMDRVA; +using google_breakpad::wasteful_vector; + // Minidump defines register structures which are different from the raw // structures which we get from the kernel. These are platform specific // functions to juggle the ucontext and user structures into minidump format. @@ -90,22 +107,22 @@ typedef MDRawContextX86 RawContextCPU; // Write a uint16_t to memory // out: memory location to write to // v: value to write. -static void U16(void* out, uint16_t v) { +void U16(void* out, uint16_t v) { my_memcpy(out, &v, sizeof(v)); } // Write a uint32_t to memory // out: memory location to write to // v: value to write. -static void U32(void* out, uint32_t v) { +void U32(void* out, uint32_t v) { my_memcpy(out, &v, sizeof(v)); } // Juggle an x86 user_(fp|fpx|)regs_struct into minidump format // out: the minidump structure // info: the collection of register structures. -static void CPUFillFromThreadInfo(MDRawContextX86 *out, - const google_breakpad::ThreadInfo &info) { +void CPUFillFromThreadInfo(MDRawContextX86 *out, + const google_breakpad::ThreadInfo &info) { out->context_flags = MD_CONTEXT_X86_ALL; out->dr0 = info.dregs[0]; @@ -165,8 +182,8 @@ static void CPUFillFromThreadInfo(MDRawContextX86 *out, // Juggle an x86 ucontext into minidump format // out: the minidump structure // info: the collection of register structures. -static void CPUFillFromUContext(MDRawContextX86 *out, const ucontext *uc, - const struct _libc_fpstate* fp) { +void CPUFillFromUContext(MDRawContextX86 *out, const ucontext *uc, + const struct _libc_fpstate* fp) { const greg_t* regs = uc->uc_mcontext.gregs; out->context_flags = MD_CONTEXT_X86_FULL | @@ -206,8 +223,8 @@ static void CPUFillFromUContext(MDRawContextX86 *out, const ucontext *uc, #elif defined(__x86_64) typedef MDRawContextAMD64 RawContextCPU; -static void CPUFillFromThreadInfo(MDRawContextAMD64 *out, - const google_breakpad::ThreadInfo &info) { +void CPUFillFromThreadInfo(MDRawContextAMD64 *out, + const google_breakpad::ThreadInfo &info) { out->context_flags = MD_CONTEXT_AMD64_FULL | MD_CONTEXT_AMD64_SEGMENTS; @@ -265,8 +282,8 @@ static void CPUFillFromThreadInfo(MDRawContextAMD64 *out, my_memcpy(&out->flt_save.xmm_registers, &info.fpregs.xmm_space, 16 * 16); } -static void CPUFillFromUContext(MDRawContextAMD64 *out, const ucontext *uc, - const struct _libc_fpstate* fpregs) { +void CPUFillFromUContext(MDRawContextAMD64 *out, const ucontext *uc, + const struct _libc_fpstate* fpregs) { const greg_t* regs = uc->uc_mcontext.gregs; out->context_flags = MD_CONTEXT_AMD64_FULL; @@ -315,8 +332,8 @@ static void CPUFillFromUContext(MDRawContextAMD64 *out, const ucontext *uc, #elif defined(__ARMEL__) typedef MDRawContextARM RawContextCPU; -static void CPUFillFromThreadInfo(MDRawContextARM *out, - const google_breakpad::ThreadInfo &info) { +void CPUFillFromThreadInfo(MDRawContextARM* out, + const google_breakpad::ThreadInfo& info) { out->context_flags = MD_CONTEXT_ARM_FULL; for (int i = 0; i < MD_CONTEXT_ARM_GPR_COUNT; ++i) @@ -332,8 +349,8 @@ static void CPUFillFromThreadInfo(MDRawContextARM *out, #endif } -static void CPUFillFromUContext(MDRawContextARM *out, const ucontext *uc, - const struct _libc_fpstate* fpregs) { +void CPUFillFromUContext(MDRawContextARM* out, const ucontext* uc, + const struct _libc_fpstate* fpregs) { out->context_flags = MD_CONTEXT_ARM_FULL; out->iregs[0] = uc->uc_mcontext.arm_r0; @@ -366,15 +383,15 @@ static void CPUFillFromUContext(MDRawContextARM *out, const ucontext *uc, #error "This code has not been ported to your platform yet." #endif -namespace google_breakpad { - class MinidumpWriter { public: - MinidumpWriter(const char* filename, + MinidumpWriter(const char* minidump_path, + int minidump_fd, const ExceptionHandler::CrashContext* context, const MappingList& mappings, LinuxDumper* dumper) - : filename_(filename), + : fd_(minidump_fd), + path_(minidump_path), ucontext_(context ? &context->context : NULL), #if !defined(__ARM_EABI__) float_state_(context ? &context->float_state : NULL), @@ -385,15 +402,28 @@ class MinidumpWriter { dumper_(dumper), memory_blocks_(dumper_->allocator()), mapping_list_(mappings) { + // Assert there should be either a valid fd or a valid path, not both. + assert(fd_ != -1 || minidump_path); + assert(fd_ == -1 || !minidump_path); } bool Init() { - return dumper_->Init() && minidump_writer_.Open(filename_) && - dumper_->ThreadsSuspend(); + if (!dumper_->Init()) + return false; + + if (fd_ != -1) + minidump_writer_.SetFile(fd_); + else if (!minidump_writer_.Open(path_)) + return false; + + return dumper_->ThreadsSuspend(); } ~MinidumpWriter() { - minidump_writer_.Close(); + // Don't close the file descriptor when it's been provided explicitly. + // Callers might still need to use it. + if (fd_ == -1) + minidump_writer_.Close(); dumper_->ThreadsResume(); } @@ -1324,7 +1354,10 @@ class MinidumpWriter { return WriteFile(result, buf); } - const char* const filename_; // output filename + // Only one of the 2 member variables below should be set to a valid value. + const int fd_; // File descriptor where the minidum should be written. + const char* path_; // Path to the file where the minidum should be written. + const struct ucontext* const ucontext_; // also from the signal handler const struct _libc_fpstate* const float_state_; // ditto LinuxDumper* dumper_; @@ -1338,15 +1371,12 @@ class MinidumpWriter { const MappingList& mapping_list_; }; -bool WriteMinidump(const char* filename, pid_t crashing_process, - const void* blob, size_t blob_size) { - MappingList m; - return WriteMinidump(filename, crashing_process, blob, blob_size, m); -} -bool WriteMinidump(const char* filename, pid_t crashing_process, - const void* blob, size_t blob_size, - const MappingList& mappings) { +bool WriteMinidumpImpl(const char* minidump_path, + int minidump_fd, + pid_t crashing_process, + const void* blob, size_t blob_size, + const MappingList& mappings) { if (blob_size != sizeof(ExceptionHandler::CrashContext)) return false; const ExceptionHandler::CrashContext* context = @@ -1356,16 +1386,46 @@ bool WriteMinidump(const char* filename, pid_t crashing_process, reinterpret_cast(context->siginfo.si_addr)); dumper.set_crash_signal(context->siginfo.si_signo); dumper.set_crash_thread(context->tid); - MinidumpWriter writer(filename, context, mappings, &dumper); + MinidumpWriter writer(minidump_path, minidump_fd, context, mappings, &dumper); if (!writer.Init()) return false; return writer.Dump(); } +} // namespace + +namespace google_breakpad { + +bool WriteMinidump(const char* minidump_path, pid_t crashing_process, + const void* blob, size_t blob_size) { + return WriteMinidumpImpl(minidump_path, -1, crashing_process, blob, blob_size, + MappingList()); +} + +bool WriteMinidump(int minidump_fd, pid_t crashing_process, + const void* blob, size_t blob_size) { + return WriteMinidumpImpl(NULL, minidump_fd, crashing_process, blob, blob_size, + MappingList()); +} + +bool WriteMinidump(const char* minidump_path, pid_t crashing_process, + const void* blob, size_t blob_size, + const MappingList& mappings) { + return WriteMinidumpImpl(minidump_path, -1, crashing_process, blob, blob_size, + mappings); +} + +bool WriteMinidump(int minidump_fd, pid_t crashing_process, + const void* blob, size_t blob_size, + const MappingList& mappings) { + return WriteMinidumpImpl(NULL, minidump_fd, crashing_process, blob, blob_size, + mappings); +} + bool WriteMinidump(const char* filename, const MappingList& mappings, LinuxDumper* dumper) { - MinidumpWriter writer(filename, NULL, mappings, dumper); + MinidumpWriter writer(filename, -1, NULL, mappings, dumper); if (!writer.Init()) return false; return writer.Dump(); diff --git a/src/client/linux/minidump_writer/minidump_writer.h b/src/client/linux/minidump_writer/minidump_writer.h index e79eb79b..14da94b6 100644 --- a/src/client/linux/minidump_writer/minidump_writer.h +++ b/src/client/linux/minidump_writer/minidump_writer.h @@ -51,21 +51,27 @@ struct MappingEntry { // A list of typedef std::list MappingList; -// Write a minidump to the filesystem. This function does not malloc nor use +// Writes a minidump to the filesystem. These functions do not malloc nor use // libc functions which may. Thus, it can be used in contexts where the state // of the heap may be corrupt. -// filename: the filename to write to. This is opened O_EXCL and fails if -// open fails. +// minidump_path: the path to the file to write to. This is opened O_EXCL and +// fails open fails. // crashing_process: the pid of the crashing process. This must be trusted. // blob: a blob of data from the crashing process. See exception_handler.h // blob_size: the length of |blob|, in bytes // // Returns true iff successful. -bool WriteMinidump(const char* filename, pid_t crashing_process, +bool WriteMinidump(const char* minidump_path, pid_t crashing_process, + const void* blob, size_t blob_size); +// Same as above but takes an open file descriptor instead of a path. +bool WriteMinidump(int minidump_fd, pid_t crashing_process, const void* blob, size_t blob_size); -// This overload also allows passing a list of known mappings. -bool WriteMinidump(const char* filename, pid_t crashing_process, +// These overloads also allow passing a list of known mappings. +bool WriteMinidump(const char* minidump_path, pid_t crashing_process, + const void* blob, size_t blob_size, + const MappingList& mappings); +bool WriteMinidump(int minidump_fd, pid_t crashing_process, const void* blob, size_t blob_size, const MappingList& mappings); diff --git a/src/client/linux/minidump_writer/minidump_writer_unittest.cc b/src/client/linux/minidump_writer/minidump_writer_unittest.cc index 31e1440d..1fff015f 100644 --- a/src/client/linux/minidump_writer/minidump_writer_unittest.cc +++ b/src/client/linux/minidump_writer/minidump_writer_unittest.cc @@ -60,7 +60,7 @@ namespace { typedef testing::Test MinidumpWriterTest; } -TEST(MinidumpWriterTest, Setup) { +TEST(MinidumpWriterTest, SetupWithPath) { int fds[2]; ASSERT_NE(-1, pipe(fds)); @@ -89,6 +89,36 @@ TEST(MinidumpWriterTest, Setup) { close(fds[1]); } +TEST(MinidumpWriterTest, SetupWithFD) { + int fds[2]; + ASSERT_NE(-1, pipe(fds)); + + const pid_t child = fork(); + if (child == 0) { + close(fds[1]); + char b; + HANDLE_EINTR(read(fds[0], &b, sizeof(b))); + close(fds[0]); + syscall(__NR_exit); + } + close(fds[0]); + + ExceptionHandler::CrashContext context; + memset(&context, 0, sizeof(context)); + + AutoTempDir temp_dir; + string templ = temp_dir.path() + "/minidump-writer-unittest"; + int fd = open(templ.c_str(), O_CREAT | O_WRONLY, S_IRWXU); + // Set a non-zero tid to avoid tripping asserts. + context.tid = 1; + ASSERT_TRUE(WriteMinidump(fd, child, &context, sizeof(context))); + struct stat st; + ASSERT_EQ(stat(templ.c_str(), &st), 0); + ASSERT_GT(st.st_size, 0u); + + close(fds[1]); +} + // Test that mapping info can be specified when writing a minidump, // and that it ends up in the module list of the minidump. TEST(MinidumpWriterTest, MappingInfo) { @@ -261,9 +291,8 @@ TEST(MinidumpWriterTest, MappingInfoContained) { mapping.first = info; memcpy(mapping.second, kModuleGUID, sizeof(MDGUID)); mappings.push_back(mapping); - ASSERT_TRUE( - WriteMinidump(dumpfile.c_str(), child, &context, sizeof(context), - mappings)); + ASSERT_TRUE(WriteMinidump(dumpfile.c_str(), child, &context, sizeof(context), + mappings)); // Read the minidump. Load the module list, and ensure that // the mmap'ed |memory| is listed with the given module name @@ -355,8 +384,6 @@ TEST(MinidumpWriterTest, DeletedBinary) { ASSERT_EQ(stat(templ.c_str(), &st), 0); ASSERT_GT(st.st_size, 0u); - - Minidump minidump(templ.c_str()); ASSERT_TRUE(minidump.Read()); -- cgit v1.2.1