blob: b2550276aeb6d76dc9fd5018adc6bce1719c8e23 [file] [log] [blame]
// Copyright 2016 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <algorithm>
#include "starboard/memory.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace starboard {
namespace nplb {
namespace {
#if SB_API_VERSION >= SB_MMAP_REQUIRED_VERSION || SB_HAS(MMAP)
const size_t kSize = SB_MEMORY_PAGE_SIZE * 8;
const void* kFailed = SB_MEMORY_MAP_FAILED;
TEST(SbMemoryMapTest, AllocatesNormally) {
void* memory = SbMemoryMap(kSize, kSbMemoryMapProtectRead, "test");
ASSERT_NE(kFailed, memory);
EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
}
TEST(SbMemoryMapTest, AllocatesZero) {
void* memory = SbMemoryMap(0, kSbMemoryMapProtectRead, "test");
ASSERT_EQ(kFailed, memory);
EXPECT_FALSE(SbMemoryUnmap(memory, 0));
}
TEST(SbMemoryMapTest, AllocatesOne) {
void* memory = SbMemoryMap(1, kSbMemoryMapProtectRead, "test");
ASSERT_NE(kFailed, memory);
EXPECT_TRUE(SbMemoryUnmap(memory, 1));
}
TEST(SbMemoryMapTest, AllocatesOnePage) {
void* memory =
SbMemoryMap(SB_MEMORY_PAGE_SIZE, kSbMemoryMapProtectRead, "test");
ASSERT_NE(kFailed, memory);
EXPECT_TRUE(SbMemoryUnmap(memory, SB_MEMORY_PAGE_SIZE));
}
// Disabled because it is too slow -- currently ~5 seconds on a Linux desktop
// with lots of memory.
TEST(SbMemoryMapTest, DISABLED_DoesNotLeak) {
const int64_t kIterations = 16;
const double kFactor = 1.25;
const size_t kSparseCommittedPages = 256;
const int64_t kBytesMappedPerIteration =
static_cast<int64_t>(SbSystemGetTotalCPUMemory() * kFactor) / kIterations;
const int64_t kMaxBytesMapped = kBytesMappedPerIteration * kIterations;
for (int64_t total_bytes_mapped = 0; total_bytes_mapped < kMaxBytesMapped;
total_bytes_mapped += kBytesMappedPerIteration) {
void* memory =
SbMemoryMap(kBytesMappedPerIteration, kSbMemoryMapProtectWrite, "test");
ASSERT_NE(kFailed, memory);
// If this is the last iteration of the loop, then force a page commit for
// every single page. For any other iteration, force a page commit for
// |kSparseCommittedPages|.
bool last_iteration =
!(total_bytes_mapped + kBytesMappedPerIteration < kMaxBytesMapped);
uint8_t* first_page = static_cast<uint8_t*>(memory);
const size_t page_increment_factor =
(last_iteration)
? size_t(1u)
: std::max(static_cast<size_t>(
kBytesMappedPerIteration /
(kSparseCommittedPages * SB_MEMORY_PAGE_SIZE)),
size_t(1u));
for (uint8_t* page = first_page;
page < first_page + kBytesMappedPerIteration;
page += SB_MEMORY_PAGE_SIZE * page_increment_factor) {
*page = 0x55;
}
EXPECT_TRUE(SbMemoryUnmap(memory, kBytesMappedPerIteration));
}
}
TEST(SbMemoryMapTest, CanReadWriteToResult) {
void* memory = SbMemoryMap(kSize, kSbMemoryMapProtectReadWrite, "test");
ASSERT_NE(kFailed, memory);
char* data = static_cast<char*>(memory);
for (int i = 0; i < kSize; ++i) {
data[i] = static_cast<char>(i);
}
for (int i = 0; i < kSize; ++i) {
EXPECT_EQ(data[i], static_cast<char>(i));
}
EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
}
#if SB_CAN(MAP_EXECUTABLE_MEMORY)
typedef int (*SumFunction)(int, int);
static int Sum(int x, int y) {
return x + y;
}
static int Sum2(int x, int y) {
return x + y + x;
}
// Copy the contents of |Sum| into |memory|, returning an assertion result
// indicating whether the copy was successful, a function pointer to the
// possibly copied |Sum| function data and a function pointer to the selected
// original function.. Clients are expected to immediately call |ASSERT| on
// the assertion result.
std::tuple<::testing::AssertionResult, SumFunction, SumFunction>
CopySumFunctionIntoMemory(void* memory) {
// There's no reliable way to determine the size of the 'Sum' function. If we
// assume the function is at most a certain size, then we might try to read
// beyond mapped memory when copying it to the destination address. We can
// get a reasonable upper bound by assuming that the function's implementation
// does not cross a page boundary, and copy the memory from the beginning of
// the function to the end of the page that it is mapped to.
//
// However, since it's possible the function may cross the page boundary, we
// define two functions and use the one closest to the start of a page. There
// is no guarantee that the linker will place these definitions sequentially
// (although it likely will), so we can't use the address of 'Sum2' as the
// end of 'Sum'.
//
// To avoid the possibility that COMDAT folding will combine these two
// definitions into one, make sure they are different.
// A function pointer can't be cast to void*, but uint8* seems to be okay. So
// cast to a uint* which will be implicitly casted to a void* below.
SumFunction original_function = &Sum;
if (reinterpret_cast<uintptr_t>(&Sum2) % SB_MEMORY_PAGE_SIZE <
reinterpret_cast<uintptr_t>(&Sum) % SB_MEMORY_PAGE_SIZE) {
original_function = &Sum2;
}
uint8_t* sum_function_start = reinterpret_cast<uint8_t*>(original_function);
// MIPS16 instruction are kept odd addresses to differentiate between that and
// MIPS32 instructions. Most other instructions are aligned to at least even
// addresses, so this code should do nothing for those architectures.
// https://www.linux-mips.org/wiki/MIPS16
ptrdiff_t sum_function_offset =
sum_function_start -
reinterpret_cast<uint8_t*>(
reinterpret_cast<uintptr_t>(sum_function_start) & ~0x1);
sum_function_start -= sum_function_offset;
// Get the last address of the page that |sum_function_start| is on.
uint8_t* sum_function_page_end = reinterpret_cast<uint8_t*>(
(reinterpret_cast<uintptr_t>(sum_function_start) / SB_MEMORY_PAGE_SIZE) *
SB_MEMORY_PAGE_SIZE +
SB_MEMORY_PAGE_SIZE);
if (!SbMemoryIsAligned(sum_function_page_end, SB_MEMORY_PAGE_SIZE)) {
return std::make_tuple(::testing::AssertionFailure()
<< "Expected |Sum| page end ("
<< static_cast<void*>(sum_function_page_end)
<< ") to be aligned to " << SB_MEMORY_PAGE_SIZE,
nullptr, nullptr);
}
if (sum_function_start >= sum_function_page_end) {
return std::make_tuple(::testing::AssertionFailure()
<< "Expected |Sum| function page start ("
<< static_cast<void*>(sum_function_start)
<< ") to be less than |Sum| function page end ("
<< static_cast<void*>(sum_function_page_end)
<< ")",
nullptr, nullptr);
}
size_t bytes_to_copy = sum_function_page_end - sum_function_start;
if (bytes_to_copy > SB_MEMORY_PAGE_SIZE) {
return std::make_tuple(
::testing::AssertionFailure()
<< "Expected bytes required to copy |Sum| to be less than "
<< SB_MEMORY_PAGE_SIZE << ", Actual: " << bytes_to_copy,
nullptr, nullptr);
}
SbMemoryCopy(memory, sum_function_start, bytes_to_copy);
SbMemoryFlush(memory, bytes_to_copy);
SumFunction mapped_function = reinterpret_cast<SumFunction>(
reinterpret_cast<uint8_t*>(memory) + sum_function_offset);
return std::make_tuple(::testing::AssertionSuccess(), mapped_function,
original_function);
}
#if SB_API_VERSION >= 10
// Cobalt can not map executable memory. If executable memory is needed, map
// non-executable memory first and use SbMemoryProtect to change memory accesss
// to executable.
TEST(SbMemoryMapTest, CanNotDirectlyMapMemoryWithExecFlag) {
SbMemoryMapFlags exec_flags[] = {
SbMemoryMapFlags(kSbMemoryMapProtectExec),
SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectExec),
SbMemoryMapFlags(kSbMemoryMapProtectWrite | kSbMemoryMapProtectExec),
SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectWrite |
kSbMemoryMapProtectExec),
};
for (auto exec_flag : exec_flags) {
void* memory = SbMemoryMap(kSize, exec_flag, "test");
ASSERT_EQ(kFailed, memory);
EXPECT_FALSE(SbMemoryUnmap(memory, 0));
}
}
#endif // 10
#endif // SB_CAN(MAP_EXECUTABLE_MEMORY)
#if SB_API_VERSION >= 10
TEST(SbMemoryMapTest, CanChangeMemoryProtection) {
SbMemoryMapFlags all_from_flags[] = {
SbMemoryMapFlags(kSbMemoryMapProtectReserved),
SbMemoryMapFlags(kSbMemoryMapProtectRead),
SbMemoryMapFlags(kSbMemoryMapProtectWrite),
SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectWrite),
};
SbMemoryMapFlags all_to_flags[] = {
SbMemoryMapFlags(kSbMemoryMapProtectReserved),
SbMemoryMapFlags(kSbMemoryMapProtectRead),
SbMemoryMapFlags(kSbMemoryMapProtectWrite),
SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectWrite),
#if SB_CAN(MAP_EXECUTABLE_MEMORY)
SbMemoryMapFlags(kSbMemoryMapProtectExec),
SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectExec),
#endif
};
for (SbMemoryMapFlags from_flags : all_from_flags) {
for (SbMemoryMapFlags to_flags : all_to_flags) {
void* memory = SbMemoryMap(kSize, from_flags, "test");
// If the platform does not support a particular protection flags
// configuration in the first place, then just give them a pass, knowing
// that that feature will be tested elsewhere.
if (memory == SB_MEMORY_MAP_FAILED) {
continue;
}
#if SB_CAN(MAP_EXECUTABLE_MEMORY)
// We can only test the ability to execute memory after changing
// protections if we have write permissions either now or then, because
// we have to actually put a valid function into the mapped memory.
SumFunction mapped_function = nullptr;
SumFunction original_function = nullptr;
if (from_flags & kSbMemoryMapProtectWrite) {
auto copy_sum_function_result = CopySumFunctionIntoMemory(memory);
ASSERT_TRUE(std::get<0>(copy_sum_function_result));
mapped_function = std::get<1>(copy_sum_function_result);
original_function = std::get<2>(copy_sum_function_result);
}
#endif
if (!SbMemoryProtect(memory, kSize, to_flags)) {
EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
continue;
}
#if SB_CAN(MAP_EXECUTABLE_MEMORY)
if ((to_flags & kSbMemoryMapProtectExec) && mapped_function != nullptr) {
EXPECT_EQ(original_function(0xc0ba178, 0xbadf00d),
mapped_function(0xc0ba178, 0xbadf00d));
}
#endif
if (to_flags & kSbMemoryMapProtectRead) {
for (int i = 0; i < kSize; i++) {
volatile uint8_t force_read = static_cast<uint8_t*>(memory)[i];
}
}
if (to_flags & kSbMemoryMapProtectWrite) {
for (int i = 0; i < kSize; i++) {
static_cast<uint8_t*>(memory)[i] = 0xff;
}
}
EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
}
}
}
#endif // SB_API_VERSION >= 10
#endif // SB_API_VERSION >= SB_MMAP_REQUIRED_VERSION || SB_HAS(MMAP)
} // namespace
} // namespace nplb
} // namespace starboard