Handle failures allocating mapped local memory.

base/metrics/persistent_memory_allocator.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/persistent_memory_allocator.h"
 
 #include <assert.h>
 #include <algorithm>
 
 #if defined(OS_WIN)
 #include "winbase.h"
 #elif defined(OS_POSIX)
 #include <sys/mman.h>
 #endif
 
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/sparse_histogram.h"
 
 namespace {
 
 // Limit of memory segment size. It has to fit in an unsigned 32-bit number
 // and should be a power of 2 in order to accomodate almost any page size.
 const uint32_t kSegmentMaxSize = 1 << 30;  // 1 GiB
 
 // A constant (random) value placed in the shared metadata to identify
 // an already initialized memory segment.
 const uint32_t kGlobalCookie = 0x408305DC;
@@ skipping 707 matching lines @@
     base::StringPiece name)
     : PersistentMemoryAllocator(AllocateLocalMemory(size),
                                 size, 0, id, name, false) {}
 
 LocalPersistentMemoryAllocator::~LocalPersistentMemoryAllocator() {
   DeallocateLocalMemory(const_cast<char*>(mem_base_), mem_size_);
 }
 
 // static
 void* LocalPersistentMemoryAllocator::AllocateLocalMemory(size_t size) {
+  void* address;
+
 #if defined(OS_WIN)
-  void* address =
+  address =
       ::VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
-  DPCHECK(address);
-  return address;
+  if (!address) {
+    UMA_HISTOGRAM_SPARSE_SLOWLY(
+        "UMA.LocalPersistentMemoryAllocator.Failures.Win", ::GetLastError());
+  }
 #elif defined(OS_POSIX)
   // MAP_ANON is deprecated on Linux but MAP_ANONYMOUS is not universal on Mac.
   // MAP_SHARED is not available on Linux <2.4 but required on Mac.
-  void* address = ::mmap(nullptr, size, PROT_READ | PROT_WRITE,
-                         MAP_ANON | MAP_SHARED, -1, 0);
-  DPCHECK(MAP_FAILED != address);
-  return address;
+  address = ::mmap(nullptr, size, PROT_READ | PROT_WRITE,
+                   MAP_ANON | MAP_SHARED, -1, 0);
+  if (address == MAP_FAILED) {
+    UMA_HISTOGRAM_SPARSE_SLOWLY(
+        "UMA.LocalPersistentMemoryAllocator.Failures.Posix", errno);
+    address = nullptr;
+  }
 #else
 #error This architecture is not (yet) supported.
 #endif
+
+  if (!address) {
+    // As a last resort, just allocate the memory from the heap. This will
+    // achieve the same basic result but the acquired memory has to be
+    // explicitly zeroed and thus realized immediately (i.e. all pages added
+    // to the process now istead of when first accessed).

[Alexei Svitkine (slow), 2016/09/22 16:57:12]

Can you add a histogram to track how often this happens?

[bcwhite, 2016/09/22 17:25:59]

I tried that (see patch #1) but it means creating a histogram every time one of
these gets created and since these are used for testing, it messes with the
expected results of a dozen histogram tests.

+    address = ::malloc(size);
+    DPCHECK(address);
+    ::memset(address, 0, size);

[Alexei Svitkine (slow), 2016/09/22 16:57:12]

Nit: I don't think it's general convention to prefix non-Chrome code with ::
unless there's conflicts.

[bcwhite, 2016/09/22 17:25:59]

Done.

+  }
+  return address;
 }
 
 // static
 void LocalPersistentMemoryAllocator::DeallocateLocalMemory(void* memory,
                                                            size_t size) {
 #if defined(OS_WIN)
   BOOL success = ::VirtualFree(memory, 0, MEM_DECOMMIT);
-  DPCHECK(success);
+  if (!success) {
+    // Must have been allocated by fallback allocator.
+    ::free(memory);
+  }
 #elif defined(OS_POSIX)
   int result = ::munmap(memory, size);
-  DPCHECK(0 == result);
+  if (result < 0) {
+    // Must have been allocated by fallback allocator.

[Alexei Svitkine (slow), 2016/09/22 16:57:12]

I don't think this is a safe assumption - e.g. if the above fails for some other
reason. I would add a boolean to explicitly track this.

[bcwhite, 2016/09/22 17:25:59]

I'd like to but can't because there is no place to store it. This method is
static because it's used to determine a construction parameter to the base class
meaning no way to safely write to member variables.

According to the man page, the only reason this call should fail is EINVAL which
is the case we're looking at.

+    ::free(memory);
+  }
 #else
 #error This architecture is not (yet) supported.
 #endif
 }
 
 
 //----- SharedPersistentMemoryAllocator ----------------------------------------
 
 SharedPersistentMemoryAllocator::SharedPersistentMemoryAllocator(
     std::unique_ptr<SharedMemory> memory,
@@ skipping 38 matching lines @@
 
 // static
 bool FilePersistentMemoryAllocator::IsFileAcceptable(
     const MemoryMappedFile& file,
     bool read_only) {
   return IsMemoryAcceptable(file.data(), file.length(), 0, read_only);
 }
 #endif  // !defined(OS_NACL)
 
 }  // namespace base