snapshot/win/exception_snapshot_win.cc - crashpad/crashpad - Git at Google

 // Copyright 2015 The Crashpad Authors
 //
 // 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/win/exception_snapshot_win.h"

 #include <algorithm>

 #include "base/logging.h"
 #include "snapshot/capture_memory.h"
 #include "snapshot/memory_snapshot.h"
 #include "snapshot/memory_snapshot_generic.h"
 #include "snapshot/win/capture_memory_delegate_win.h"
 #include "snapshot/win/cpu_context_win.h"
 #include "snapshot/win/process_reader_win.h"
 #include "util/win/exception_codes.h"
 #include "util/win/nt_internals.h"

 namespace crashpad {
 namespace internal {

 namespace {

 #if defined(ARCH_CPU_X86_FAMILY)
 #if defined(ARCH_CPU_32_BITS)
 using Context32 = CONTEXT;
 #elif defined(ARCH_CPU_64_BITS)
 using Context32 = WOW64_CONTEXT;
 #endif

 void NativeContextToCPUContext32(const Context32* context_record,
                                  CPUContext* context,
                                  CPUContextUnion* context_union) {
   context->architecture = kCPUArchitectureX86;
   context->x86 = &context_union->x86;
   InitializeX86Context(context_record, context->x86);
 }
 #endif  // ARCH_CPU_X86_FAMILY

 #if defined(ARCH_CPU_64_BITS)
 void NativeContextToCPUContext64(const CONTEXT* context_record,
                                  CPUContext* context,
                                  CPUContextUnion* context_union) {
 #if defined(ARCH_CPU_X86_64)
   context->architecture = kCPUArchitectureX86_64;
   context->x86_64 = &context_union->x86_64;
   // Note that the context here is not extended, even if the flags suggest so,
   // as we only copied in sizeof(CONTEXT).
   InitializeX64Context(context_record, context->x86_64);
   // TODO(1250098) plumb through ssp via message from crashed process. For now
   // we zero this if CET is available in the capturing process as otherwise
   // WinDBG will show the relevant thread's ssp for the exception which will
   // likely be more confusing than showing a zero value.
   if (IsXStateFeatureEnabled(XSTATE_MASK_CET_U)) {
     XSAVE_CET_U_FORMAT cet_u_fake;
     cet_u_fake.Ia32CetUMsr = 0;
     cet_u_fake.Ia32Pl3SspMsr = 0;
     InitializeX64XStateCet(context_record, &cet_u_fake, context->x86_64);
   }
 #elif defined(ARCH_CPU_ARM64)
   context->architecture = kCPUArchitectureARM64;
   context->arm64 = &context_union->arm64;
   InitializeARM64Context(context_record, context->arm64);
 #else
 #error Unsupported Windows 64-bit Arch
 #endif
 }
 #endif

 }  // namespace

 ExceptionSnapshotWin::ExceptionSnapshotWin()
     : ExceptionSnapshot(),
       context_union_(),
       context_(),
       codes_(),
       extra_memory_(),
       thread_id_(0),
       exception_address_(0),
       exception_flags_(0),
       exception_code_(0),
       initialized_() {
 }

 ExceptionSnapshotWin::~ExceptionSnapshotWin() {
 }

 bool ExceptionSnapshotWin::Initialize(
     ProcessReaderWin* process_reader,
     DWORD thread_id,
     WinVMAddress exception_pointers_address,
     uint32_t* gather_indirectly_referenced_memory_cap) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);

   const ProcessReaderWin::Thread* thread = nullptr;
   for (const auto& loop_thread : process_reader->Threads()) {
     if (thread_id == loop_thread.id) {
       thread = &loop_thread;
       break;
     }
   }

   if (!thread) {
     LOG(ERROR) << "thread ID " << thread_id << " not found in process";
     return false;
   } else {
     thread_id_ = thread_id;
   }

 #if defined(ARCH_CPU_32_BITS)
   const bool is_64_bit = false;
 #elif defined(ARCH_CPU_64_BITS)
   const bool is_64_bit = process_reader->Is64Bit();
   if (is_64_bit) {
     if (!InitializeFromExceptionPointers<EXCEPTION_RECORD64,
                                          process_types::EXCEPTION_POINTERS64>(
             process_reader,
             exception_pointers_address,
             thread_id,
             &NativeContextToCPUContext64)) {
       return false;
     }
   }
 #endif

 #if !defined(ARCH_CPU_ARM64)
   if (!is_64_bit) {
     if (!InitializeFromExceptionPointers<EXCEPTION_RECORD32,
                                          process_types::EXCEPTION_POINTERS32>(
             process_reader,
             exception_pointers_address,
             thread_id,
             &NativeContextToCPUContext32)) {
       return false;
     }
   }
 #endif

   CaptureMemoryDelegateWin capture_memory_delegate(
       process_reader,
       *thread,
       &extra_memory_,
       gather_indirectly_referenced_memory_cap);
   CaptureMemory::PointedToByContext(context_, &capture_memory_delegate);

   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }

 const CPUContext* ExceptionSnapshotWin::Context() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return &context_;
 }

 uint64_t ExceptionSnapshotWin::ThreadID() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return thread_id_;
 }

 uint32_t ExceptionSnapshotWin::Exception() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return exception_code_;
 }

 uint32_t ExceptionSnapshotWin::ExceptionInfo() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return exception_flags_;
 }

 uint64_t ExceptionSnapshotWin::ExceptionAddress() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return exception_address_;
 }

 const std::vector<uint64_t>& ExceptionSnapshotWin::Codes() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return codes_;
 }

 std::vector<const MemorySnapshot*> ExceptionSnapshotWin::ExtraMemory() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   std::vector<const MemorySnapshot*> result;
   result.reserve(extra_memory_.size());
   for (const auto& em : extra_memory_) {
     result.push_back(em.get());
   }
   return result;
 }

 template <class ExceptionRecordType,
           class ExceptionPointersType,
           class ContextType>
 bool ExceptionSnapshotWin::InitializeFromExceptionPointers(
     ProcessReaderWin* process_reader,
     WinVMAddress exception_pointers_address,
     DWORD exception_thread_id,
     void (*native_to_cpu_context)(const ContextType* context_record,
                                   CPUContext* context,
                                   CPUContextUnion* context_union)) {
   ExceptionPointersType exception_pointers;
   if (!process_reader->Memory()->Read(exception_pointers_address,
                                       sizeof(exception_pointers),
                                       &exception_pointers)) {
     LOG(ERROR) << "EXCEPTION_POINTERS read failed";
     return false;
   }
   if (!exception_pointers.ExceptionRecord) {
     LOG(ERROR) << "null ExceptionRecord";
     return false;
   }

   ExceptionRecordType first_record;
   if (!process_reader->Memory()->Read(
           static_cast<WinVMAddress>(exception_pointers.ExceptionRecord),
           sizeof(first_record),
           &first_record)) {
     LOG(ERROR) << "ExceptionRecord";
     return false;
   }

   const bool triggered_by_client =
       first_record.ExceptionCode == ExceptionCodes::kTriggeredExceptionCode &&
       first_record.NumberParameters == 2;
   if (triggered_by_client)
     process_reader->DecrementThreadSuspendCounts(exception_thread_id);

   if (triggered_by_client && first_record.ExceptionInformation[0] != 0) {
     // This special exception code indicates that the target was crashed by
     // another client calling CrashpadClient::DumpAndCrashTargetProcess(). In
     // this case the parameters are a thread id and an exception code which we
     // use to fabricate a new exception record.
     using ArgumentType = decltype(first_record.ExceptionInformation[0]);
     const ArgumentType blame_thread_id = first_record.ExceptionInformation[0];
     exception_code_ = static_cast<DWORD>(first_record.ExceptionInformation[1]);
     exception_flags_ = EXCEPTION_NONCONTINUABLE;
     for (const auto& thread : process_reader->Threads()) {
       if (thread.id == blame_thread_id) {
         thread_id_ = blame_thread_id;
         native_to_cpu_context(thread.context.context<const ContextType>(),
                               &context_,
                               &context_union_);
         exception_address_ = context_.InstructionPointer();
         break;
       }
     }

     if (exception_address_ == 0) {
       LOG(WARNING) << "thread " << blame_thread_id << " not found";
       return false;
     }
   } else {
     // Normal case.
     exception_code_ = first_record.ExceptionCode;
     exception_flags_ = first_record.ExceptionFlags;
     exception_address_ = first_record.ExceptionAddress;

     const DWORD number_parameters = std::min<DWORD>(
         first_record.NumberParameters, EXCEPTION_MAXIMUM_PARAMETERS);
     for (DWORD i = 0; i < number_parameters; ++i) {
       codes_.push_back(first_record.ExceptionInformation[i]);
     }
     if (first_record.ExceptionRecord) {
       // https://crashpad.chromium.org/bug/43
       LOG(WARNING) << "dropping chained ExceptionRecord";
     }

     ContextType context_record;
     if (!process_reader->Memory()->Read(
             static_cast<WinVMAddress>(exception_pointers.ContextRecord),
             sizeof(context_record),
             &context_record)) {
       LOG(ERROR) << "ContextRecord";
       return false;
     }

     native_to_cpu_context(&context_record, &context_, &context_union_);
   }

   return true;
 }

 }  // namespace internal
 }  // namespace crashpad
	// Copyright 2015 The Crashpad Authors
	//
	// 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/win/exception_snapshot_win.h"

	#include <algorithm>

	#include "base/logging.h"
	#include "snapshot/capture_memory.h"
	#include "snapshot/memory_snapshot.h"
	#include "snapshot/memory_snapshot_generic.h"
	#include "snapshot/win/capture_memory_delegate_win.h"
	#include "snapshot/win/cpu_context_win.h"
	#include "snapshot/win/process_reader_win.h"
	#include "util/win/exception_codes.h"
	#include "util/win/nt_internals.h"

	namespace crashpad {
	namespace internal {

	namespace {

	#if defined(ARCH_CPU_X86_FAMILY)
	#if defined(ARCH_CPU_32_BITS)
	using Context32 = CONTEXT;
	#elif defined(ARCH_CPU_64_BITS)
	using Context32 = WOW64_CONTEXT;
	#endif

	void NativeContextToCPUContext32(const Context32* context_record,
	CPUContext* context,
	CPUContextUnion* context_union) {
	context->architecture = kCPUArchitectureX86;
	context->x86 = &context_union->x86;
	InitializeX86Context(context_record, context->x86);
	}
	#endif // ARCH_CPU_X86_FAMILY

	#if defined(ARCH_CPU_64_BITS)
	void NativeContextToCPUContext64(const CONTEXT* context_record,
	CPUContext* context,
	CPUContextUnion* context_union) {
	#if defined(ARCH_CPU_X86_64)
	context->architecture = kCPUArchitectureX86_64;
	context->x86_64 = &context_union->x86_64;
	// Note that the context here is not extended, even if the flags suggest so,
	// as we only copied in sizeof(CONTEXT).
	InitializeX64Context(context_record, context->x86_64);
	// TODO(1250098) plumb through ssp via message from crashed process. For now
	// we zero this if CET is available in the capturing process as otherwise
	// WinDBG will show the relevant thread's ssp for the exception which will
	// likely be more confusing than showing a zero value.
	if (IsXStateFeatureEnabled(XSTATE_MASK_CET_U)) {
	XSAVE_CET_U_FORMAT cet_u_fake;
	cet_u_fake.Ia32CetUMsr = 0;
	cet_u_fake.Ia32Pl3SspMsr = 0;
	InitializeX64XStateCet(context_record, &cet_u_fake, context->x86_64);
	}
	#elif defined(ARCH_CPU_ARM64)
	context->architecture = kCPUArchitectureARM64;
	context->arm64 = &context_union->arm64;
	InitializeARM64Context(context_record, context->arm64);
	#else
	#error Unsupported Windows 64-bit Arch
	#endif
	}
	#endif

	} // namespace

	ExceptionSnapshotWin::ExceptionSnapshotWin()
	: ExceptionSnapshot(),
	context_union_(),
	context_(),
	codes_(),
	extra_memory_(),
	thread_id_(0),
	exception_address_(0),
	exception_flags_(0),
	exception_code_(0),
	initialized_() {
	}

	ExceptionSnapshotWin::~ExceptionSnapshotWin() {
	}

	bool ExceptionSnapshotWin::Initialize(
	ProcessReaderWin* process_reader,
	DWORD thread_id,
	WinVMAddress exception_pointers_address,
	uint32_t* gather_indirectly_referenced_memory_cap) {
	INITIALIZATION_STATE_SET_INITIALIZING(initialized_);

	const ProcessReaderWin::Thread* thread = nullptr;
	for (const auto& loop_thread : process_reader->Threads()) {
	if (thread_id == loop_thread.id) {
	thread = &loop_thread;
	break;
	}
	}

	if (!thread) {
	LOG(ERROR) << "thread ID " << thread_id << " not found in process";
	return false;
	} else {
	thread_id_ = thread_id;
	}

	#if defined(ARCH_CPU_32_BITS)
	const bool is_64_bit = false;
	#elif defined(ARCH_CPU_64_BITS)
	const bool is_64_bit = process_reader->Is64Bit();
	if (is_64_bit) {
	if (!InitializeFromExceptionPointers<EXCEPTION_RECORD64,
	process_types::EXCEPTION_POINTERS64>(
	process_reader,
	exception_pointers_address,
	thread_id,
	&NativeContextToCPUContext64)) {
	return false;
	}
	}
	#endif

	#if !defined(ARCH_CPU_ARM64)
	if (!is_64_bit) {
	if (!InitializeFromExceptionPointers<EXCEPTION_RECORD32,
	process_types::EXCEPTION_POINTERS32>(
	process_reader,
	exception_pointers_address,
	thread_id,
	&NativeContextToCPUContext32)) {
	return false;
	}
	}
	#endif

	CaptureMemoryDelegateWin capture_memory_delegate(
	process_reader,
	*thread,
	&extra_memory_,
	gather_indirectly_referenced_memory_cap);
	CaptureMemory::PointedToByContext(context_, &capture_memory_delegate);

	INITIALIZATION_STATE_SET_VALID(initialized_);
	return true;
	}

	const CPUContext* ExceptionSnapshotWin::Context() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return &context_;
	}

	uint64_t ExceptionSnapshotWin::ThreadID() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return thread_id_;
	}

	uint32_t ExceptionSnapshotWin::Exception() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return exception_code_;
	}

	uint32_t ExceptionSnapshotWin::ExceptionInfo() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return exception_flags_;
	}

	uint64_t ExceptionSnapshotWin::ExceptionAddress() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return exception_address_;
	}

	const std::vector<uint64_t>& ExceptionSnapshotWin::Codes() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return codes_;
	}

	std::vector<const MemorySnapshot*> ExceptionSnapshotWin::ExtraMemory() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	std::vector<const MemorySnapshot*> result;
	result.reserve(extra_memory_.size());
	for (const auto& em : extra_memory_) {
	result.push_back(em.get());
	}
	return result;
	}

	template <class ExceptionRecordType,
	class ExceptionPointersType,
	class ContextType>
	bool ExceptionSnapshotWin::InitializeFromExceptionPointers(
	ProcessReaderWin* process_reader,
	WinVMAddress exception_pointers_address,
	DWORD exception_thread_id,
	void (native_to_cpu_context)(const ContextType context_record,
	CPUContext* context,
	CPUContextUnion* context_union)) {
	ExceptionPointersType exception_pointers;
	if (!process_reader->Memory()->Read(exception_pointers_address,
	sizeof(exception_pointers),
	&exception_pointers)) {
	LOG(ERROR) << "EXCEPTION_POINTERS read failed";
	return false;
	}
	if (!exception_pointers.ExceptionRecord) {
	LOG(ERROR) << "null ExceptionRecord";
	return false;
	}

	ExceptionRecordType first_record;
	if (!process_reader->Memory()->Read(
	static_cast<WinVMAddress>(exception_pointers.ExceptionRecord),
	sizeof(first_record),
	&first_record)) {
	LOG(ERROR) << "ExceptionRecord";
	return false;
	}

	const bool triggered_by_client =
	first_record.ExceptionCode == ExceptionCodes::kTriggeredExceptionCode &&
	first_record.NumberParameters == 2;
	if (triggered_by_client)
	process_reader->DecrementThreadSuspendCounts(exception_thread_id);

	if (triggered_by_client && first_record.ExceptionInformation[0] != 0) {
	// This special exception code indicates that the target was crashed by
	// another client calling CrashpadClient::DumpAndCrashTargetProcess(). In
	// this case the parameters are a thread id and an exception code which we
	// use to fabricate a new exception record.
	using ArgumentType = decltype(first_record.ExceptionInformation[0]);
	const ArgumentType blame_thread_id = first_record.ExceptionInformation[0];
	exception_code_ = static_cast<DWORD>(first_record.ExceptionInformation[1]);
	exception_flags_ = EXCEPTION_NONCONTINUABLE;
	for (const auto& thread : process_reader->Threads()) {
	if (thread.id == blame_thread_id) {
	thread_id_ = blame_thread_id;
	native_to_cpu_context(thread.context.context<const ContextType>(),
	&context_,
	&context_union_);
	exception_address_ = context_.InstructionPointer();
	break;
	}
	}

	if (exception_address_ == 0) {
	LOG(WARNING) << "thread " << blame_thread_id << " not found";
	return false;
	}
	} else {
	// Normal case.
	exception_code_ = first_record.ExceptionCode;
	exception_flags_ = first_record.ExceptionFlags;
	exception_address_ = first_record.ExceptionAddress;

	const DWORD number_parameters = std::min<DWORD>(
	first_record.NumberParameters, EXCEPTION_MAXIMUM_PARAMETERS);
	for (DWORD i = 0; i < number_parameters; ++i) {
	codes_.push_back(first_record.ExceptionInformation[i]);
	}
	if (first_record.ExceptionRecord) {
	// https://crashpad.chromium.org/bug/43
	LOG(WARNING) << "dropping chained ExceptionRecord";
	}

	ContextType context_record;
	if (!process_reader->Memory()->Read(
	static_cast<WinVMAddress>(exception_pointers.ContextRecord),
	sizeof(context_record),
	&context_record)) {
	LOG(ERROR) << "ContextRecord";
	return false;
	}

	native_to_cpu_context(&context_record, &context_, &context_union_);
	}

	return true;
	}

	} // namespace internal
	} // namespace crashpad