Postmortem report collection: validate internal state

base/debug/activity_analyzer.cc

 // Copyright 2016 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 "base/debug/activity_analyzer.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 
 namespace base {
 namespace debug {
 
 namespace {
 // An empty snapshot that can be returned when there otherwise is none.
 LazyInstance<ActivityUserData::Snapshot>::Leaky g_empty_user_data_snapshot;
+
+#if !defined(OS_NACL)
+// DO NOT CHANGE VALUES. This is logged persistently in a histogram.
+enum AnalyzerCreationError {
+  kInvalidMemoryMappedFile,
+  kPmaBadFile,
+  kPmaUninitialized,
+  kPmaDeleted,
+  kPmaCorrupt,
+  kAnalyzerCreationErrorMax  // Keep this last.
+};
+
+void LogAnalyzerCreationError(AnalyzerCreationError error) {
+  UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.AnalyzerCreationError",
+                            error, kAnalyzerCreationErrorMax);
+}
+#endif  // !defined(OS_NACL)
+
 }  // namespace
 
 ThreadActivityAnalyzer::Snapshot::Snapshot() {}
 ThreadActivityAnalyzer::Snapshot::~Snapshot() {}
 
 ThreadActivityAnalyzer::ThreadActivityAnalyzer(
     const ThreadActivityTracker& tracker)
     : activity_snapshot_valid_(tracker.CreateSnapshot(&activity_snapshot_)) {}
 
 ThreadActivityAnalyzer::ThreadActivityAnalyzer(void* base, size_t size)
@@ skipping 22 matching lines @@
     // The global GetUserDataSnapshot will return an empty snapshot if the ref
     // or id is not valid.
     activity_snapshot_.user_data_stack.push_back(global->GetUserDataSnapshot(
         activity_snapshot_.process_id, activity.user_data_ref,
         activity.user_data_id));
   }
 }
 
 GlobalActivityAnalyzer::GlobalActivityAnalyzer(
     std::unique_ptr<PersistentMemoryAllocator> allocator)
-    : allocator_(std::move(allocator)), allocator_iterator_(allocator_.get()) {}
+    : allocator_(std::move(allocator)), allocator_iterator_(allocator_.get()) {
+  DCHECK(allocator_);
+}
 
 GlobalActivityAnalyzer::~GlobalActivityAnalyzer() {}
 
 #if !defined(OS_NACL)
 // static
 std::unique_ptr<GlobalActivityAnalyzer> GlobalActivityAnalyzer::CreateWithFile(
     const FilePath& file_path) {
   // Map the file read-write so it can guarantee consistency between
   // the analyzer and any trackers that my still be active.
   std::unique_ptr<MemoryMappedFile> mmfile(new MemoryMappedFile());
   mmfile->Initialize(file_path, MemoryMappedFile::READ_WRITE);
-  if (!mmfile->IsValid())
+  if (!mmfile->IsValid()) {
+    LogAnalyzerCreationError(kInvalidMemoryMappedFile);
     return nullptr;
+  }
 
-  if (!FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, true))
+  if (!FilePersistentMemoryAllocator::IsFileAcceptable(*mmfile, true)) {
+    LogAnalyzerCreationError(kPmaBadFile);
     return nullptr;
+  }
 
-  return WrapUnique(
-      new GlobalActivityAnalyzer(MakeUnique<FilePersistentMemoryAllocator>(
-          std::move(mmfile), 0, 0, base::StringPiece(), true)));
+  std::unique_ptr<FilePersistentMemoryAllocator> allocator(
+      new FilePersistentMemoryAllocator(std::move(mmfile), 0, 0,
+                                        base::StringPiece(), true));
+  if (allocator->GetMemoryState() ==
+      PersistentMemoryAllocator::MEMORY_UNINITIALIZED) {
+    LogAnalyzerCreationError(kPmaUninitialized);
+    return nullptr;
+  }
+  if (allocator->GetMemoryState() ==
+      PersistentMemoryAllocator::MEMORY_DELETED) {
+    LogAnalyzerCreationError(kPmaDeleted);
+    return nullptr;
+  }
+  if (allocator->IsCorrupt()) {
+    LogAnalyzerCreationError(kPmaCorrupt);
+    return nullptr;
+  }
+
+  return WrapUnique(new GlobalActivityAnalyzer(std::move(allocator)));
 }
 #endif  // !defined(OS_NACL)
 
 int64_t GlobalActivityAnalyzer::GetFirstProcess() {
   PrepareAllAnalyzers();
   return GetNextProcess();
 }
 
 int64_t GlobalActivityAnalyzer::GetNextProcess() {
   if (process_ids_.empty())
@@ skipping 111 matching lines @@
 
   return modules;
 }
 
 GlobalActivityAnalyzer::ProgramLocation
 GlobalActivityAnalyzer::GetProgramLocationFromAddress(uint64_t address) {
   // TODO(bcwhite): Implement this.
   return { 0, 0 };
 }
 
+bool GlobalActivityAnalyzer::IsDataComplete() const {
+  DCHECK(allocator_);
+  return !allocator_->IsFull();
+}
+
 GlobalActivityAnalyzer::UserDataSnapshot::UserDataSnapshot() {}
 GlobalActivityAnalyzer::UserDataSnapshot::UserDataSnapshot(
     const UserDataSnapshot& rhs) = default;
 GlobalActivityAnalyzer::UserDataSnapshot::UserDataSnapshot(
     UserDataSnapshot&& rhs) = default;
 GlobalActivityAnalyzer::UserDataSnapshot::~UserDataSnapshot() {}
 
 void GlobalActivityAnalyzer::PrepareAllAnalyzers() {
   // Record the time when analysis started.
   analysis_stamp_ = base::Time::Now().ToInternalValue();
@@ skipping 92 matching lines @@
       } break;
     }
   }
 
   // Reverse the list of PIDs so that they get popped in the order found.
   std::reverse(process_ids_.begin(), process_ids_.end());
 }
 
 }  // namespace debug
 }  // namespace base