mirror of
https://github.com/chromium/crashpad.git
synced 2024-12-29 00:32:35 +08:00
2b05eb522f
Mac's ProcessReader becomes ProcessReaderMac. Linux/Android's ProcessReader becomes ProcessReaderLinux. Fuchsia's ProcessReader becomes ProcessReaderFuchsia. No intended change in behavior. Bug: crashpad:196, crashpad:30 Change-Id: I7ec8d72f79533bd78189173261ade2ad99010bad Reviewed-on: https://chromium-review.googlesource.com/930321 Reviewed-by: Mark Mentovai <mark@chromium.org> Commit-Queue: Scott Graham <scottmg@chromium.org>
398 lines
12 KiB
C++
398 lines
12 KiB
C++
// Copyright 2017 The Crashpad Authors. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "snapshot/linux/exception_snapshot_linux.h"
|
|
|
|
#include <signal.h>
|
|
|
|
#include "base/logging.h"
|
|
#include "snapshot/linux/cpu_context_linux.h"
|
|
#include "snapshot/linux/process_reader_linux.h"
|
|
#include "snapshot/linux/signal_context.h"
|
|
#include "util/linux/traits.h"
|
|
#include "util/misc/reinterpret_bytes.h"
|
|
#include "util/numeric/safe_assignment.h"
|
|
|
|
namespace crashpad {
|
|
namespace internal {
|
|
|
|
ExceptionSnapshotLinux::ExceptionSnapshotLinux()
|
|
: ExceptionSnapshot(),
|
|
context_union_(),
|
|
context_(),
|
|
codes_(),
|
|
thread_id_(0),
|
|
exception_address_(0),
|
|
signal_number_(0),
|
|
signal_code_(0),
|
|
initialized_() {}
|
|
|
|
ExceptionSnapshotLinux::~ExceptionSnapshotLinux() {}
|
|
|
|
#if defined(ARCH_CPU_X86_FAMILY)
|
|
template <>
|
|
bool ExceptionSnapshotLinux::ReadContext<ContextTraits32>(
|
|
ProcessReaderLinux* reader,
|
|
LinuxVMAddress context_address) {
|
|
UContext<ContextTraits32> ucontext;
|
|
if (!reader->Memory()->Read(context_address, sizeof(ucontext), &ucontext)) {
|
|
LOG(ERROR) << "Couldn't read ucontext";
|
|
return false;
|
|
}
|
|
|
|
context_.architecture = kCPUArchitectureX86;
|
|
context_.x86 = &context_union_.x86;
|
|
|
|
if (ucontext.fprs.magic == X86_FXSR_MAGIC) {
|
|
if (!reader->Memory()->Read(context_address +
|
|
offsetof(UContext<ContextTraits32>, fprs) +
|
|
offsetof(SignalFloatContext32, fxsave),
|
|
sizeof(CPUContextX86::Fxsave),
|
|
&context_.x86->fxsave)) {
|
|
LOG(ERROR) << "Couldn't read fxsave";
|
|
return false;
|
|
}
|
|
InitializeCPUContextX86_NoFloatingPoint(ucontext.mcontext.gprs,
|
|
context_.x86);
|
|
|
|
} else {
|
|
if (ucontext.fprs.magic != 0xffff) {
|
|
LOG(ERROR) << "unexpected magic 0x" << std::hex << ucontext.fprs.magic;
|
|
return false;
|
|
}
|
|
InitializeCPUContextX86(
|
|
ucontext.mcontext.gprs, ucontext.fprs, context_.x86);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template <>
|
|
bool ExceptionSnapshotLinux::ReadContext<ContextTraits64>(
|
|
ProcessReaderLinux* reader,
|
|
LinuxVMAddress context_address) {
|
|
UContext<ContextTraits64> ucontext;
|
|
if (!reader->Memory()->Read(context_address, sizeof(ucontext), &ucontext)) {
|
|
LOG(ERROR) << "Couldn't read ucontext";
|
|
return false;
|
|
}
|
|
|
|
context_.architecture = kCPUArchitectureX86_64;
|
|
context_.x86_64 = &context_union_.x86_64;
|
|
|
|
InitializeCPUContextX86_64(
|
|
ucontext.mcontext.gprs, ucontext.fprs, context_.x86_64);
|
|
return true;
|
|
}
|
|
|
|
#elif defined(ARCH_CPU_ARM_FAMILY)
|
|
|
|
template <>
|
|
bool ExceptionSnapshotLinux::ReadContext<ContextTraits32>(
|
|
ProcessReaderLinux* reader,
|
|
LinuxVMAddress context_address) {
|
|
context_.architecture = kCPUArchitectureARM;
|
|
context_.arm = &context_union_.arm;
|
|
|
|
CPUContextARM* dest_context = context_.arm;
|
|
ProcessMemory* memory = reader->Memory();
|
|
|
|
LinuxVMAddress gprs_address =
|
|
context_address + offsetof(UContext<ContextTraits32>, mcontext32) +
|
|
offsetof(MContext32, gprs);
|
|
|
|
SignalThreadContext32 thread_context;
|
|
if (!memory->Read(gprs_address, sizeof(thread_context), &thread_context)) {
|
|
LOG(ERROR) << "Couldn't read gprs";
|
|
return false;
|
|
}
|
|
InitializeCPUContextARM_NoFloatingPoint(thread_context, dest_context);
|
|
|
|
dest_context->have_fpa_regs = false;
|
|
|
|
LinuxVMAddress reserved_address =
|
|
context_address + offsetof(UContext<ContextTraits32>, reserved);
|
|
if ((reserved_address & 7) != 0) {
|
|
LOG(ERROR) << "invalid alignment 0x" << std::hex << reserved_address;
|
|
return false;
|
|
}
|
|
|
|
constexpr VMSize kMaxContextSpace = 1024;
|
|
|
|
ProcessMemoryRange range;
|
|
if (!range.Initialize(memory, false, reserved_address, kMaxContextSpace)) {
|
|
return false;
|
|
}
|
|
|
|
dest_context->have_vfp_regs = false;
|
|
do {
|
|
CoprocessorContextHead head;
|
|
if (!range.Read(reserved_address, sizeof(head), &head)) {
|
|
LOG(ERROR) << "missing context terminator";
|
|
return false;
|
|
}
|
|
reserved_address += sizeof(head);
|
|
|
|
switch (head.magic) {
|
|
case VFP_MAGIC:
|
|
if (head.size != sizeof(SignalVFPContext) + sizeof(head)) {
|
|
LOG(ERROR) << "unexpected vfp context size " << head.size;
|
|
return false;
|
|
}
|
|
static_assert(
|
|
sizeof(SignalVFPContext::vfp) == sizeof(dest_context->vfp_regs),
|
|
"vfp context size mismatch");
|
|
if (!range.Read(reserved_address + offsetof(SignalVFPContext, vfp),
|
|
sizeof(dest_context->vfp_regs),
|
|
&dest_context->vfp_regs)) {
|
|
LOG(ERROR) << "Couldn't read vfp";
|
|
return false;
|
|
}
|
|
dest_context->have_vfp_regs = true;
|
|
return true;
|
|
|
|
case CRUNCH_MAGIC:
|
|
case IWMMXT_MAGIC:
|
|
case DUMMY_MAGIC:
|
|
reserved_address += head.size - sizeof(head);
|
|
continue;
|
|
|
|
case 0:
|
|
return true;
|
|
|
|
default:
|
|
LOG(ERROR) << "invalid magic number 0x" << std::hex << head.magic;
|
|
return false;
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
template <>
|
|
bool ExceptionSnapshotLinux::ReadContext<ContextTraits64>(
|
|
ProcessReaderLinux* reader,
|
|
LinuxVMAddress context_address) {
|
|
context_.architecture = kCPUArchitectureARM64;
|
|
context_.arm64 = &context_union_.arm64;
|
|
|
|
CPUContextARM64* dest_context = context_.arm64;
|
|
ProcessMemory* memory = reader->Memory();
|
|
|
|
LinuxVMAddress gprs_address =
|
|
context_address + offsetof(UContext<ContextTraits64>, mcontext64) +
|
|
offsetof(MContext64, gprs);
|
|
|
|
ThreadContext::t64_t thread_context;
|
|
if (!memory->Read(gprs_address, sizeof(thread_context), &thread_context)) {
|
|
LOG(ERROR) << "Couldn't read gprs";
|
|
return false;
|
|
}
|
|
InitializeCPUContextARM64_NoFloatingPoint(thread_context, dest_context);
|
|
|
|
LinuxVMAddress reserved_address =
|
|
context_address + offsetof(UContext<ContextTraits64>, reserved);
|
|
if ((reserved_address & 15) != 0) {
|
|
LOG(ERROR) << "invalid alignment 0x" << std::hex << reserved_address;
|
|
return false;
|
|
}
|
|
|
|
constexpr VMSize kMaxContextSpace = 4096;
|
|
|
|
ProcessMemoryRange range;
|
|
if (!range.Initialize(memory, true, reserved_address, kMaxContextSpace)) {
|
|
return false;
|
|
}
|
|
|
|
do {
|
|
CoprocessorContextHead head;
|
|
if (!range.Read(reserved_address, sizeof(head), &head)) {
|
|
LOG(ERROR) << "missing context terminator";
|
|
return false;
|
|
}
|
|
reserved_address += sizeof(head);
|
|
|
|
switch (head.magic) {
|
|
case FPSIMD_MAGIC:
|
|
if (head.size != sizeof(SignalFPSIMDContext) + sizeof(head)) {
|
|
LOG(ERROR) << "unexpected fpsimd context size " << head.size;
|
|
return false;
|
|
}
|
|
SignalFPSIMDContext fpsimd;
|
|
if (!range.Read(reserved_address, sizeof(fpsimd), &fpsimd)) {
|
|
LOG(ERROR) << "Couldn't read fpsimd " << head.size;
|
|
return false;
|
|
}
|
|
InitializeCPUContextARM64_OnlyFPSIMD(fpsimd, dest_context);
|
|
return true;
|
|
|
|
case ESR_MAGIC:
|
|
case EXTRA_MAGIC:
|
|
reserved_address += head.size - sizeof(head);
|
|
continue;
|
|
|
|
case 0:
|
|
LOG(WARNING) << "fpsimd not found";
|
|
InitializeCPUContextARM64_ClearFPSIMD(dest_context);
|
|
return true;
|
|
|
|
default:
|
|
LOG(ERROR) << "invalid magic number 0x" << std::hex << head.magic;
|
|
return false;
|
|
}
|
|
} while (true);
|
|
}
|
|
|
|
#endif // ARCH_CPU_X86_FAMILY
|
|
|
|
bool ExceptionSnapshotLinux::Initialize(ProcessReaderLinux* process_reader,
|
|
LinuxVMAddress siginfo_address,
|
|
LinuxVMAddress context_address,
|
|
pid_t thread_id) {
|
|
INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
|
|
|
|
thread_id_ = thread_id;
|
|
|
|
if (process_reader->Is64Bit()) {
|
|
if (!ReadContext<ContextTraits64>(process_reader, context_address) ||
|
|
!ReadSiginfo<Traits64>(process_reader, siginfo_address)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if (!ReadContext<ContextTraits32>(process_reader, context_address) ||
|
|
!ReadSiginfo<Traits32>(process_reader, siginfo_address)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
INITIALIZATION_STATE_SET_VALID(initialized_);
|
|
return true;
|
|
}
|
|
|
|
template <typename Traits>
|
|
bool ExceptionSnapshotLinux::ReadSiginfo(ProcessReaderLinux* reader,
|
|
LinuxVMAddress siginfo_address) {
|
|
Siginfo<Traits> siginfo;
|
|
if (!reader->Memory()->Read(siginfo_address, sizeof(siginfo), &siginfo)) {
|
|
LOG(ERROR) << "Couldn't read siginfo";
|
|
return false;
|
|
}
|
|
|
|
signal_number_ = siginfo.signo;
|
|
signal_code_ = siginfo.code;
|
|
|
|
uint64_t extra_code;
|
|
#define PUSH_CODE(value) \
|
|
do { \
|
|
if (!ReinterpretBytes(value, &extra_code)) { \
|
|
LOG(ERROR) << "bad code"; \
|
|
return false; \
|
|
} \
|
|
codes_.push_back(extra_code); \
|
|
} while (false)
|
|
|
|
switch (siginfo.signo) {
|
|
case SIGILL:
|
|
case SIGFPE:
|
|
case SIGSEGV:
|
|
case SIGBUS:
|
|
case SIGTRAP:
|
|
exception_address_ = siginfo.address;
|
|
break;
|
|
|
|
case SIGPOLL: // SIGIO
|
|
PUSH_CODE(siginfo.band);
|
|
PUSH_CODE(siginfo.fd);
|
|
break;
|
|
|
|
case SIGSYS:
|
|
exception_address_ = siginfo.call_address;
|
|
PUSH_CODE(siginfo.syscall);
|
|
PUSH_CODE(siginfo.arch);
|
|
break;
|
|
|
|
case SIGALRM:
|
|
case SIGVTALRM:
|
|
case SIGPROF:
|
|
PUSH_CODE(siginfo.timerid);
|
|
PUSH_CODE(siginfo.overrun);
|
|
PUSH_CODE(siginfo.sigval.sigval);
|
|
break;
|
|
|
|
case SIGABRT:
|
|
case SIGQUIT:
|
|
case SIGXCPU:
|
|
case SIGXFSZ:
|
|
case SIGHUP:
|
|
case SIGINT:
|
|
case SIGPIPE:
|
|
case SIGTERM:
|
|
case SIGUSR1:
|
|
case SIGUSR2:
|
|
#if defined(SIGEMT)
|
|
case SIGEMT:
|
|
#endif // SIGEMT
|
|
#if defined(SIGPWR)
|
|
case SIGPWR:
|
|
#endif // SIGPWR
|
|
#if defined(SIGSTKFLT)
|
|
case SIGSTKFLT:
|
|
#endif // SIGSTKFLT
|
|
PUSH_CODE(siginfo.pid);
|
|
PUSH_CODE(siginfo.uid);
|
|
PUSH_CODE(siginfo.sigval.sigval);
|
|
break;
|
|
|
|
default:
|
|
LOG(WARNING) << "Unhandled signal " << siginfo.signo;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
const CPUContext* ExceptionSnapshotLinux::Context() const {
|
|
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
|
|
return &context_;
|
|
}
|
|
|
|
uint64_t ExceptionSnapshotLinux::ThreadID() const {
|
|
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
|
|
return thread_id_;
|
|
}
|
|
|
|
uint32_t ExceptionSnapshotLinux::Exception() const {
|
|
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
|
|
return signal_number_;
|
|
}
|
|
|
|
uint32_t ExceptionSnapshotLinux::ExceptionInfo() const {
|
|
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
|
|
return signal_code_;
|
|
}
|
|
|
|
uint64_t ExceptionSnapshotLinux::ExceptionAddress() const {
|
|
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
|
|
return exception_address_;
|
|
}
|
|
|
|
const std::vector<uint64_t>& ExceptionSnapshotLinux::Codes() const {
|
|
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
|
|
return codes_;
|
|
}
|
|
|
|
std::vector<const MemorySnapshot*> ExceptionSnapshotLinux::ExtraMemory() const {
|
|
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
|
|
return std::vector<const MemorySnapshot*>();
|
|
}
|
|
|
|
} // namespace internal
|
|
} // namespace crashpad
|