Handle failures allocating mapped local memory.

base/metrics/persistent_memory_allocator.h

 // 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.
 
 #ifndef BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 #define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
 
 #include <stdint.h>
 
 #include <atomic>
@@ skipping 269 matching lines @@
 
   // Flag set if an allocation has failed because the memory segment was full.
   bool IsFull() const;
 
   // Update those "tracking" histograms which do not get updates during regular
   // operation, such as how much memory is currently used. This should be
   // called before such information is to be displayed or uploaded.
   void UpdateTrackingHistograms();
 
  protected:
+  enum MemoryType {
+    MEM_EXTERNAL,
+    MEM_MALLOC,
+    MEM_VIRTUAL,
+    MEM_SHARED,
+    MEM_FILE,
+  };
+
+  struct Memory {
+    Memory(void* b, MemoryType t) : base(b), type(t) {}
+
+    void* base;
+    MemoryType type;
+  };
+
+  // Constructs the allocator. Everything is the same as the public allocator
+  // except |memory| which is a structure with additional information besides
+  // the base address.
+  PersistentMemoryAllocator(Memory memory, size_t size, size_t page_size,
+                            uint64_t id, base::StringPiece name,
+                            bool readonly);
+
   volatile char* const mem_base_;  // Memory base. (char so sizeof guaranteed 1)
+  const MemoryType mem_type_;      // Type of memory allocation.
   const uint32_t mem_size_;        // Size of entire memory segment.
   const uint32_t mem_page_;        // Page size allocations shouldn't cross.
 
  private:
   struct SharedMetadata;
   struct BlockHeader;
   static const uint32_t kAllocAlignment;
   static const Reference kReferenceQueue;
 
   // The shared metadata is always located at the top of the memory segment.
@@ skipping 51 matching lines @@
     : public PersistentMemoryAllocator {
  public:
   LocalPersistentMemoryAllocator(size_t size, uint64_t id,
                                  base::StringPiece name);
   ~LocalPersistentMemoryAllocator() override;
 
  private:
   // Allocates a block of local memory of the specified |size|, ensuring that
   // the memory will not be physically allocated until accessed and will read
   // as zero when that happens.
-  static void* AllocateLocalMemory(size_t size);
+  static Memory AllocateLocalMemory(size_t size);
 
   // Deallocates a block of local |memory| of the specified |size|.
-  static void DeallocateLocalMemory(void* memory, size_t size);
+  static void DeallocateLocalMemory(void* memory, size_t size, MemoryType type);
 
   DISALLOW_COPY_AND_ASSIGN(LocalPersistentMemoryAllocator);
 };
 
 
 // This allocator takes a shared-memory object and performs allocation from
 // it. The memory must be previously mapped via Map() or MapAt(). The allocator
 // takes ownership of the memory object.
 class BASE_EXPORT SharedPersistentMemoryAllocator
     : public PersistentMemoryAllocator {
  public:
   SharedPersistentMemoryAllocator(std::unique_ptr<SharedMemory> memory,
                                   uint64_t id,
                                   base::StringPiece name,
                                   bool read_only);
   ~SharedPersistentMemoryAllocator() override;
 
   SharedMemory* shared_memory() { return shared_memory_.get(); }
 
-  // Ensure that the memory isn't so invalid that it won't crash when passing it
+  // Ensure that the memory isn't so invalid that it would crash when passing it
   // to the allocator. This doesn't guarantee the data is valid, just that it
   // won't cause the program to abort. The existing IsCorrupt() call will handle
   // the rest.
   static bool IsSharedMemoryAcceptable(const SharedMemory& memory);
 
  private:
   std::unique_ptr<SharedMemory> shared_memory_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedPersistentMemoryAllocator);
 };
 
 
 #if !defined(OS_NACL)  // NACL doesn't support any kind of file access in build.
 // This allocator takes a memory-mapped file object and performs allocation
 // from it. The allocator takes ownership of the file object.
 class BASE_EXPORT FilePersistentMemoryAllocator
     : public PersistentMemoryAllocator {
  public:
   // A |max_size| of zero will use the length of the file as the maximum
   // size. The |file| object must have been already created with sufficient
   // permissions (read, read/write, or read/write/extend).
   FilePersistentMemoryAllocator(std::unique_ptr<MemoryMappedFile> file,
                                 size_t max_size,
                                 uint64_t id,
                                 base::StringPiece name,
                                 bool read_only);
   ~FilePersistentMemoryAllocator() override;
 
-  // Ensure that the file isn't so invalid that it won't crash when passing it
+  // Ensure that the file isn't so invalid that it would crash when passing it
   // to the allocator. This doesn't guarantee the file is valid, just that it
   // won't cause the program to abort. The existing IsCorrupt() call will handle
   // the rest.
   static bool IsFileAcceptable(const MemoryMappedFile& file, bool read_only);
 
  private:
   std::unique_ptr<MemoryMappedFile> mapped_file_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
 };
 #endif  // !defined(OS_NACL)
 
 }  // namespace base
 
 #endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_