snapshot/ios/thread_snapshot_ios_intermediate_dump.cc - crashpad/crashpad - Git at Google

 // Copyright 2020 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/ios/thread_snapshot_ios_intermediate_dump.h"

 #include "base/apple/mach_logging.h"
 #include "snapshot/ios/intermediate_dump_reader_util.h"
 #include "snapshot/mac/cpu_context_mac.h"
 #include "util/ios/ios_intermediate_dump_data.h"
 #include "util/ios/ios_intermediate_dump_list.h"
 #include "util/ios/ios_intermediate_dump_map.h"

 #include <vector>

 namespace {

 std::vector<uint8_t> GenerateStackMemoryFromFrames(const uint64_t* frames,
                                                    const size_t frame_count) {
   std::vector<uint8_t> stack_memory;
   if (frame_count < 2) {
     return stack_memory;
   }
   size_t pointer_size = sizeof(uintptr_t);
   size_t frame_record_size = 2 * pointer_size;
   size_t stack_size = frame_record_size * (frame_count - 1) + pointer_size;
   stack_memory.resize(stack_size);
   uintptr_t sp = stack_size - pointer_size;
   uintptr_t fp = 0;
   uintptr_t lr = 0;
   for (size_t current_frame = frame_count - 1; current_frame > 0;
        --current_frame) {
     memcpy(&stack_memory[0] + sp, &lr, sizeof(lr));
     sp -= pointer_size;
     memcpy(&stack_memory[0] + sp, &fp, sizeof(fp));
     fp = sp;
     sp -= pointer_size;
     lr = frames[current_frame];
   }

   if (sp != 0) {
     LOG(ERROR) << "kExpectedFinalSp should be 0, is " << sp;
   }
   if (fp != sizeof(uintptr_t)) {
     LOG(ERROR) << "kExpectedFinalFp should be sizeof(uintptr_t), is " << fp;
   }
   if (lr != frames[1]) {
     LOG(ERROR) << "lr should be " << frames[1] << ", is " << lr;
   }
   return stack_memory;
 }

 }  // namespace
 namespace crashpad {
 namespace internal {

 using Key = IntermediateDumpKey;

 ThreadSnapshotIOSIntermediateDump::ThreadSnapshotIOSIntermediateDump()
     : ThreadSnapshot(),
 #if defined(ARCH_CPU_X86_64)
       context_x86_64_(),
 #elif defined(ARCH_CPU_ARM64)
       context_arm64_(),
 #endif
       context_(),
       stack_(),
       thread_name_(),
       thread_id_(0),
       thread_specific_data_address_(0),
       suspend_count_(0),
       priority_(0),
       initialized_() {
 #if defined(ARCH_CPU_X86_64)
   context_.architecture = kCPUArchitectureX86_64;
   context_.x86_64 = &context_x86_64_;
 #elif defined(ARCH_CPU_ARM64)
   context_.architecture = kCPUArchitectureARM64;
   context_.arm64 = &context_arm64_;
 #endif
 }

 ThreadSnapshotIOSIntermediateDump::~ThreadSnapshotIOSIntermediateDump() {}

 bool ThreadSnapshotIOSIntermediateDump::Initialize(
     const IOSIntermediateDumpMap* thread_data) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);

   GetDataValueFromMap(thread_data, Key::kSuspendCount, &suspend_count_);
   GetDataValueFromMap(thread_data, Key::kPriority, &priority_);
   GetDataValueFromMap(thread_data, Key::kThreadID, &thread_id_);
   GetDataValueFromMap(
       thread_data, Key::kThreadDataAddress, &thread_specific_data_address_);
   GetDataStringFromMap(thread_data, Key::kThreadName, &thread_name_);

 #if defined(ARCH_CPU_X86_64)
   typedef x86_thread_state64_t thread_state_type;
   typedef x86_float_state64_t float_state_type;
   typedef x86_debug_state64_t debug_state_type;
 #elif defined(ARCH_CPU_ARM64)
   typedef arm_thread_state64_t thread_state_type;
   typedef arm_neon_state64_t float_state_type;
   typedef arm_debug_state64_t debug_state_type;
 #endif

   thread_state_type thread_state;
   float_state_type float_state;
   debug_state_type debug_state;

   const IOSIntermediateDumpData* nsexception_frames =
       thread_data->GetAsData(Key::kThreadUncaughtNSExceptionFrames);
   const IOSIntermediateDumpData* thread_stack_data_dump =
       thread_data->GetAsData(Key::kStackRegionData);
   if (nsexception_frames && thread_stack_data_dump) {
     LOG(ERROR) << "Unexpected thread with kStackRegionData and "
                << "kThreadUncaughtNSExceptionFrames, using kStackRegionData";
   }
   if (thread_stack_data_dump) {
     vm_address_t stack_region_address;
     GetDataValueFromMap(
         thread_data, Key::kStackRegionAddress, &stack_region_address);

     const std::vector<uint8_t>& bytes = thread_stack_data_dump->bytes();
     const vm_address_t stack_region_data =
         reinterpret_cast<const vm_address_t>(bytes.data());
     vm_size_t stack_region_size = bytes.size();
     stack_.Initialize(
         stack_region_address, stack_region_data, stack_region_size);
   } else if (nsexception_frames) {
     const std::vector<uint8_t>& bytes = nsexception_frames->bytes();
     const uint64_t* frames = reinterpret_cast<const uint64_t*>(bytes.data());
     size_t frame_count = bytes.size() / sizeof(uint64_t);
     exception_stack_memory_ =
         GenerateStackMemoryFromFrames(frames, frame_count);
     vm_address_t stack_memory_addr =
         !exception_stack_memory_.empty()
             ? reinterpret_cast<vm_address_t>(&exception_stack_memory_[0])
             : 0;
     stack_.Initialize(0, stack_memory_addr, exception_stack_memory_.size());
   } else {
     stack_.Initialize(0, 0, 0);
   }

   if (GetDataValueFromMap(thread_data, Key::kThreadState, &thread_state) &&
       GetDataValueFromMap(thread_data, Key::kFloatState, &float_state) &&
       GetDataValueFromMap(thread_data, Key::kDebugState, &debug_state)) {
 #if defined(ARCH_CPU_X86_64)
     InitializeCPUContextX86_64(&context_x86_64_,
                                THREAD_STATE_NONE,
                                nullptr,
                                0,
                                &thread_state,
                                &float_state,
                                &debug_state);
 #elif defined(ARCH_CPU_ARM64)
     InitializeCPUContextARM64(&context_arm64_,
                               THREAD_STATE_NONE,
                               nullptr,
                               0,
                               &thread_state,
                               &float_state,
                               &debug_state);

 #else
 #error Port to your CPU architecture
 #endif
   }
   const IOSIntermediateDumpList* thread_context_memory_regions =
       GetListFromMap(thread_data, Key::kThreadContextMemoryRegions);
   if (thread_context_memory_regions) {
     for (auto& region : *thread_context_memory_regions) {
       vm_address_t address;
       const IOSIntermediateDumpData* region_data =
           region->GetAsData(Key::kThreadContextMemoryRegionData);
       if (!region_data)
         continue;
       if (GetDataValueFromMap(
               region.get(), Key::kThreadContextMemoryRegionAddress, &address)) {
         const std::vector<uint8_t>& bytes = region_data->bytes();
         vm_size_t data_size = bytes.size();
         if (data_size == 0)
           continue;

         const vm_address_t data =
             reinterpret_cast<const vm_address_t>(bytes.data());

         auto memory =
             std::make_unique<internal::MemorySnapshotIOSIntermediateDump>();
         memory->Initialize(address, data, data_size);
         extra_memory_.push_back(std::move(memory));
       }
     }
   }

   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 const CPUContext* ThreadSnapshotIOSIntermediateDump::Context() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return &context_;
 }

 const MemorySnapshot* ThreadSnapshotIOSIntermediateDump::Stack() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return &stack_;
 }

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

 std::string ThreadSnapshotIOSIntermediateDump::ThreadName() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return thread_name_;
 }

 int ThreadSnapshotIOSIntermediateDump::SuspendCount() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return suspend_count_;
 }

 int ThreadSnapshotIOSIntermediateDump::Priority() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return priority_;
 }

 uint64_t ThreadSnapshotIOSIntermediateDump::ThreadSpecificDataAddress() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return thread_specific_data_address_;
 }

 std::vector<const MemorySnapshot*>
 ThreadSnapshotIOSIntermediateDump::ExtraMemory() const {
   std::vector<const MemorySnapshot*> extra_memory;
   for (const auto& memory : extra_memory_) {
     extra_memory.push_back(memory.get());
   }
   return extra_memory;
 }

 }  // namespace internal
 }  // namespace crashpad
	// Copyright 2020 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/ios/thread_snapshot_ios_intermediate_dump.h"

	#include "base/apple/mach_logging.h"
	#include "snapshot/ios/intermediate_dump_reader_util.h"
	#include "snapshot/mac/cpu_context_mac.h"
	#include "util/ios/ios_intermediate_dump_data.h"
	#include "util/ios/ios_intermediate_dump_list.h"
	#include "util/ios/ios_intermediate_dump_map.h"

	#include <vector>

	namespace {

	std::vector<uint8_t> GenerateStackMemoryFromFrames(const uint64_t* frames,
	const size_t frame_count) {
	std::vector<uint8_t> stack_memory;
	if (frame_count < 2) {
	return stack_memory;
	}
	size_t pointer_size = sizeof(uintptr_t);
	size_t frame_record_size = 2 * pointer_size;
	size_t stack_size = frame_record_size * (frame_count - 1) + pointer_size;
	stack_memory.resize(stack_size);
	uintptr_t sp = stack_size - pointer_size;
	uintptr_t fp = 0;
	uintptr_t lr = 0;
	for (size_t current_frame = frame_count - 1; current_frame > 0;
	--current_frame) {
	memcpy(&stack_memory[0] + sp, &lr, sizeof(lr));
	sp -= pointer_size;
	memcpy(&stack_memory[0] + sp, &fp, sizeof(fp));
	fp = sp;
	sp -= pointer_size;
	lr = frames[current_frame];
	}

	if (sp != 0) {
	LOG(ERROR) << "kExpectedFinalSp should be 0, is " << sp;
	}
	if (fp != sizeof(uintptr_t)) {
	LOG(ERROR) << "kExpectedFinalFp should be sizeof(uintptr_t), is " << fp;
	}
	if (lr != frames[1]) {
	LOG(ERROR) << "lr should be " << frames[1] << ", is " << lr;
	}
	return stack_memory;
	}

	} // namespace
	namespace crashpad {
	namespace internal {

	using Key = IntermediateDumpKey;

	ThreadSnapshotIOSIntermediateDump::ThreadSnapshotIOSIntermediateDump()
	: ThreadSnapshot(),
	#if defined(ARCH_CPU_X86_64)
	context_x86_64_(),
	#elif defined(ARCH_CPU_ARM64)
	context_arm64_(),
	#endif
	context_(),
	stack_(),
	thread_name_(),
	thread_id_(0),
	thread_specific_data_address_(0),
	suspend_count_(0),
	priority_(0),
	initialized_() {
	#if defined(ARCH_CPU_X86_64)
	context_.architecture = kCPUArchitectureX86_64;
	context_.x86_64 = &context_x86_64_;
	#elif defined(ARCH_CPU_ARM64)
	context_.architecture = kCPUArchitectureARM64;
	context_.arm64 = &context_arm64_;
	#endif
	}

	ThreadSnapshotIOSIntermediateDump::~ThreadSnapshotIOSIntermediateDump() {}

	bool ThreadSnapshotIOSIntermediateDump::Initialize(
	const IOSIntermediateDumpMap* thread_data) {
	INITIALIZATION_STATE_SET_INITIALIZING(initialized_);

	GetDataValueFromMap(thread_data, Key::kSuspendCount, &suspend_count_);
	GetDataValueFromMap(thread_data, Key::kPriority, &priority_);
	GetDataValueFromMap(thread_data, Key::kThreadID, &thread_id_);
	GetDataValueFromMap(
	thread_data, Key::kThreadDataAddress, &thread_specific_data_address_);
	GetDataStringFromMap(thread_data, Key::kThreadName, &thread_name_);

	#if defined(ARCH_CPU_X86_64)
	typedef x86_thread_state64_t thread_state_type;
	typedef x86_float_state64_t float_state_type;
	typedef x86_debug_state64_t debug_state_type;
	#elif defined(ARCH_CPU_ARM64)
	typedef arm_thread_state64_t thread_state_type;
	typedef arm_neon_state64_t float_state_type;
	typedef arm_debug_state64_t debug_state_type;
	#endif

	thread_state_type thread_state;
	float_state_type float_state;
	debug_state_type debug_state;

	const IOSIntermediateDumpData* nsexception_frames =
	thread_data->GetAsData(Key::kThreadUncaughtNSExceptionFrames);
	const IOSIntermediateDumpData* thread_stack_data_dump =
	thread_data->GetAsData(Key::kStackRegionData);
	if (nsexception_frames && thread_stack_data_dump) {
	LOG(ERROR) << "Unexpected thread with kStackRegionData and "
	<< "kThreadUncaughtNSExceptionFrames, using kStackRegionData";
	}
	if (thread_stack_data_dump) {
	vm_address_t stack_region_address;
	GetDataValueFromMap(
	thread_data, Key::kStackRegionAddress, &stack_region_address);

	const std::vector<uint8_t>& bytes = thread_stack_data_dump->bytes();
	const vm_address_t stack_region_data =
	reinterpret_cast<const vm_address_t>(bytes.data());
	vm_size_t stack_region_size = bytes.size();
	stack_.Initialize(
	stack_region_address, stack_region_data, stack_region_size);
	} else if (nsexception_frames) {
	const std::vector<uint8_t>& bytes = nsexception_frames->bytes();
	const uint64_t* frames = reinterpret_cast<const uint64_t*>(bytes.data());
	size_t frame_count = bytes.size() / sizeof(uint64_t);
	exception_stack_memory_ =
	GenerateStackMemoryFromFrames(frames, frame_count);
	vm_address_t stack_memory_addr =
	!exception_stack_memory_.empty()
	? reinterpret_cast<vm_address_t>(&exception_stack_memory_[0])
	: 0;
	stack_.Initialize(0, stack_memory_addr, exception_stack_memory_.size());
	} else {
	stack_.Initialize(0, 0, 0);
	}

	if (GetDataValueFromMap(thread_data, Key::kThreadState, &thread_state) &&
	GetDataValueFromMap(thread_data, Key::kFloatState, &float_state) &&
	GetDataValueFromMap(thread_data, Key::kDebugState, &debug_state)) {
	#if defined(ARCH_CPU_X86_64)
	InitializeCPUContextX86_64(&context_x86_64_,
	THREAD_STATE_NONE,
	nullptr,
	0,
	&thread_state,
	&float_state,
	&debug_state);
	#elif defined(ARCH_CPU_ARM64)
	InitializeCPUContextARM64(&context_arm64_,
	THREAD_STATE_NONE,
	nullptr,
	0,
	&thread_state,
	&float_state,
	&debug_state);

	#else
	#error Port to your CPU architecture
	#endif
	}
	const IOSIntermediateDumpList* thread_context_memory_regions =
	GetListFromMap(thread_data, Key::kThreadContextMemoryRegions);
	if (thread_context_memory_regions) {
	for (auto& region : *thread_context_memory_regions) {
	vm_address_t address;
	const IOSIntermediateDumpData* region_data =
	region->GetAsData(Key::kThreadContextMemoryRegionData);
	if (!region_data)
	continue;
	if (GetDataValueFromMap(
	region.get(), Key::kThreadContextMemoryRegionAddress, &address)) {
	const std::vector<uint8_t>& bytes = region_data->bytes();
	vm_size_t data_size = bytes.size();
	if (data_size == 0)
	continue;

	const vm_address_t data =
	reinterpret_cast<const vm_address_t>(bytes.data());

	auto memory =
	std::make_unique<internal::MemorySnapshotIOSIntermediateDump>();
	memory->Initialize(address, data, data_size);
	extra_memory_.push_back(std::move(memory));
	}
	}
	}

	INITIALIZATION_STATE_SET_VALID(initialized_);
	return true;
	}
	const CPUContext* ThreadSnapshotIOSIntermediateDump::Context() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return &context_;
	}

	const MemorySnapshot* ThreadSnapshotIOSIntermediateDump::Stack() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return &stack_;
	}

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

	std::string ThreadSnapshotIOSIntermediateDump::ThreadName() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return thread_name_;
	}

	int ThreadSnapshotIOSIntermediateDump::SuspendCount() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return suspend_count_;
	}

	int ThreadSnapshotIOSIntermediateDump::Priority() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return priority_;
	}

	uint64_t ThreadSnapshotIOSIntermediateDump::ThreadSpecificDataAddress() const {
	INITIALIZATION_STATE_DCHECK_VALID(initialized_);
	return thread_specific_data_address_;
	}

	std::vector<const MemorySnapshot*>
	ThreadSnapshotIOSIntermediateDump::ExtraMemory() const {
	std::vector<const MemorySnapshot*> extra_memory;
	for (const auto& memory : extra_memory_) {
	extra_memory.push_back(memory.get());
	}
	return extra_memory;
	}

	} // namespace internal
	} // namespace crashpad