Move ashmem utility functions to discardable_memory_allocator_android.cc.

base/memory/discardable_memory_allocator_android.cc

 // Copyright 2013 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/memory/discardable_memory_allocator_android.h"
 
+#include <sys/mman.h>
+#include <unistd.h>
+
 #include <algorithm>
 #include <cmath>
+#include <limits>
 #include <set>
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/discardable_memory.h"
-#include "base/memory/discardable_memory_android.h"
 #include "base/memory/scoped_vector.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
+#include "third_party/ashmem/ashmem.h"
 
 // The allocator consists of three parts (classes):
 // - DiscardableMemoryAllocator: entry point of all allocations (through its
 // Allocate() method) that are dispatched to the AshmemRegion instances (which
 // it owns).
 // - AshmemRegion: manages allocations and destructions inside a single large
 // (e.g. 32 MBytes) ashmem region.
 // - DiscardableAshmemChunk: class implementing the DiscardableMemory interface
 // whose instances are returned to the client. DiscardableAshmemChunk lets the
 // client seamlessly operate on a subrange of the ashmem region managed by
@@ skipping 19 matching lines @@
 // Returns 0 if the provided size is too high to be aligned.
 size_t AlignToNextPage(size_t size) {
   const size_t kPageSize = 4096;
   DCHECK_EQ(static_cast<int>(kPageSize), getpagesize());
   if (size > std::numeric_limits<size_t>::max() - kPageSize + 1)
     return 0;
   const size_t mask = ~(kPageSize - 1);
   return (size + kPageSize - 1) & mask;
 }
 
+bool CreateAshmemRegion(const char* name,
+                        size_t size,
+                        int* out_fd,
+                        void** out_address) {
+  int fd = ashmem_create_region(name, size);
+  if (fd < 0) {
+    DLOG(ERROR) << "ashmem_create_region() failed";
+    return false;
+  }
+  file_util::ScopedFD fd_closer(&fd);
+
+  const int err = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
+  if (err < 0) {
+    DLOG(ERROR) << "Error " << err << " when setting protection of ashmem";
+    return false;
+  }
+
+  // There is a problem using MAP_PRIVATE here. As we are constantly calling
+  // Lock() and Unlock(), data could get lost if they are not written to the
+  // underlying file when Unlock() gets called.
+  void* const address = mmap(
+      NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+  if (address == MAP_FAILED) {
+    DPLOG(ERROR) << "Failed to map memory.";
+    return false;
+  }
+
+  ignore_result(fd_closer.release());
+  *out_fd = fd;
+  *out_address = address;
+  return true;
+}
+
+bool CloseAshmemRegion(int fd, size_t size, void* address) {
+  if (munmap(address, size) == -1) {
+    DPLOG(ERROR) << "Failed to unmap memory.";
+    close(fd);
+    return false;
+  }
+  return close(fd) == 0;
+}
+
+DiscardableMemoryLockStatus LockAshmemRegion(int fd,
+                                             size_t off,
+                                             size_t size,
+                                             const void* address) {
+  const int result = ashmem_pin_region(fd, off, size);
+  DCHECK_EQ(0, mprotect(address, size, PROT_READ | PROT_WRITE));
+  return result == ASHMEM_WAS_PURGED ? DISCARDABLE_MEMORY_LOCK_STATUS_PURGED
+                                     : DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS;
+}
+
+bool UnlockAshmemRegion(int fd, size_t off, size_t size, const void* address) {
+  const int failed = ashmem_unpin_region(fd, off, size);
+  if (failed)
+    DLOG(ERROR) << "Failed to unpin memory.";
+  // This allows us to catch accesses to unlocked memory.
+  DCHECK_EQ(0, mprotect(address, size, PROT_NONE));
+  return !failed;
+}
+
 }  // namespace
 
 namespace internal {
 
 class DiscardableMemoryAllocator::DiscardableAshmemChunk
     : public DiscardableMemory {
  public:
   // Note that |ashmem_region| must outlive |this|.
   DiscardableAshmemChunk(AshmemRegion* ashmem_region,
                          int fd,
                          void* address,
                          size_t offset,
                          size_t size)
       : ashmem_region_(ashmem_region),
         fd_(fd),
         address_(address),
         offset_(offset),
         size_(size),
         locked_(true) {
   }
 
   // Implemented below AshmemRegion since this requires the full definition of
   // AshmemRegion.
   virtual ~DiscardableAshmemChunk();
 
   // DiscardableMemory:
   virtual DiscardableMemoryLockStatus Lock() OVERRIDE {
     DCHECK(!locked_);
     locked_ = true;
-    return internal::LockAshmemRegion(fd_, offset_, size_, address_);
+    return LockAshmemRegion(fd_, offset_, size_, address_);
   }
 
   virtual void Unlock() OVERRIDE {
     DCHECK(locked_);
     locked_ = false;
-    internal::UnlockAshmemRegion(fd_, offset_, size_, address_);
+    UnlockAshmemRegion(fd_, offset_, size_, address_);
   }
 
   virtual void* Memory() const OVERRIDE {
     return address_;
   }
 
  private:
   AshmemRegion* const ashmem_region_;
   const int fd_;
   void* const address_;
   const size_t offset_;
   const size_t size_;
   bool locked_;
 
   DISALLOW_COPY_AND_ASSIGN(DiscardableAshmemChunk);
 };
 
 class DiscardableMemoryAllocator::AshmemRegion {
  public:
   // Note that |allocator| must outlive |this|.
   static scoped_ptr<AshmemRegion> Create(
       size_t size,
       const std::string& name,
       DiscardableMemoryAllocator* allocator) {
     DCHECK_EQ(size, AlignToNextPage(size));
     int fd;
     void* base;
-    if (!internal::CreateAshmemRegion(name.c_str(), size, &fd, &base))
+    if (!CreateAshmemRegion(name.c_str(), size, &fd, &base))
       return scoped_ptr<AshmemRegion>();
     return make_scoped_ptr(new AshmemRegion(fd, size, base, allocator));
   }
 
   ~AshmemRegion() {
-    const bool result = internal::CloseAshmemRegion(fd_, size_, base_);
+    const bool result = CloseAshmemRegion(fd_, size_, base_);
     DCHECK(result);
   }
 
   // Returns a new instance of DiscardableMemory whose size is greater or equal
   // than |actual_size| (which is expected to be greater or equal than
   // |client_requested_size|).
   // Allocation works as follows:
   // 1) Reuse a previously freed chunk and return it if it succeeded. See
   // ReuseFreeChunk_Locked() below for more information.
   // 2) If no free chunk could be reused and the region is not big enough for
@@ skipping 111 matching lines @@
       DCHECK_GT(reused_chunk.size, actual_size);
       const size_t new_chunk_size = reused_chunk.size - actual_size;
       // Note that merging is not needed here since there can't be contiguous
       // free chunks at this point.
       AddFreeChunk_Locked(
           FreeChunk(reused_chunk.start, new_chunk_start, new_chunk_size));
     }
 
     const size_t offset =
         static_cast<char*>(reused_chunk.start) - static_cast<char*>(base_);
-    internal::LockAshmemRegion(
-        fd_, offset, reused_chunk_size, reused_chunk.start);
+    LockAshmemRegion(fd_, offset, reused_chunk_size, reused_chunk.start);
     scoped_ptr<DiscardableMemory> memory(
         new DiscardableAshmemChunk(this, fd_, reused_chunk.start, offset,
                                    reused_chunk_size));
     return memory.Pass();
   }
 
   // Makes the chunk identified with the provided arguments free and possibly
   // merges this chunk with the previous and next contiguous ones.
   // If the provided chunk is the only one used (and going to be freed) in the
   // region then the internal ashmem region is closed so that the underlying
@@ skipping 111 matching lines @@
       void*, std::multiset<FreeChunk>::iterator> address_to_free_chunk_map_;
   // Maps the address of *used* chunks to the address of their previous
   // contiguous chunk.
   hash_map<void*, void*> used_to_previous_chunk_map_;
 
   DISALLOW_COPY_AND_ASSIGN(AshmemRegion);
 };
 
 DiscardableMemoryAllocator::DiscardableAshmemChunk::~DiscardableAshmemChunk() {
   if (locked_)
-    internal::UnlockAshmemRegion(fd_, offset_, size_, address_);
+    UnlockAshmemRegion(fd_, offset_, size_, address_);
   ashmem_region_->OnChunkDeletion(address_, size_);
 }
 
 DiscardableMemoryAllocator::DiscardableMemoryAllocator(
     const std::string& name,
     size_t ashmem_region_size)
     : name_(name),
       ashmem_region_size_(
           std::max(kMinAshmemRegionSize, AlignToNextPage(ashmem_region_size))),
       last_ashmem_region_size_(0) {
@@ skipping 55 matching lines @@
   DCHECK_LE(ashmem_regions_.size(), 5U);
   const ScopedVector<AshmemRegion>::iterator it = std::find(
       ashmem_regions_.begin(), ashmem_regions_.end(), region);
   DCHECK_NE(ashmem_regions_.end(), it);
   std::swap(*it, ashmem_regions_.back());
   ashmem_regions_.pop_back();
 }
 
 }  // namespace internal
 }  // namespace base