202 lines
6.7 KiB
C++
202 lines
6.7 KiB
C++
/*
|
|
* Copyright (C) 2010 Apple Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <wtf/OSAllocator.h>
|
|
|
|
#include <errno.h>
|
|
#include <sys/mman.h>
|
|
#include <wtf/Assertions.h>
|
|
#include <wtf/PageBlock.h>
|
|
|
|
#if ENABLE(JIT_CAGE)
|
|
#include <WebKitAdditions/JITCageAdditions.h>
|
|
#else // ENABLE(JIT_CAGE)
|
|
#if OS(DARWIN)
|
|
#define MAP_EXECUTABLE_FOR_JIT MAP_JIT
|
|
#define MAP_EXECUTABLE_FOR_JIT_WITH_JIT_CAGE MAP_JIT
|
|
#else // OS(DARWIN)
|
|
#define MAP_EXECUTABLE_FOR_JIT 0
|
|
#define MAP_EXECUTABLE_FOR_JIT_WITH_JIT_CAGE 0
|
|
#endif // OS(DARWIN)
|
|
#endif // ENABLE(JIT_CAGE)
|
|
|
|
namespace WTF {
|
|
|
|
void* OSAllocator::reserveUncommitted(size_t bytes, Usage usage, bool writable, bool executable, bool jitCageEnabled, bool includesGuardPages)
|
|
{
|
|
#if OS(LINUX) || OS(HAIKU)
|
|
UNUSED_PARAM(usage);
|
|
UNUSED_PARAM(writable);
|
|
UNUSED_PARAM(executable);
|
|
UNUSED_PARAM(jitCageEnabled);
|
|
UNUSED_PARAM(includesGuardPages);
|
|
|
|
void* result = mmap(0, bytes, PROT_NONE, MAP_NORESERVE | MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
if (result == MAP_FAILED)
|
|
CRASH();
|
|
madvise(result, bytes, MADV_DONTNEED);
|
|
#else
|
|
void* result = reserveAndCommit(bytes, usage, writable, executable, jitCageEnabled, includesGuardPages);
|
|
#if HAVE(MADV_FREE_REUSE)
|
|
if (result) {
|
|
// To support the "reserve then commit" model, we have to initially decommit.
|
|
while (madvise(result, bytes, MADV_FREE_REUSABLE) == -1 && errno == EAGAIN) { }
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
void* OSAllocator::reserveAndCommit(size_t bytes, Usage usage, bool writable, bool executable, bool jitCageEnabled, bool includesGuardPages)
|
|
{
|
|
// All POSIX reservations start out logically committed.
|
|
int protection = PROT_READ;
|
|
if (writable)
|
|
protection |= PROT_WRITE;
|
|
if (executable)
|
|
protection |= PROT_EXEC;
|
|
|
|
int flags = MAP_PRIVATE | MAP_ANON;
|
|
#if OS(DARWIN)
|
|
if (executable) {
|
|
if (jitCageEnabled)
|
|
flags |= MAP_EXECUTABLE_FOR_JIT_WITH_JIT_CAGE;
|
|
else
|
|
flags |= MAP_EXECUTABLE_FOR_JIT;
|
|
}
|
|
#else
|
|
UNUSED_PARAM(jitCageEnabled);
|
|
#endif
|
|
|
|
#if OS(DARWIN)
|
|
int fd = usage;
|
|
#else
|
|
UNUSED_PARAM(usage);
|
|
int fd = -1;
|
|
#endif
|
|
|
|
void* result = 0;
|
|
#if (OS(DARWIN) && CPU(X86_64))
|
|
if (executable) {
|
|
ASSERT(includesGuardPages);
|
|
// Cook up an address to allocate at, using the following recipe:
|
|
// 17 bits of zero, stay in userspace kids.
|
|
// 26 bits of randomness for ASLR.
|
|
// 21 bits of zero, at least stay aligned within one level of the pagetables.
|
|
//
|
|
// But! - as a temporary workaround for some plugin problems (rdar://problem/6812854),
|
|
// for now instead of 2^26 bits of ASLR lets stick with 25 bits of randomization plus
|
|
// 2^24, which should put up somewhere in the middle of userspace (in the address range
|
|
// 0x200000000000 .. 0x5fffffffffff).
|
|
intptr_t randomLocation = 0;
|
|
randomLocation = arc4random() & ((1 << 25) - 1);
|
|
randomLocation += (1 << 24);
|
|
randomLocation <<= 21;
|
|
result = reinterpret_cast<void*>(randomLocation);
|
|
}
|
|
#endif
|
|
|
|
result = mmap(result, bytes, protection, flags, fd, 0);
|
|
if (result == MAP_FAILED) {
|
|
if (executable)
|
|
result = 0;
|
|
else
|
|
CRASH();
|
|
}
|
|
if (result && includesGuardPages) {
|
|
// We use mmap to remap the guardpages rather than using mprotect as
|
|
// mprotect results in multiple references to the code region. This
|
|
// breaks the madvise based mechanism we use to return physical memory
|
|
// to the OS.
|
|
mmap(result, pageSize(), PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON, fd, 0);
|
|
mmap(static_cast<char*>(result) + bytes - pageSize(), pageSize(), PROT_NONE, MAP_FIXED | MAP_PRIVATE | MAP_ANON, fd, 0);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void OSAllocator::commit(void* address, size_t bytes, bool writable, bool executable)
|
|
{
|
|
#if OS(LINUX) || OS(HAIKU)
|
|
int protection = PROT_READ;
|
|
if (writable)
|
|
protection |= PROT_WRITE;
|
|
if (executable)
|
|
protection |= PROT_EXEC;
|
|
if (mprotect(address, bytes, protection))
|
|
CRASH();
|
|
madvise(address, bytes, MADV_WILLNEED);
|
|
#elif HAVE(MADV_FREE_REUSE)
|
|
UNUSED_PARAM(writable);
|
|
UNUSED_PARAM(executable);
|
|
while (madvise(address, bytes, MADV_FREE_REUSE) == -1 && errno == EAGAIN) { }
|
|
#else
|
|
// Non-MADV_FREE_REUSE reservations automatically commit on demand.
|
|
UNUSED_PARAM(address);
|
|
UNUSED_PARAM(bytes);
|
|
UNUSED_PARAM(writable);
|
|
UNUSED_PARAM(executable);
|
|
#endif
|
|
}
|
|
|
|
void OSAllocator::decommit(void* address, size_t bytes)
|
|
{
|
|
#if OS(LINUX) || OS(HAIKU)
|
|
madvise(address, bytes, MADV_DONTNEED);
|
|
if (mprotect(address, bytes, PROT_NONE))
|
|
CRASH();
|
|
#elif HAVE(MADV_FREE_REUSE)
|
|
while (madvise(address, bytes, MADV_FREE_REUSABLE) == -1 && errno == EAGAIN) { }
|
|
#elif HAVE(MADV_FREE)
|
|
while (madvise(address, bytes, MADV_FREE) == -1 && errno == EAGAIN) { }
|
|
#elif HAVE(MADV_DONTNEED)
|
|
while (madvise(address, bytes, MADV_DONTNEED) == -1 && errno == EAGAIN) { }
|
|
#else
|
|
UNUSED_PARAM(address);
|
|
UNUSED_PARAM(bytes);
|
|
#endif
|
|
}
|
|
|
|
void OSAllocator::hintMemoryNotNeededSoon(void* address, size_t bytes)
|
|
{
|
|
#if HAVE(MADV_DONTNEED)
|
|
while (madvise(address, bytes, MADV_DONTNEED) == -1 && errno == EAGAIN) { }
|
|
#else
|
|
UNUSED_PARAM(address);
|
|
UNUSED_PARAM(bytes);
|
|
#endif
|
|
}
|
|
|
|
void OSAllocator::releaseDecommitted(void* address, size_t bytes)
|
|
{
|
|
int result = munmap(address, bytes);
|
|
if (result == -1)
|
|
CRASH();
|
|
}
|
|
|
|
} // namespace WTF
|