base/memory/discardable_memory_mac.cc

// Copyright (c) 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.h"

#include <mach/mach.h>
#include <sys/mman.h>

#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"

namespace base {
namespace {

// The VM subsystem allows tagging of memory and 240-255 is reserved for
// application use (see mach/vm_statistics.h). Pick 252 (after chromium's atomic
// weight of ~52).
const int kDiscardableMemoryTag = VM_MAKE_TAG(252);

class DiscardableMemoryMac : public DiscardableMemory {
 public:
  DiscardableMemoryMac(void* memory, size_t size)
      : memory_(memory),
        size_(size) {
    DCHECK(memory_);
  }

  virtual ~DiscardableMemoryMac() {
    vm_deallocate(mach_task_self(),
                  reinterpret_cast<vm_address_t>(memory_),
                  size_);
  }

  virtual LockDiscardableMemoryStatus Lock() OVERRIDE {
    DCHECK_EQ(0, mprotect(memory_, size_, PROT_READ | PROT_WRITE));
    int state = VM_PURGABLE_NONVOLATILE;
    kern_return_t ret = vm_purgable_control(
        mach_task_self(),
        reinterpret_cast<vm_address_t>(memory_),
        VM_PURGABLE_SET_STATE,
        &state);
    if (ret != KERN_SUCCESS)
      return DISCARDABLE_MEMORY_FAILED;

    return state & VM_PURGABLE_EMPTY ? DISCARDABLE_MEMORY_PURGED
                                     : DISCARDABLE_MEMORY_SUCCESS;
  }

  virtual void Unlock() OVERRIDE {
    int state = VM_PURGABLE_VOLATILE | VM_VOLATILE_GROUP_DEFAULT;
    kern_return_t ret = vm_purgable_control(
        mach_task_self(),
        reinterpret_cast<vm_address_t>(memory_),
        VM_PURGABLE_SET_STATE,
        &state);
    DCHECK_EQ(0, mprotect(memory_, size_, PROT_NONE));
    if (ret != KERN_SUCCESS)
      DLOG(ERROR) << "Failed to unlock memory.";
  }

  virtual void* Memory() const OVERRIDE {
    return memory_;
  }

 private:
  void* const memory_;
  const size_t size_;

  DISALLOW_COPY_AND_ASSIGN(DiscardableMemoryMac);
};

}  // namespace

// static
bool DiscardableMemory::SupportedNatively() {
  return true;
}

// static
scoped_ptr<DiscardableMemory> DiscardableMemory::CreateLockedMemory(
    size_t size) {
  vm_address_t buffer = 0;
  kern_return_t ret = vm_allocate(mach_task_self(),
                                  &buffer,
                                  size,
                                  VM_FLAGS_PURGABLE |
                                  VM_FLAGS_ANYWHERE |
                                  kDiscardableMemoryTag);
  if (ret != KERN_SUCCESS) {
    DLOG(ERROR) << "vm_allocate() failed";
    return scoped_ptr<DiscardableMemory>();
  }
  return scoped_ptr<DiscardableMemory>(
      new DiscardableMemoryMac(reinterpret_cast<void*>(buffer), size));
}

// static
bool DiscardableMemory::PurgeForTestingSupported() {
  return true;
}

// static
void DiscardableMemory::PurgeForTesting() {
  int state = 0;
  vm_purgable_control(mach_task_self(), 0, VM_PURGABLE_PURGE_ALL, &state);
}

}  // namespace base