components/browser_watcher/activity_report_user_stream_data_source.cc - chromium/src - Git at Google

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "components/browser_watcher/activity_report_user_stream_data_source.h"

 #include <string>
 #include <utility>

 #include <windows.h>

 // Must be included after windows.h.
 #include <psapi.h>

 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/memory/free_deleter.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/metrics/persistent_memory_allocator.h"
 #include "base/process/memory.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
 #include "components/browser_watcher/activity_report_extractor.h"
 #include "components/browser_watcher/activity_tracker_annotation.h"
 #include "components/browser_watcher/extended_crash_reporting_metrics.h"
 #include "components/browser_watcher/minidump_user_streams.h"
 #include "third_party/crashpad/crashpad/minidump/minidump_user_extension_stream_data_source.h"
 #include "third_party/crashpad/crashpad/snapshot/annotation_snapshot.h"
 #include "third_party/crashpad/crashpad/snapshot/exception_snapshot.h"
 #include "third_party/crashpad/crashpad/snapshot/module_snapshot.h"
 #include "third_party/crashpad/crashpad/snapshot/process_snapshot.h"
 #include "third_party/crashpad/crashpad/util/process/process_memory.h"

 namespace browser_watcher {

 namespace {

 // TODO(siggi): Refactor this to harmonize with the activity tracker setup.
 const size_t kMaxActivityAnnotationSize = 2 << 20;

 using UniqueMallocPtr = std::unique_ptr<void, base::FreeDeleter>;

 UniqueMallocPtr UncheckedAllocate(size_t size) {
   void* raw_ptr = nullptr;
   if (!base::UncheckedMalloc(size, &raw_ptr))
     return UniqueMallocPtr();

   return UniqueMallocPtr(raw_ptr);
 }

 // A PersistentMemoryAllocator subclass that can take ownership of a buffer
 // that's allocated with a malloc-compatible allocation function.
 class MallocMemoryAllocator : public base::PersistentMemoryAllocator {
  public:
   MallocMemoryAllocator(UniqueMallocPtr buffer, size_t size);
   ~MallocMemoryAllocator() override;
 };

 MallocMemoryAllocator::MallocMemoryAllocator(UniqueMallocPtr buffer,
                                              size_t size)
     : base::PersistentMemoryAllocator(buffer.release(), size, 0, 0, "", true) {}

 MallocMemoryAllocator::~MallocMemoryAllocator() {
   free(const_cast<char*>(mem_base_));
 }

 class BufferExtensionStreamDataSource final
     : public crashpad::MinidumpUserExtensionStreamDataSource {
  public:
   explicit BufferExtensionStreamDataSource(uint32_t stream_type);

   bool Init(const StabilityReport& report);

   size_t StreamDataSize() override;
   bool ReadStreamData(Delegate* delegate) override;

  private:
   std::string data_;

   DISALLOW_COPY_AND_ASSIGN(BufferExtensionStreamDataSource);
 };

 BufferExtensionStreamDataSource::BufferExtensionStreamDataSource(
     uint32_t stream_type)
     : crashpad::MinidumpUserExtensionStreamDataSource(stream_type) {}

 bool BufferExtensionStreamDataSource::Init(const StabilityReport& report) {
   if (report.SerializeToString(&data_))
     return true;
   data_.clear();
   return false;
 }

 size_t BufferExtensionStreamDataSource::StreamDataSize() {
   DCHECK(!data_.empty());
   return data_.size();
 }

 bool BufferExtensionStreamDataSource::ReadStreamData(Delegate* delegate) {
   DCHECK(!data_.empty());
   return delegate->ExtensionStreamDataSourceRead(
       data_.size() ? data_.data() : nullptr, data_.size());
 }

 // TODO(manzagop): Collection should factor in whether this is a true crash or
 // dump without crashing.
 bool CollectStabilityReport(
     std::unique_ptr<base::debug::GlobalActivityAnalyzer> global_analyzer,
     StabilityReport* report) {
   CollectionStatus status = ANALYZER_CREATION_FAILED;
   if (global_analyzer)
     status = Extract(std::move(global_analyzer), report);

   base::UmaHistogramEnumeration("ActivityTracker.CollectCrash.Status", status,
                                 COLLECTION_STATUS_MAX);
   if (status != SUCCESS)
     return false;

   LogCollectOnCrashEvent(CollectOnCrashEvent::kReportExtractionSuccess);

   return true;
 }

 void CollectSystemPerformanceMetrics(StabilityReport* report) {
   // Grab system commit memory. Also best effort.
   PERFORMANCE_INFORMATION perf_info = {sizeof(perf_info)};
   if (GetPerformanceInfo(&perf_info, sizeof(perf_info))) {
     auto* memory_state =
         report->mutable_system_memory_state()->mutable_windows_memory();

     memory_state->set_system_commit_limit(perf_info.CommitLimit);
     memory_state->set_system_commit_remaining(perf_info.CommitLimit -
                                               perf_info.CommitTotal);
     memory_state->set_system_handle_count(perf_info.HandleCount);
   }
 }

 void CollectProcessPerformanceMetrics(
     crashpad::ProcessSnapshot* process_snapshot,
     StabilityReport* report) {
   const crashpad::ExceptionSnapshot* exception = process_snapshot->Exception();

   if (!exception)
     return;

   // Find or create the ProcessState for the process in question.
   base::ProcessId pid = process_snapshot->ProcessID();
   ProcessState* process_state = nullptr;
   for (int i = 0; i < report->process_states_size(); ++i) {
     ProcessState* temp = report->mutable_process_states(i);

     if (temp->has_process_id() && temp->process_id() == pid) {
       process_state = temp;
       break;
     }
   }

   if (!process_state) {
     process_state = report->add_process_states();
     process_state->set_process_id(pid);
   }

   auto* memory_state =
       process_state->mutable_memory_state()->mutable_windows_memory();

   // Grab the requested allocation size in case of OOM exception.
   if (exception->Exception() == base::win::kOomExceptionCode) {
     const auto& codes = exception->Codes();
     if (codes.size()) {
       // The first parameter, if present, is the size of the allocation attempt.
       memory_state->set_process_allocation_attempt(codes[0]);
     }
   }

   base::Process process(base::Process::OpenWithAccess(
       pid, PROCESS_QUERY_LIMITED_INFORMATION | PROCESS_VM_READ));

   if (process.IsValid()) {
     PROCESS_MEMORY_COUNTERS_EX process_memory = {sizeof(process_memory)};
     if (::GetProcessMemoryInfo(
             process.Handle(),
             reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&process_memory),
             sizeof(process_memory))) {
       // This is in units of bytes, re-scale to pages for consistency with
       // system metrics.
       const uint64_t kPageSize = 4096;
       memory_state->set_process_private_usage(process_memory.PrivateUsage /
                                               kPageSize);
       memory_state->set_process_peak_workingset_size(
           process_memory.PeakWorkingSetSize / kPageSize);
       memory_state->set_process_peak_pagefile_usage(
           process_memory.PeakPagefileUsage / kPageSize);
     }

     DWORD process_handle_count = 0;
     if (::GetProcessHandleCount(process.Handle(), &process_handle_count)) {
       memory_state->set_process_handle_count(process_handle_count);
     }
   }
 }

 // If the process has a beacon for in-memory activities, returns an analyzer
 // for it.
 std::unique_ptr<base::debug::GlobalActivityAnalyzer>
 MaybeGetInMemoryActivityAnalyzer(crashpad::ProcessSnapshot* process_snapshot) {
   if (!process_snapshot->Memory())
     return nullptr;

   auto modules = process_snapshot->Modules();
   for (auto* module : modules) {
     auto annotations = module->AnnotationObjects();
     for (const auto& annotation : annotations) {
       if (annotation.name == ActivityTrackerAnnotation::kAnnotationName &&
           annotation.type == static_cast<uint16_t>(
                                  ActivityTrackerAnnotation::kAnnotationType) &&
           annotation.value.size() ==
               sizeof(ActivityTrackerAnnotation::ValueType)) {
         // Re-cast the annotation to its value type.
         ActivityTrackerAnnotation::ValueType value;
         memcpy(&value, annotation.value.data(), sizeof(value));

         // Check the size field for sanity.
         if (value.size > kMaxActivityAnnotationSize)
           continue;

         // Allocate the buffer with no terminate-on-exhaustion to make sure
         // this can't be used to bring down the handler and thus elide
         // crash reporting.
         UniqueMallocPtr buffer = UncheckedAllocate(value.size);
         if (!buffer || !base::PersistentMemoryAllocator::IsMemoryAcceptable(
                            buffer.get(), value.size, 0, true)) {
           continue;
         }

         // Read the activity tracker data from the crashed process.
         if (process_snapshot->Memory()->Read(value.address, value.size,
                                              buffer.get())) {
           // Success - wrap an allocator on the buffer, and an analyzer on that.
           std::unique_ptr<MallocMemoryAllocator> allocator =
               std::make_unique<MallocMemoryAllocator>(std::move(buffer),
                                                       value.size);

           return base::debug::GlobalActivityAnalyzer::CreateWithAllocator(
               std::move(allocator));
         } else {
           return nullptr;
         }
       }
     }
   }

   return nullptr;
 }

 }  // namespace

 ActivityReportUserStreamDataSource::ActivityReportUserStreamDataSource(
     const base::FilePath& user_data_dir)
     : user_data_dir_(user_data_dir) {}

 std::unique_ptr<crashpad::MinidumpUserExtensionStreamDataSource>
 ActivityReportUserStreamDataSource::ProduceStreamData(
     crashpad::ProcessSnapshot* process_snapshot) {
   DCHECK(process_snapshot);
   LogCollectOnCrashEvent(CollectOnCrashEvent::kCollectAttempt);

   StabilityReport report;

   // See whether there's an activity tracking report beacon in the process'
   // annotations.
   std::unique_ptr<base::debug::GlobalActivityAnalyzer> global_analyzer =
       MaybeGetInMemoryActivityAnalyzer(process_snapshot);
   bool collected_report = false;
   if (global_analyzer) {
     LogCollectOnCrashEvent(CollectOnCrashEvent::kInMemoryAnnotationExists);

     collected_report =
         CollectStabilityReport(std::move(global_analyzer), &report);
   }

   CollectSystemPerformanceMetrics(&report);
   CollectProcessPerformanceMetrics(process_snapshot, &report);

   std::unique_ptr<BufferExtensionStreamDataSource> source(
       new BufferExtensionStreamDataSource(kActivityReportStreamType));
   if (!source->Init(report))
     return nullptr;

   if (collected_report)
     LogCollectOnCrashEvent(CollectOnCrashEvent::kSuccess);

   return source;
 }

 }  // namespace browser_watcher
	// Copyright 2017 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "components/browser_watcher/activity_report_user_stream_data_source.h"

	#include <string>
	#include <utility>

	#include <windows.h>

	// Must be included after windows.h.
	#include <psapi.h>

	#include "base/files/file.h"
	#include "base/files/file_util.h"
	#include "base/memory/free_deleter.h"
	#include "base/metrics/histogram_functions.h"
	#include "base/metrics/persistent_memory_allocator.h"
	#include "base/process/memory.h"
	#include "base/process/process.h"
	#include "base/strings/string16.h"
	#include "base/time/time.h"
	#include "components/browser_watcher/activity_report_extractor.h"
	#include "components/browser_watcher/activity_tracker_annotation.h"
	#include "components/browser_watcher/extended_crash_reporting_metrics.h"
	#include "components/browser_watcher/minidump_user_streams.h"
	#include "third_party/crashpad/crashpad/minidump/minidump_user_extension_stream_data_source.h"
	#include "third_party/crashpad/crashpad/snapshot/annotation_snapshot.h"
	#include "third_party/crashpad/crashpad/snapshot/exception_snapshot.h"
	#include "third_party/crashpad/crashpad/snapshot/module_snapshot.h"
	#include "third_party/crashpad/crashpad/snapshot/process_snapshot.h"
	#include "third_party/crashpad/crashpad/util/process/process_memory.h"

	namespace browser_watcher {

	namespace {

	// TODO(siggi): Refactor this to harmonize with the activity tracker setup.
	const size_t kMaxActivityAnnotationSize = 2 << 20;

	using UniqueMallocPtr = std::unique_ptr<void, base::FreeDeleter>;

	UniqueMallocPtr UncheckedAllocate(size_t size) {
	void* raw_ptr = nullptr;
	if (!base::UncheckedMalloc(size, &raw_ptr))
	return UniqueMallocPtr();

	return UniqueMallocPtr(raw_ptr);
	}

	// A PersistentMemoryAllocator subclass that can take ownership of a buffer
	// that's allocated with a malloc-compatible allocation function.
	class MallocMemoryAllocator : public base::PersistentMemoryAllocator {
	public:
	MallocMemoryAllocator(UniqueMallocPtr buffer, size_t size);
	~MallocMemoryAllocator() override;
	};

	MallocMemoryAllocator::MallocMemoryAllocator(UniqueMallocPtr buffer,
	size_t size)
	: base::PersistentMemoryAllocator(buffer.release(), size, 0, 0, "", true) {}

	MallocMemoryAllocator::~MallocMemoryAllocator() {
	free(const_cast<char*>(mem_base_));
	}

	class BufferExtensionStreamDataSource final
	: public crashpad::MinidumpUserExtensionStreamDataSource {
	public:
	explicit BufferExtensionStreamDataSource(uint32_t stream_type);

	bool Init(const StabilityReport& report);

	size_t StreamDataSize() override;
	bool ReadStreamData(Delegate* delegate) override;

	private:
	std::string data_;

	DISALLOW_COPY_AND_ASSIGN(BufferExtensionStreamDataSource);
	};

	BufferExtensionStreamDataSource::BufferExtensionStreamDataSource(
	uint32_t stream_type)
	: crashpad::MinidumpUserExtensionStreamDataSource(stream_type) {}

	bool BufferExtensionStreamDataSource::Init(const StabilityReport& report) {
	if (report.SerializeToString(&data_))
	return true;
	data_.clear();
	return false;
	}

	size_t BufferExtensionStreamDataSource::StreamDataSize() {
	DCHECK(!data_.empty());
	return data_.size();
	}

	bool BufferExtensionStreamDataSource::ReadStreamData(Delegate* delegate) {
	DCHECK(!data_.empty());
	return delegate->ExtensionStreamDataSourceRead(
	data_.size() ? data_.data() : nullptr, data_.size());
	}

	// TODO(manzagop): Collection should factor in whether this is a true crash or
	// dump without crashing.
	bool CollectStabilityReport(
	std::unique_ptr<base::debug::GlobalActivityAnalyzer> global_analyzer,
	StabilityReport* report) {
	CollectionStatus status = ANALYZER_CREATION_FAILED;
	if (global_analyzer)
	status = Extract(std::move(global_analyzer), report);

	base::UmaHistogramEnumeration("ActivityTracker.CollectCrash.Status", status,
	COLLECTION_STATUS_MAX);
	if (status != SUCCESS)
	return false;

	LogCollectOnCrashEvent(CollectOnCrashEvent::kReportExtractionSuccess);

	return true;
	}

	void CollectSystemPerformanceMetrics(StabilityReport* report) {
	// Grab system commit memory. Also best effort.
	PERFORMANCE_INFORMATION perf_info = {sizeof(perf_info)};
	if (GetPerformanceInfo(&perf_info, sizeof(perf_info))) {
	auto* memory_state =
	report->mutable_system_memory_state()->mutable_windows_memory();

	memory_state->set_system_commit_limit(perf_info.CommitLimit);
	memory_state->set_system_commit_remaining(perf_info.CommitLimit -
	perf_info.CommitTotal);
	memory_state->set_system_handle_count(perf_info.HandleCount);
	}
	}

	void CollectProcessPerformanceMetrics(
	crashpad::ProcessSnapshot* process_snapshot,
	StabilityReport* report) {
	const crashpad::ExceptionSnapshot* exception = process_snapshot->Exception();

	if (!exception)
	return;

	// Find or create the ProcessState for the process in question.
	base::ProcessId pid = process_snapshot->ProcessID();
	ProcessState* process_state = nullptr;
	for (int i = 0; i < report->process_states_size(); ++i) {
	ProcessState* temp = report->mutable_process_states(i);

	if (temp->has_process_id() && temp->process_id() == pid) {
	process_state = temp;
	break;
	}
	}

	if (!process_state) {
	process_state = report->add_process_states();
	process_state->set_process_id(pid);
	}

	auto* memory_state =
	process_state->mutable_memory_state()->mutable_windows_memory();

	// Grab the requested allocation size in case of OOM exception.
	if (exception->Exception() == base::win::kOomExceptionCode) {
	const auto& codes = exception->Codes();
	if (codes.size()) {
	// The first parameter, if present, is the size of the allocation attempt.
	memory_state->set_process_allocation_attempt(codes[0]);
	}
	}

	base::Process process(base::Process::OpenWithAccess(
	pid, PROCESS_QUERY_LIMITED_INFORMATION \| PROCESS_VM_READ));

	if (process.IsValid()) {
	PROCESS_MEMORY_COUNTERS_EX process_memory = {sizeof(process_memory)};
	if (::GetProcessMemoryInfo(
	process.Handle(),
	reinterpret_cast<PROCESS_MEMORY_COUNTERS*>(&process_memory),
	sizeof(process_memory))) {
	// This is in units of bytes, re-scale to pages for consistency with
	// system metrics.
	const uint64_t kPageSize = 4096;
	memory_state->set_process_private_usage(process_memory.PrivateUsage /
	kPageSize);
	memory_state->set_process_peak_workingset_size(
	process_memory.PeakWorkingSetSize / kPageSize);
	memory_state->set_process_peak_pagefile_usage(
	process_memory.PeakPagefileUsage / kPageSize);
	}

	DWORD process_handle_count = 0;
	if (::GetProcessHandleCount(process.Handle(), &process_handle_count)) {
	memory_state->set_process_handle_count(process_handle_count);
	}
	}
	}

	// If the process has a beacon for in-memory activities, returns an analyzer
	// for it.
	std::unique_ptr<base::debug::GlobalActivityAnalyzer>
	MaybeGetInMemoryActivityAnalyzer(crashpad::ProcessSnapshot* process_snapshot) {
	if (!process_snapshot->Memory())
	return nullptr;

	auto modules = process_snapshot->Modules();
	for (auto* module : modules) {
	auto annotations = module->AnnotationObjects();
	for (const auto& annotation : annotations) {
	if (annotation.name == ActivityTrackerAnnotation::kAnnotationName &&
	annotation.type == static_cast<uint16_t>(
	ActivityTrackerAnnotation::kAnnotationType) &&
	annotation.value.size() ==
	sizeof(ActivityTrackerAnnotation::ValueType)) {
	// Re-cast the annotation to its value type.
	ActivityTrackerAnnotation::ValueType value;
	memcpy(&value, annotation.value.data(), sizeof(value));

	// Check the size field for sanity.
	if (value.size > kMaxActivityAnnotationSize)
	continue;

	// Allocate the buffer with no terminate-on-exhaustion to make sure
	// this can't be used to bring down the handler and thus elide
	// crash reporting.
	UniqueMallocPtr buffer = UncheckedAllocate(value.size);
	if (!buffer \|\| !base::PersistentMemoryAllocator::IsMemoryAcceptable(
	buffer.get(), value.size, 0, true)) {
	continue;
	}

	// Read the activity tracker data from the crashed process.
	if (process_snapshot->Memory()->Read(value.address, value.size,
	buffer.get())) {
	// Success - wrap an allocator on the buffer, and an analyzer on that.
	std::unique_ptr<MallocMemoryAllocator> allocator =
	std::make_unique<MallocMemoryAllocator>(std::move(buffer),
	value.size);

	return base::debug::GlobalActivityAnalyzer::CreateWithAllocator(
	std::move(allocator));
	} else {
	return nullptr;
	}
	}
	}
	}

	return nullptr;
	}

	} // namespace

	ActivityReportUserStreamDataSource::ActivityReportUserStreamDataSource(
	const base::FilePath& user_data_dir)
	: user_data_dir_(user_data_dir) {}

	std::unique_ptr<crashpad::MinidumpUserExtensionStreamDataSource>
	ActivityReportUserStreamDataSource::ProduceStreamData(
	crashpad::ProcessSnapshot* process_snapshot) {
	DCHECK(process_snapshot);
	LogCollectOnCrashEvent(CollectOnCrashEvent::kCollectAttempt);

	StabilityReport report;

	// See whether there's an activity tracking report beacon in the process'
	// annotations.
	std::unique_ptr<base::debug::GlobalActivityAnalyzer> global_analyzer =
	MaybeGetInMemoryActivityAnalyzer(process_snapshot);
	bool collected_report = false;
	if (global_analyzer) {
	LogCollectOnCrashEvent(CollectOnCrashEvent::kInMemoryAnnotationExists);

	collected_report =
	CollectStabilityReport(std::move(global_analyzer), &report);
	}

	CollectSystemPerformanceMetrics(&report);
	CollectProcessPerformanceMetrics(process_snapshot, &report);

	std::unique_ptr<BufferExtensionStreamDataSource> source(
	new BufferExtensionStreamDataSource(kActivityReportStreamType));
	if (!source->Init(report))
	return nullptr;

	if (collected_report)
	LogCollectOnCrashEvent(CollectOnCrashEvent::kSuccess);

	return source;
	}

	} // namespace browser_watcher