193 lines
7.0 KiB
C++
193 lines
7.0 KiB
C++
// Copyright (c) 2010, 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.
|
|
|
|
#ifndef CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
|
|
#define CLIENT_LINUX_MINIDUMP_WRITER_LINUX_DUMPER_H_
|
|
|
|
#include <elf.h>
|
|
#include <linux/limits.h>
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
#if !defined(__ANDROID__)
|
|
#include <sys/user.h>
|
|
#endif
|
|
|
|
#include "common/memory.h"
|
|
#include "google_breakpad/common/minidump_format.h"
|
|
|
|
namespace google_breakpad {
|
|
|
|
#if defined(__i386) || defined(__x86_64)
|
|
typedef typeof(((struct user*) 0)->u_debugreg[0]) debugreg_t;
|
|
#endif
|
|
|
|
// Typedef for our parsing of the auxv variables in /proc/pid/auxv.
|
|
#if defined(__i386) || defined(__ARM_EABI__)
|
|
#if !defined(__ANDROID__)
|
|
typedef Elf32_auxv_t elf_aux_entry;
|
|
#else
|
|
// Android is missing this structure definition
|
|
typedef struct
|
|
{
|
|
uint32_t a_type; /* Entry type */
|
|
union
|
|
{
|
|
uint32_t a_val; /* Integer value */
|
|
} a_un;
|
|
} elf_aux_entry;
|
|
|
|
#if !defined(AT_SYSINFO_EHDR)
|
|
#define AT_SYSINFO_EHDR 33
|
|
#endif
|
|
#endif // __ANDROID__
|
|
#elif defined(__x86_64__)
|
|
typedef Elf64_auxv_t elf_aux_entry;
|
|
#endif
|
|
// When we find the VDSO mapping in the process's address space, this
|
|
// is the name we use for it when writing it to the minidump.
|
|
// This should always be less than NAME_MAX!
|
|
const char kLinuxGateLibraryName[] = "linux-gate.so";
|
|
|
|
// We produce one of these structures for each thread in the crashed process.
|
|
struct ThreadInfo {
|
|
pid_t tgid; // thread group id
|
|
pid_t ppid; // parent process
|
|
|
|
// Even on platforms where the stack grows down, the following will point to
|
|
// the smallest address in the stack.
|
|
const void* stack; // pointer to the stack area
|
|
size_t stack_len; // length of the stack to copy
|
|
|
|
|
|
#if defined(__i386) || defined(__x86_64)
|
|
user_regs_struct regs;
|
|
user_fpregs_struct fpregs;
|
|
static const unsigned kNumDebugRegisters = 8;
|
|
debugreg_t dregs[8];
|
|
#if defined(__i386)
|
|
user_fpxregs_struct fpxregs;
|
|
#endif // defined(__i386)
|
|
|
|
#elif defined(__ARM_EABI__)
|
|
// Mimicking how strace does this(see syscall.c, search for GETREGS)
|
|
#if defined(__ANDROID__)
|
|
struct pt_regs regs;
|
|
#else
|
|
struct user_regs regs;
|
|
struct user_fpregs fpregs;
|
|
#endif // __ANDROID__
|
|
#endif
|
|
};
|
|
|
|
// One of these is produced for each mapping in the process (i.e. line in
|
|
// /proc/$x/maps).
|
|
struct MappingInfo {
|
|
uintptr_t start_addr;
|
|
size_t size;
|
|
size_t offset; // offset into the backed file.
|
|
char name[NAME_MAX];
|
|
};
|
|
|
|
class LinuxDumper {
|
|
public:
|
|
explicit LinuxDumper(pid_t pid);
|
|
|
|
// Parse the data for |threads| and |mappings|.
|
|
bool Init();
|
|
|
|
// Suspend/resume all threads in the given process.
|
|
bool ThreadsSuspend();
|
|
bool ThreadsResume();
|
|
|
|
// Read information about the given thread. Returns true on success. One must
|
|
// have called |ThreadsSuspend| first.
|
|
bool ThreadInfoGet(pid_t tid, ThreadInfo* info);
|
|
|
|
// These are only valid after a call to |Init|.
|
|
const wasteful_vector<pid_t> &threads() { return threads_; }
|
|
const wasteful_vector<MappingInfo*> &mappings() { return mappings_; }
|
|
const MappingInfo* FindMapping(const void* address) const;
|
|
|
|
// Find a block of memory to take as the stack given the top of stack pointer.
|
|
// stack: (output) the lowest address in the memory area
|
|
// stack_len: (output) the length of the memory area
|
|
// stack_top: the current top of the stack
|
|
bool GetStackInfo(const void** stack, size_t* stack_len, uintptr_t stack_top);
|
|
|
|
PageAllocator* allocator() { return &allocator_; }
|
|
|
|
// memcpy from a remote process.
|
|
static void CopyFromProcess(void* dest, pid_t child, const void* src,
|
|
size_t length);
|
|
|
|
// Builds a proc path for a certain pid for a node. path is a
|
|
// character array that is overwritten, and node is the final node
|
|
// without any slashes.
|
|
void BuildProcPath(char* path, pid_t pid, const char* node) const;
|
|
|
|
// Generate a File ID from the .text section of a mapped entry.
|
|
// mapping_id may be -1 if this is not a member of mappings_.
|
|
bool ElfFileIdentifierForMapping(const MappingInfo& mapping,
|
|
int mapping_id,
|
|
uint8_t identifier[sizeof(MDGUID)]);
|
|
|
|
// Utility method to find the location of where the kernel has
|
|
// mapped linux-gate.so in memory(shows up in /proc/pid/maps as
|
|
// [vdso], but we can't guarantee that it's the only virtual dynamic
|
|
// shared object. Parsing the auxilary vector for AT_SYSINFO_EHDR
|
|
// is the safest way to go.)
|
|
void* FindBeginningOfLinuxGateSharedLibrary(const pid_t pid) const;
|
|
private:
|
|
bool EnumerateMappings(wasteful_vector<MappingInfo*>* result) const;
|
|
bool EnumerateThreads(wasteful_vector<pid_t>* result) const;
|
|
|
|
// For the case where a running program has been deleted, it'll show up in
|
|
// /proc/pid/maps as "/path/to/program (deleted)". If this is the case, then
|
|
// see if '/path/to/program (deleted)' matches /proc/pid/exe and return
|
|
// /proc/pid/exe in |path| so ELF identifier generation works correctly. This
|
|
// also checks to see if '/path/to/program (deleted)' exists, so it does not
|
|
// get fooled by a poorly named binary.
|
|
// For programs that don't end with ' (deleted)', this is a no-op.
|
|
// This assumes |path| is a buffer with length NAME_MAX.
|
|
// Returns true if |path| is modified.
|
|
bool HandleDeletedFileInMapping(char* path) const;
|
|
|
|
const pid_t pid_;
|
|
|
|
mutable PageAllocator allocator_;
|
|
|
|
bool threads_suspended_;
|
|
wasteful_vector<pid_t> threads_; // the ids of all the threads
|
|
wasteful_vector<MappingInfo*> mappings_; // info from /proc/<pid>/maps
|
|
};
|
|
|
|
} // namespace google_breakpad
|
|
|
|
#endif // CLIENT_LINUX_HANDLER_LINUX_DUMPER_H_
|