Track number of instances with a corrupt allocator.

base/metrics/histogram_persistence.cc

 // Copyright (c) 2015 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/metrics/histogram_persistence.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
@@ skipping 28 matching lines @@
 
   // Could not allocate histogram memory due to lack of space.
   CREATE_HISTOGRAM_ALLOCATOR_FULL,
 
   // Could not allocate histogram memory due to unknown error.
   CREATE_HISTOGRAM_ALLOCATOR_ERROR,
 
   // Histogram was of unknown type.
   CREATE_HISTOGRAM_UNKNOWN_TYPE,
 
+  // Instance has detected a corrupt allocator (recorded only once).
+  CREATE_HISTOGRAM_ALLOCATOR_NEWLY_CORRUPT,
+
   // Always keep this at the end.
   CREATE_HISTOGRAM_MAX
 };
 
 // Type identifiers used when storing in persistent memory so they can be
 // identified during extraction; the first 4 bytes of the SHA1 of the name
 // is used as a unique integer. A "version number" is added to the base
 // so that, if the structure of that object changes, stored older versions
 // will be safely ignored.
 enum : uint32_t {
@@ skipping 276 matching lines @@
     HistogramType histogram_type,
     const std::string& name,
     int minimum,
     int maximum,
     const BucketRanges* bucket_ranges,
     int32_t flags,
     PersistentMemoryAllocator::Reference* ref_ptr) {
   if (!allocator)
     return nullptr;
 
+  // If the allocator is corrupt, don't waste time trying anything else.
+  // This also allows differentiating on the dashboard between allocations
+  // failed due to a corrupt allocator and the number of process instances
+  // with one, the latter being idicated by "newly corrupt", below.
+  if (allocator->IsCorrupt()) {
+    RecordCreateHistogramResult(CREATE_HISTOGRAM_ALLOCATOR_CORRUPT);
+    return nullptr;
+  }
+
   size_t bucket_count = bucket_ranges->bucket_count();
   // An overflow such as this, perhaps as the result of a milicious actor,
   // could lead to writing beyond the allocation boundary and into other
   // memory. Just fail the allocation and let the caller deal with it.
   if (bucket_count > std::numeric_limits<int32_t>::max() /
                      sizeof(HistogramBase::AtomicCount)) {
     NOTREACHED();
     return nullptr;
   }
   size_t counts_bytes = bucket_count * sizeof(HistogramBase::AtomicCount);
@@ skipping 38 matching lines @@
     HistogramBase* histogram =
         CreatePersistentHistogram(allocator, histogram_data);
     DCHECK(histogram);
     if (ref_ptr != nullptr)
       *ref_ptr = histogram_ref;
     return histogram;
   }
 
   CreateHistogramResultType result;
   if (allocator->IsCorrupt()) {
+    RecordCreateHistogramResult(CREATE_HISTOGRAM_ALLOCATOR_NEWLY_CORRUPT);
     result = CREATE_HISTOGRAM_ALLOCATOR_CORRUPT;
   } else if (allocator->IsFull()) {
     result = CREATE_HISTOGRAM_ALLOCATOR_FULL;
   } else {
     result = CREATE_HISTOGRAM_ALLOCATOR_ERROR;
   }
   RecordCreateHistogramResult(result);
   NOTREACHED() << "error=" << result;
 
   return nullptr;
@@ skipping 17 matching lines @@
     for (;;) {
       HistogramBase* histogram = GetNextPersistentHistogram(g_allocator, &iter);
       if (!histogram)
         break;
       StatisticsRecorder::RegisterOrDeleteDuplicate(histogram);
     }
   }
 }
 
 }  // namespace base