Google Git
Sign in
fuchsia / fuchsia / 57ef8eaaff96ca15cebfbd2e5605521ab24317e6 / . / zircon / system / utest / core / vmo / vmo.cc
blob: 1d82baa4c4dd19aa19dc30dc39bdbe1246aa4b87 [file] [log] [blame]
// Copyright 2016 The Fuchsia 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 <ctype.h>
#include <inttypes.h>
#include <lib/fit/defer.h>
#include <lib/fzl/memory-probe.h>
#include <lib/zx/bti.h>
#include <lib/zx/iommu.h>
#include <lib/zx/pager.h>
#include <lib/zx/vmar.h>
#include <lib/zx/vmo.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <threads.h>
#include <unistd.h>
#include <zircon/process.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/iommu.h>
#include <zircon/syscalls/object.h>
#include <algorithm>
#include <atomic>
#include <iterator>
#include <thread>
#include <vector>
#include <explicit-memory/bytes.h>
#include <fbl/algorithm.h>
#include <zxtest/zxtest.h>
#if defined(__x86_64__)
#include <cpuid.h>
namespace {
// See fxbug.dev/66978.
bool IsQemuTcg() {
uint32_t eax;
uint32_t name[3];
__cpuid(0x40000000, eax, name[0], name[1], name[2]);
return !memcmp(reinterpret_cast<const char *>(name), "TCGTCGTCGTCG", sizeof(name));
}
} // namespace
#endif
#include "helpers.h"
extern "C" __WEAK zx_handle_t get_root_resource(void);
namespace {
TEST(VmoTestCase, Create) {
zx_status_t status;
zx_handle_t vmo[16];
// allocate a bunch of vmos then free them
for (size_t i = 0; i < std::size(vmo); i++) {
status = zx_vmo_create(i * zx_system_get_page_size(), 0, &vmo[i]);
EXPECT_OK(status, "vm_object_create");
}
for (size_t i = 0; i < std::size(vmo); i++) {
status = zx_handle_close(vmo[i]);
EXPECT_OK(status, "handle_close");
}
}
TEST(VmoTestCase, ReadWriteBadLen) {
zx_status_t status;
zx_handle_t vmo;
// allocate an object and attempt read/write from it, with bad length
const size_t len = zx_system_get_page_size() * 4;
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
char buf[len];
for (int i = 1; i <= 2; i++) {
status = zx_vmo_read(vmo, buf, 0,
std::numeric_limits<size_t>::max() - (zx_system_get_page_size() / i));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, status);
status = zx_vmo_write(vmo, buf, 0,
std::numeric_limits<size_t>::max() - (zx_system_get_page_size() / i));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, status);
}
status = zx_vmo_read(vmo, buf, 0, len);
EXPECT_OK(status, "vmo_read");
status = zx_vmo_write(vmo, buf, 0, len);
EXPECT_OK(status, "vmo_write");
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
}
TEST(VmoTestCase, ReadWrite) {
zx_status_t status;
zx_handle_t vmo;
// allocate an object and read/write from it
const size_t len = zx_system_get_page_size() * 4;
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
char buf[len];
status = zx_vmo_read(vmo, buf, 0, sizeof(buf));
EXPECT_OK(status, "vm_object_read");
// make sure it's full of zeros
size_t count = 0;
for (auto c : buf) {
EXPECT_EQ(c, 0, "zero test");
if (c != 0) {
printf("char at offset %#zx is bad\n", count);
}
count++;
}
memset(buf, 0x99, sizeof(buf));
status = zx_vmo_write(vmo, buf, 0, sizeof(buf));
EXPECT_OK(status, "vm_object_write");
// map it
uintptr_t ptr;
status =
zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, len, &ptr);
EXPECT_OK(status, "vm_map");
EXPECT_NE(0u, ptr, "vm_map");
// check that it matches what we last wrote into it
EXPECT_BYTES_EQ((uint8_t *)buf, (uint8_t *)ptr, sizeof(buf), "mapped buffer");
status = zx_vmar_unmap(zx_vmar_root_self(), ptr, len);
EXPECT_OK(status, "vm_unmap");
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
}
TEST(VmoTestCase, ReadWriteRange) {
zx_status_t status;
zx_handle_t vmo;
// allocate an object
const size_t len = zx_system_get_page_size() * 4;
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// fail to read past end
char buf[len * 2];
status = zx_vmo_read(vmo, buf, 0, sizeof(buf));
EXPECT_EQ(status, ZX_ERR_OUT_OF_RANGE, "vm_object_read past end");
// Successfully read 0 bytes at end
status = zx_vmo_read(vmo, buf, len, 0);
EXPECT_OK(status, "vm_object_read zero at end");
// Fail to read 0 bytes past end
status = zx_vmo_read(vmo, buf, len + 1, 0);
EXPECT_EQ(status, ZX_ERR_OUT_OF_RANGE, "vm_object_read zero past end");
// fail to write past end
status = zx_vmo_write(vmo, buf, 0, sizeof(buf));
EXPECT_EQ(status, ZX_ERR_OUT_OF_RANGE, "vm_object_write past end");
// Successfully write 0 bytes at end
status = zx_vmo_write(vmo, buf, len, 0);
EXPECT_OK(status, "vm_object_write zero at end");
// Fail to read 0 bytes past end
status = zx_vmo_write(vmo, buf, len + 1, 0);
EXPECT_EQ(status, ZX_ERR_OUT_OF_RANGE, "vm_object_write zero past end");
// Test for unsigned wraparound
status = zx_vmo_read(vmo, buf, UINT64_MAX - (len / 2), len);
EXPECT_EQ(status, ZX_ERR_OUT_OF_RANGE, "vm_object_read offset + len wraparound");
status = zx_vmo_write(vmo, buf, UINT64_MAX - (len / 2), len);
EXPECT_EQ(status, ZX_ERR_OUT_OF_RANGE, "vm_object_write offset + len wraparound");
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
}
TEST(VmoTestCase, Map) {
zx_status_t status;
zx_handle_t vmo;
uintptr_t ptr[3] = {};
// allocate a vmo
status = zx_vmo_create(4 * zx_system_get_page_size(), 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// do a regular map
ptr[0] = 0;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0, zx_system_get_page_size(),
&ptr[0]);
EXPECT_OK(status, "map");
EXPECT_NE(0u, ptr[0], "map address");
// printf("mapped %#" PRIxPTR "\n", ptr[0]);
// try to map something completely out of range without any fixed mapping, should succeed
ptr[2] = UINTPTR_MAX;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0, zx_system_get_page_size(),
&ptr[2]);
EXPECT_OK(status, "map");
EXPECT_NE(0u, ptr[2], "map address");
// try to map something completely out of range fixed, should fail
uintptr_t map_addr;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_SPECIFIC, UINTPTR_MAX, vmo, 0,
zx_system_get_page_size(), &map_addr);
EXPECT_EQ(ZX_ERR_INVALID_ARGS, status, "map");
// cleanup
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
for (auto p : ptr) {
if (p) {
status = zx_vmar_unmap(zx_vmar_root_self(), p, zx_system_get_page_size());
EXPECT_OK(status, "unmap");
}
}
}
TEST(VmoTestCase, MapRead) {
zx::vmo vmo;
EXPECT_OK(zx::vmo::create(zx_system_get_page_size() * 2, 0, &vmo));
uintptr_t vaddr;
// Map in the first page
EXPECT_OK(zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0,
zx_system_get_page_size(), &vaddr));
// Read from the second page of the vmo to mapping.
// This should succeed and not deadlock in the kernel.
EXPECT_OK(vmo.read(reinterpret_cast<void *>(vaddr), zx_system_get_page_size(),
zx_system_get_page_size()));
}
// This test attempts to write to a memory location from multiple threads
// while other threads are decommitting that same memory.
//
// The expected behavior is that the writes succeed without crashing
// the kernel.
//
// See fxbug.dev/66978 for more details.
TEST(VmoTestCase, ParallelWriteAndDecommit) {
// TODO(fxbug.dev/66978): This test triggers a QEMU TCG bug on x86. Once the bug is fixed, the
// test should be renabled for this configuration.
#if defined(__x86_64__)
if (IsQemuTcg()) {
printf("skipping test when running on QEMU TCG x86 (fxbug.dev/66978)\n");
return;
}
#endif
constexpr size_t kVmoSize = 8 * (1UL << 30);
zx::vmo vmo;
ASSERT_OK(zx::vmo::create(kVmoSize, 0, &vmo));
uintptr_t base;
ASSERT_OK(
zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, kVmoSize, &base));
ASSERT_OK(vmo.op_range(ZX_VMO_OP_DECOMMIT, 0, kVmoSize, nullptr, 0));
constexpr size_t kNumThreads = 2;
void *dst = reinterpret_cast<void *>(base + kVmoSize / 2);
std::atomic<size_t> running = 0;
std::atomic<bool> start = false;
auto writer = [dst, &running, &start] {
running++;
while (!start) {
sched_yield();
}
for (int i = 0; i < 100000; i++) {
mandatory_memset(dst, 0x1, 128);
}
};
auto decommitter = [&vmo, &running, &start] {
running++;
while (!start) {
sched_yield();
}
for (int i = 0; i < 100000; i++) {
EXPECT_OK(vmo.op_range(ZX_VMO_OP_DECOMMIT, kVmoSize / 2, 4096, nullptr, 0));
}
};
std::vector<std::thread> threads;
for (size_t i = 0; i < kNumThreads; i++) {
threads.push_back(std::thread(writer));
threads.push_back(std::thread(decommitter));
}
while (running < kNumThreads * 2) {
sched_yield();
}
start = true;
for (auto &thread : threads) {
thread.join();
}
}
TEST(VmoTestCase, ParallelRead) {
constexpr size_t kNumPages = 1024;
zx::vmo vmo1, vmo2;
EXPECT_OK(zx::vmo::create(zx_system_get_page_size() * kNumPages, 0, &vmo1));
EXPECT_OK(zx::vmo::create(zx_system_get_page_size() * kNumPages, 0, &vmo2));
uintptr_t vaddr1, vaddr2;
// Map the bottom half of both in.
EXPECT_OK(zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo1, 0,
zx_system_get_page_size() * (kNumPages / 2), &vaddr1));
EXPECT_OK(zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo2, 0,
zx_system_get_page_size() * (kNumPages / 2), &vaddr2));
// Spin up a thread to read from one of the vmos, whilst we read from the other
auto vmo_read_closure = [&vmo1, &vaddr2] {
vmo1.read(reinterpret_cast<void *>(vaddr2), zx_system_get_page_size() * (kNumPages / 2),
zx_system_get_page_size() * (kNumPages / 2));
};
std::thread thread(vmo_read_closure);
// As these two threads read from one vmo into the mapping from another vmo if there are any
// scenarios where the kernel would try and hold both vmo locks at the same time (without
// attempting to resolve lock ordering) then this should trigger a deadlock to occur.
EXPECT_OK(vmo2.read(reinterpret_cast<void *>(vaddr1), zx_system_get_page_size() * (kNumPages / 2),
zx_system_get_page_size() * (kNumPages / 2)));
thread.join();
}
TEST(VmoTestCase, ReadOnlyMap) {
zx_status_t status;
zx_handle_t vmo;
// allocate an object and read/write from it
const size_t len = zx_system_get_page_size();
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// map it
uintptr_t ptr;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0, len, &ptr);
EXPECT_OK(status, "vm_map");
EXPECT_NE(0u, ptr, "vm_map");
EXPECT_EQ(false, probe_for_write((void *)ptr), "write");
status = zx_vmar_unmap(zx_vmar_root_self(), ptr, len);
EXPECT_OK(status, "vm_unmap");
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
}
TEST(VmoTestCase, NoPermMap) {
zx_status_t status;
zx_handle_t vmo;
// allocate an object and read/write from it
const size_t len = zx_system_get_page_size();
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// map it with read permissions
uintptr_t ptr;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0, len, &ptr);
EXPECT_OK(status, "vm_map");
EXPECT_NE(0u, ptr, "vm_map");
// protect it to no permissions
status = zx_vmar_protect(zx_vmar_root_self(), 0, ptr, len);
EXPECT_OK(status, "vm_protect");
// test reading writing to the mapping
EXPECT_EQ(false, probe_for_read(reinterpret_cast<void *>(ptr)), "read");
EXPECT_EQ(false, probe_for_write(reinterpret_cast<void *>(ptr)), "write");
status = zx_vmar_unmap(zx_vmar_root_self(), ptr, len);
EXPECT_OK(status, "vm_unmap");
// close the handle
EXPECT_OK(zx_handle_close(vmo), "handle_close");
}
TEST(VmoTestCase, NoPermProtect) {
zx_status_t status;
zx_handle_t vmo;
// allocate an object and read/write from it
const size_t len = zx_system_get_page_size();
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// map it with no permissions
uintptr_t ptr;
status = zx_vmar_map(zx_vmar_root_self(), 0, 0, vmo, 0, len, &ptr);
EXPECT_OK(status, "vm_map");
EXPECT_NE(0u, ptr, "vm_map");
// test writing to the mapping
EXPECT_EQ(false, probe_for_write(reinterpret_cast<void *>(ptr)), "write");
// test reading to the mapping
EXPECT_EQ(false, probe_for_read(reinterpret_cast<void *>(ptr)), "read");
// protect it to read permissions and make sure it works as expected
status = zx_vmar_protect(zx_vmar_root_self(), ZX_VM_PERM_READ, ptr, len);
EXPECT_OK(status, "vm_protect");
// test writing to the mapping
EXPECT_EQ(false, probe_for_write(reinterpret_cast<void *>(ptr)), "write");
// test reading from the mapping
EXPECT_EQ(true, probe_for_read(reinterpret_cast<void *>(ptr)), "read");
status = zx_vmar_unmap(zx_vmar_root_self(), ptr, len);
EXPECT_OK(status, "vm_unmap");
// close the handle
EXPECT_OK(zx_handle_close(vmo), "handle_close");
}
TEST(VmoTestCase, Resize) {
zx_status_t status;
zx_handle_t vmo;
// allocate an object
size_t len = zx_system_get_page_size() * 4;
status = zx_vmo_create(len, ZX_VMO_RESIZABLE, &vmo);
EXPECT_OK(status, "vm_object_create");
// get the size that we set it to
uint64_t size = 0x99999999;
status = zx_vmo_get_size(vmo, &size);
EXPECT_OK(status, "vm_object_get_size");
EXPECT_EQ(len, size, "vm_object_get_size");
// try to resize it
len += zx_system_get_page_size();
status = zx_vmo_set_size(vmo, len);
EXPECT_OK(status, "vm_object_set_size");
// get the size again
size = 0x99999999;
status = zx_vmo_get_size(vmo, &size);
EXPECT_OK(status, "vm_object_get_size");
EXPECT_EQ(len, size, "vm_object_get_size");
// try to resize it to a ludicrous size
status = zx_vmo_set_size(vmo, UINT64_MAX);
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, status, "vm_object_set_size too big");
// resize it to a non aligned size
status = zx_vmo_set_size(vmo, len + 1);
EXPECT_OK(status, "vm_object_set_size");
// size should be rounded up to the next page boundary
size = 0x99999999;
status = zx_vmo_get_size(vmo, &size);
EXPECT_OK(status, "vm_object_get_size");
EXPECT_EQ(fbl::round_up(len + 1u, static_cast<size_t>(zx_system_get_page_size())), size,
"vm_object_get_size");
len = fbl::round_up(len + 1u, static_cast<size_t>(zx_system_get_page_size()));
// map it
uintptr_t ptr;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0, len, &ptr);
EXPECT_OK(status, "vm_map");
EXPECT_NE(ptr, 0, "vm_map");
// attempt to map expecting an non resizable vmo.
uintptr_t ptr2;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_REQUIRE_NON_RESIZABLE, 0, vmo,
0, len, &ptr2);
EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, status, "vm_map");
// resize it with it mapped
status = zx_vmo_set_size(vmo, size);
EXPECT_OK(status, "vm_object_set_size");
// unmap it
status = zx_vmar_unmap(zx_vmar_root_self(), ptr, len);
EXPECT_OK(status, "unmap");
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
}
// Check that non-resizable VMOs cannot get resized.
TEST(VmoTestCase, NoResize) {
const size_t len = zx_system_get_page_size() * 4;
zx_handle_t vmo = ZX_HANDLE_INVALID;
zx_vmo_create(len, 0, &vmo);
EXPECT_NE(vmo, ZX_HANDLE_INVALID);
zx_status_t status;
status = zx_vmo_set_size(vmo, len + zx_system_get_page_size());
EXPECT_EQ(ZX_ERR_UNAVAILABLE, status, "vm_object_set_size");
status = zx_vmo_set_size(vmo, len - zx_system_get_page_size());
EXPECT_EQ(ZX_ERR_UNAVAILABLE, status, "vm_object_set_size");
size_t size;
status = zx_vmo_get_size(vmo, &size);
EXPECT_OK(status, "vm_object_get_size");
EXPECT_EQ(len, size, "vm_object_get_size");
uintptr_t ptr;
status = zx_vmar_map(zx_vmar_root_self(),
ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_REQUIRE_NON_RESIZABLE, 0, vmo, 0,
len, &ptr);
ASSERT_OK(status, "vm_map");
ASSERT_NE(ptr, 0, "vm_map");
status = zx_vmar_unmap(zx_vmar_root_self(), ptr, len);
EXPECT_OK(status, "unmap");
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
}
TEST(VmoTestCase, Info) {
size_t len = zx_system_get_page_size() * 4;
zx::vmo vmo;
zx_info_vmo_t info;
zx_status_t status;
// Create a non-resizeable VMO, query the INFO on it
// and dump it.
status = zx::vmo::create(len, 0, &vmo);
EXPECT_OK(status, "vm_info_test: vmo_create");
status = vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr);
EXPECT_OK(status, "vm_info_test: info_vmo");
vmo.reset();
EXPECT_EQ(info.size_bytes, len, "vm_info_test: info_vmo.size_bytes");
EXPECT_EQ(info.flags, ZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_VIA_HANDLE,
"vm_info_test: info_vmo.flags");
EXPECT_EQ(info.cache_policy, ZX_CACHE_POLICY_CACHED, "vm_info_test: info_vmo.cache_policy");
// Create a resizeable uncached VMO, query the INFO on it and dump it.
len = zx_system_get_page_size() * 8;
zx::vmo::create(len, ZX_VMO_RESIZABLE, &vmo);
EXPECT_OK(status, "vm_info_test: vmo_create");
vmo.set_cache_policy(ZX_CACHE_POLICY_UNCACHED);
size_t actual, avail;
status = vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), &actual, &avail);
EXPECT_OK(status, "vm_info_test: info_vmo");
EXPECT_EQ(actual, 1);
EXPECT_EQ(avail, 1);
zx_info_handle_basic_t basic_info;
status = vmo.get_info(ZX_INFO_HANDLE_BASIC, &basic_info, sizeof(basic_info), &actual, &avail);
EXPECT_OK(status, "vm_info_test: info_handle_basic");
EXPECT_EQ(actual, 1);
EXPECT_EQ(avail, 1);
vmo.reset();
EXPECT_EQ(info.size_bytes, len, "vm_info_test: info_vmo.size_bytes");
EXPECT_EQ(info.flags, ZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_VIA_HANDLE | ZX_INFO_VMO_RESIZABLE,
"vm_info_test: info_vmo.flags");
EXPECT_EQ(info.cache_policy, ZX_CACHE_POLICY_UNCACHED, "vm_info_test: info_vmo.cache_policy");
EXPECT_EQ(info.handle_rights, basic_info.rights, "vm_info_test: info_vmo.handle_rights");
if (get_root_resource) {
zx::iommu iommu;
zx::bti bti;
auto final_bti_check = vmo_test::CreateDeferredBtiCheck(bti);
// Please do not use get_root_resource() in new code. See fxbug.dev/31358.
zx::unowned_resource root_res(get_root_resource());
zx_iommu_desc_dummy_t desc;
EXPECT_EQ(zx_iommu_create((*root_res).get(), ZX_IOMMU_TYPE_DUMMY, &desc, sizeof(desc),
iommu.reset_and_get_address()),
ZX_OK);
bti = vmo_test::CreateNamedBti(iommu, 0, 0xdeadbeef, "VmoTestCase::Info");
len = zx_system_get_page_size() * 12;
EXPECT_OK(zx::vmo::create_contiguous(bti, len, 0, &vmo));
status = vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr);
EXPECT_OK(status, "vm_info_test: info_vmo");
EXPECT_EQ(info.size_bytes, len, "vm_info_test: info_vmo.size_bytes");
EXPECT_EQ(info.flags, ZX_INFO_VMO_TYPE_PAGED | ZX_INFO_VMO_VIA_HANDLE | ZX_INFO_VMO_CONTIGUOUS,
"vm_info_test: info_vmo.flags");
EXPECT_EQ(info.cache_policy, ZX_CACHE_POLICY_CACHED, "vm_info_test: info_vmo.cache_policy");
}
}
TEST(VmoTestCase, SizeAlign) {
for (uint64_t s = 0; s < zx_system_get_page_size() * 4; s++) {
zx_handle_t vmo;
// create a new object with nonstandard size
zx_status_t status = zx_vmo_create(s, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// should be the size rounded up to the nearest page boundary
uint64_t size = 0x99999999;
status = zx_vmo_get_size(vmo, &size);
EXPECT_OK(status, "vm_object_get_size");
EXPECT_EQ(fbl::round_up(s, static_cast<size_t>(zx_system_get_page_size())), size,
"vm_object_get_size");
// close the handle
EXPECT_OK(zx_handle_close(vmo), "handle_close");
}
}
TEST(VmoTestCase, ResizeAlign) {
// resize a vmo with a particular size and test that the resulting size is aligned on a page
// boundary.
zx_handle_t vmo;
zx_status_t status = zx_vmo_create(0, ZX_VMO_RESIZABLE, &vmo);
EXPECT_OK(status, "vm_object_create");
for (uint64_t s = 0; s < zx_system_get_page_size() * 4; s++) {
// set the size of the object
zx_status_t status = zx_vmo_set_size(vmo, s);
EXPECT_OK(status, "vm_object_create");
// should be the size rounded up to the nearest page boundary
uint64_t size = 0x99999999;
status = zx_vmo_get_size(vmo, &size);
EXPECT_OK(status, "vm_object_get_size");
EXPECT_EQ(fbl::round_up(s, static_cast<size_t>(zx_system_get_page_size())), size,
"vm_object_get_size");
}
// close the handle
EXPECT_OK(zx_handle_close(vmo), "handle_close");
}
TEST(VmoTestCase, ContentSize) {
zx_status_t status;
zx::vmo vmo;
size_t len = zx_system_get_page_size() * 4;
status = zx::vmo::create(len, ZX_VMO_RESIZABLE, &vmo);
EXPECT_OK(status, "zx::vmo::create");
uint64_t content_size = 42;
status = vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &content_size, sizeof(content_size));
EXPECT_OK(status, "get_property");
EXPECT_EQ(len, content_size);
uint64_t target_size = len / 3;
status = vmo.set_property(ZX_PROP_VMO_CONTENT_SIZE, &target_size, sizeof(target_size));
EXPECT_OK(status, "set_property");
content_size = 42;
status = vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &content_size, sizeof(content_size));
EXPECT_OK(status, "get_property");
EXPECT_EQ(target_size, content_size);
target_size = len + 15643;
status = vmo.set_property(ZX_PROP_VMO_CONTENT_SIZE, &target_size, sizeof(target_size));
EXPECT_OK(status, "set_property");
content_size = 42;
status = vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &content_size, sizeof(content_size));
EXPECT_OK(status, "get_property");
EXPECT_EQ(target_size, content_size);
target_size = 5461;
status = vmo.set_size(target_size);
EXPECT_OK(status, "set_size");
content_size = 42;
status = vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &content_size, sizeof(content_size));
EXPECT_OK(status, "get_property");
EXPECT_EQ(target_size, content_size);
}
void RightsTestMapHelper(zx_handle_t vmo, size_t len, uint32_t flags, bool expect_success,
zx_status_t fail_err_code) {
uintptr_t ptr;
zx_status_t r = zx_vmar_map(zx_vmar_root_self(), flags, 0, vmo, 0, len, &ptr);
if (expect_success) {
EXPECT_OK(r);
r = zx_vmar_unmap(zx_vmar_root_self(), ptr, len);
EXPECT_OK(r, "unmap");
} else {
EXPECT_EQ(fail_err_code, r);
}
}
zx_rights_t GetHandleRights(zx_handle_t h) {
zx_info_handle_basic_t info;
zx_status_t s =
zx_object_get_info(h, ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
if (s != ZX_OK) {
EXPECT_OK(s); // Poison the test
return 0;
}
return info.rights;
}
void ChildPermsTestHelper(const zx_handle_t vmo) {
// Read out the current rights;
const zx_rights_t parent_rights = GetHandleRights(vmo);
// Make different kinds of children and ensure we get the correct rights.
zx_handle_t child;
EXPECT_OK(zx_vmo_create_child(vmo, ZX_VMO_CHILD_SNAPSHOT, 0, zx_system_get_page_size(), &child));
EXPECT_EQ(GetHandleRights(child),
(parent_rights | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_SET_PROPERTY | ZX_RIGHT_WRITE) &
~ZX_RIGHT_EXECUTE);
EXPECT_OK(zx_handle_close(child));
EXPECT_OK(zx_vmo_create_child(vmo, ZX_VMO_CHILD_SNAPSHOT | ZX_VMO_CHILD_NO_WRITE, 0,
zx_system_get_page_size(), &child));
EXPECT_EQ(GetHandleRights(child),
(parent_rights | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_SET_PROPERTY) & ~ZX_RIGHT_WRITE);
EXPECT_OK(zx_handle_close(child));
EXPECT_OK(zx_vmo_create_child(vmo, ZX_VMO_CHILD_SLICE, 0, zx_system_get_page_size(), &child));
EXPECT_EQ(GetHandleRights(child), parent_rights | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_SET_PROPERTY);
EXPECT_OK(zx_handle_close(child));
EXPECT_OK(zx_vmo_create_child(vmo, ZX_VMO_CHILD_SLICE | ZX_VMO_CHILD_NO_WRITE, 0,
zx_system_get_page_size(), &child));
EXPECT_EQ(GetHandleRights(child),
(parent_rights | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_SET_PROPERTY) & ~ZX_RIGHT_WRITE);
EXPECT_OK(zx_handle_close(child));
}
TEST(VmoTestCase, Rights) {
char buf[4096];
size_t len = zx_system_get_page_size() * 4;
zx_status_t status;
zx_handle_t vmo, vmo2;
// allocate an object
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// Check that the handle has at least the expected rights.
// This list should match the list in docs/syscalls/vmo_create.md.
static const zx_rights_t kExpectedRights =
ZX_RIGHT_DUPLICATE | ZX_RIGHT_TRANSFER | ZX_RIGHT_WAIT | ZX_RIGHT_READ | ZX_RIGHT_WRITE |
ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_SET_PROPERTY;
EXPECT_EQ(kExpectedRights, kExpectedRights & GetHandleRights(vmo));
// test that we can read/write it
status = zx_vmo_read(vmo, buf, 0, 0);
EXPECT_EQ(0, status, "vmo_read");
status = zx_vmo_write(vmo, buf, 0, 0);
EXPECT_EQ(0, status, "vmo_write");
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ, &vmo2);
status = zx_vmo_read(vmo2, buf, 0, 0);
EXPECT_EQ(0, status, "vmo_read");
status = zx_vmo_write(vmo2, buf, 0, 0);
EXPECT_EQ(ZX_ERR_ACCESS_DENIED, status, "vmo_write");
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_WRITE, &vmo2);
status = zx_vmo_read(vmo2, buf, 0, 0);
EXPECT_EQ(ZX_ERR_ACCESS_DENIED, status, "vmo_read");
status = zx_vmo_write(vmo2, buf, 0, 0);
EXPECT_EQ(0, status, "vmo_write");
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, 0, &vmo2);
status = zx_vmo_read(vmo2, buf, 0, 0);
EXPECT_EQ(ZX_ERR_ACCESS_DENIED, status, "vmo_read");
status = zx_vmo_write(vmo2, buf, 0, 0);
EXPECT_EQ(ZX_ERR_ACCESS_DENIED, status, "vmo_write");
zx_handle_close(vmo2);
// full perm test
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, true, 0));
// try most of the permutations of mapping and clone a vmo with various rights dropped
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_DUPLICATE, &vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, false,
ZX_ERR_ACCESS_DENIED));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE, &vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, false,
ZX_ERR_ACCESS_DENIED));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_WRITE | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE, &vmo2);
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, false,
ZX_ERR_ACCESS_DENIED));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE,
&vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, true, 0));
zx_handle_close(vmo2);
// test that we can get/set a property on it
const char *set_name = "test vmo";
status = zx_object_set_property(vmo, ZX_PROP_NAME, set_name, sizeof(set_name));
EXPECT_OK(status, "set_property");
char get_name[ZX_MAX_NAME_LEN];
status = zx_object_get_property(vmo, ZX_PROP_NAME, get_name, sizeof(get_name));
EXPECT_OK(status, "get_property");
EXPECT_STREQ(set_name, get_name, "vmo name");
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
// Use wrong handle with wrong permission, and expect wrong type not
// ZX_ERR_ACCESS_DENIED
vmo = ZX_HANDLE_INVALID;
vmo2 = ZX_HANDLE_INVALID;
status = zx_port_create(0, &vmo);
EXPECT_OK(status, "zx_port_create");
status = zx_handle_duplicate(vmo, 0, &vmo2);
EXPECT_OK(status, "zx_handle_duplicate");
status = zx_vmo_read(vmo2, buf, 0, 0);
EXPECT_EQ(ZX_ERR_WRONG_TYPE, status, "vmo_read wrong type");
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
status = zx_handle_close(vmo2);
EXPECT_OK(status, "handle_close");
}
// This test covers VMOs with the execute bit set using the vmo_replace_as_executable syscall.
// This call is available in the unified core-tests binary and in the bootfs environment, but not
// when running as a component in a full Fuchsia system.
TEST(VmoTestCase, RightsExec) {
if (getenv("NO_AMBIENT_MARK_VMO_EXEC")) {
ZXTEST_SKIP("Running without the ZX_POL_AMBIENT_MARK_VMO_EXEC policy, skipping test case.");
}
size_t len = zx_system_get_page_size() * 4;
zx_status_t status;
zx_handle_t vmo, vmo2;
// allocate an object
status = zx_vmo_create(len, 0, &vmo);
EXPECT_OK(status, "vm_object_create");
// Check that the handle has at least the expected rights.
// This list should match the list in docs/syscalls/vmo_create.md.
static const zx_rights_t kExpectedRights =
ZX_RIGHT_DUPLICATE | ZX_RIGHT_TRANSFER | ZX_RIGHT_WAIT | ZX_RIGHT_READ | ZX_RIGHT_WRITE |
ZX_RIGHT_MAP | ZX_RIGHT_GET_PROPERTY | ZX_RIGHT_SET_PROPERTY;
EXPECT_EQ(kExpectedRights, kExpectedRights & GetHandleRights(vmo));
status = zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo);
EXPECT_OK(status, "vmo_replace_as_executable");
EXPECT_EQ(kExpectedRights | ZX_RIGHT_EXECUTE,
(kExpectedRights | ZX_RIGHT_EXECUTE) & GetHandleRights(vmo));
// full perm test
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(
vmo, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo, len, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE, true, 0));
// try most of the permutations of mapping and clone a vmo with various rights dropped
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_EXECUTE | ZX_RIGHT_DUPLICATE,
&vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE,
false, ZX_ERR_ACCESS_DENIED));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE, &vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE,
false, ZX_ERR_ACCESS_DENIED));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_WRITE | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE, &vmo2);
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, false, ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE,
false, ZX_ERR_ACCESS_DENIED));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE,
&vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE,
false, ZX_ERR_ACCESS_DENIED));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(vmo, ZX_RIGHT_READ | ZX_RIGHT_EXECUTE | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE,
&vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE, false,
ZX_ERR_ACCESS_DENIED));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo, len, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE, true, 0));
zx_handle_close(vmo2);
vmo2 = ZX_HANDLE_INVALID;
zx_handle_duplicate(
vmo, ZX_RIGHT_READ | ZX_RIGHT_WRITE | ZX_RIGHT_EXECUTE | ZX_RIGHT_MAP | ZX_RIGHT_DUPLICATE,
&vmo2);
ASSERT_NO_FATAL_FAILURE(ChildPermsTestHelper(vmo2));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, 0, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_WRITE, false, ZX_ERR_INVALID_ARGS));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, true, 0));
ASSERT_NO_FATAL_FAILURE(RightsTestMapHelper(
vmo2, len, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE, true, 0));
ASSERT_NO_FATAL_FAILURE(
RightsTestMapHelper(vmo, len, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE, true, 0));
// close the handles
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
status = zx_handle_close(vmo2);
EXPECT_OK(status, "handle_close");
}
TEST(VmoTestCase, Commit) {
zx_handle_t vmo;
zx_status_t status;
uintptr_t ptr, ptr2, ptr3;
// create a vmo
const size_t size = 16384;
status = zx_vmo_create(size, 0, &vmo);
EXPECT_EQ(0, status, "vm_object_create");
// commit a range of it
status = zx_vmo_op_range(vmo, ZX_VMO_OP_COMMIT, 0, size, nullptr, 0);
EXPECT_EQ(0, status, "vm commit");
// decommit that range
status = zx_vmo_op_range(vmo, ZX_VMO_OP_DECOMMIT, 0, size, nullptr, 0);
EXPECT_EQ(0, status, "vm decommit");
// commit a range of it
status = zx_vmo_op_range(vmo, ZX_VMO_OP_COMMIT, 0, size, nullptr, 0);
EXPECT_EQ(0, status, "vm commit");
// map it
ptr = 0;
status =
zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size, &ptr);
EXPECT_OK(status, "map");
EXPECT_NE(ptr, 0, "map address");
// second mapping with an offset
ptr2 = 0;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo,
zx_system_get_page_size(), size, &ptr2);
EXPECT_OK(status, "map2");
EXPECT_NE(ptr2, 0, "map address2");
// third mapping with a totally non-overlapping offset
ptr3 = 0;
status = zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, size * 2,
size, &ptr3);
EXPECT_OK(status, "map3");
EXPECT_NE(ptr3, 0, "map address3");
// write into it at offset zx_system_get_page_size(), read it back
volatile uint32_t *u32 = (volatile uint32_t *)(ptr + zx_system_get_page_size());
*u32 = 99;
EXPECT_EQ(99u, (*u32), "written memory");
// check the alias
volatile uint32_t *u32a = (volatile uint32_t *)(ptr2);
EXPECT_EQ(99u, (*u32a), "written memory");
// decommit page 0
status = zx_vmo_op_range(vmo, ZX_VMO_OP_DECOMMIT, 0, zx_system_get_page_size(), nullptr, 0);
EXPECT_EQ(0, status, "vm decommit");
// verify that it didn't get unmapped
EXPECT_EQ(99u, (*u32), "written memory");
// verify that it didn't get unmapped
EXPECT_EQ(99u, (*u32a), "written memory2");
// decommit page 1
status = zx_vmo_op_range(vmo, ZX_VMO_OP_DECOMMIT, zx_system_get_page_size(),
zx_system_get_page_size(), nullptr, 0);
EXPECT_EQ(0, status, "vm decommit");
// verify that it did get unmapped
EXPECT_EQ(0u, (*u32), "written memory");
// verify that it did get unmapped
EXPECT_EQ(0u, (*u32a), "written memory2");
// unmap our vmos
status = zx_vmar_unmap(zx_vmar_root_self(), ptr, size);
EXPECT_OK(status, "vm_unmap");
status = zx_vmar_unmap(zx_vmar_root_self(), ptr2, size);
EXPECT_OK(status, "vm_unmap");
status = zx_vmar_unmap(zx_vmar_root_self(), ptr3, size);
EXPECT_OK(status, "vm_unmap");
// commit invalid ranges that overflow.
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
zx_vmo_op_range(vmo, ZX_VMO_OP_COMMIT, zx_system_get_page_size(),
UINT64_MAX - zx_system_get_page_size() + 1, nullptr, 0));
// close the handle
status = zx_handle_close(vmo);
EXPECT_OK(status, "handle_close");
}
TEST(VmoTestCase, ZeroPage) {
zx_handle_t vmo;
zx_status_t status;
uintptr_t ptr[3];
// create a vmo
const size_t size = zx_system_get_page_size() * 4;
EXPECT_OK(zx_vmo_create(size, 0, &vmo), "vm_object_create");
// make a few mappings of the vmo
for (auto &p : ptr) {
EXPECT_EQ(
ZX_OK,
zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size, &p),
"map");
EXPECT_NE(0, p, "map address");
}
volatile uint32_t *val = (volatile uint32_t *)ptr[0];
volatile uint32_t *val2 = (volatile uint32_t *)ptr[1];
volatile uint32_t *val3 = (volatile uint32_t *)ptr[2];
// read fault in the first mapping
EXPECT_EQ(0, *val, "read zero");
// write fault the second mapping
*val2 = 99;
EXPECT_EQ(99, *val2, "read back 99");
// expect the third mapping to read fault in the new page
EXPECT_EQ(99, *val3, "read 99");
// expect the first mapping to have gotten updated with the new mapping
// and no longer be mapping the zero page
EXPECT_EQ(99, *val, "read 99 from former zero page");
// read fault in zeros on the second page
val = (volatile uint32_t *)(ptr[0] + zx_system_get_page_size());
EXPECT_EQ(0, *val, "read zero");
// write to the page via a vmo_write call
uint32_t v = 100;
status = zx_vmo_write(vmo, &v, zx_system_get_page_size(), sizeof(v));
EXPECT_OK(status, "writing to vmo");
// expect it to read back the new value
EXPECT_EQ(100, *val, "read 100 from former zero page");
// read fault in zeros on the third page
val = (volatile uint32_t *)(ptr[0] + zx_system_get_page_size() * 2);
EXPECT_EQ(0, *val, "read zero");
// commit this range of the vmo via a commit call
status = zx_vmo_op_range(vmo, ZX_VMO_OP_COMMIT, zx_system_get_page_size() * 2,
zx_system_get_page_size(), nullptr, 0);
EXPECT_OK(status, "committing memory");
// write to the third page
status = zx_vmo_write(vmo, &v, zx_system_get_page_size() * 2, sizeof(v));
EXPECT_OK(status, "writing to vmo");
// expect it to read back the new value
EXPECT_EQ(100, *val, "read 100 from former zero page");
// unmap
for (auto p : ptr)
EXPECT_OK(zx_vmar_unmap(zx_vmar_root_self(), p, size), "unmap");
// close the handle
EXPECT_OK(zx_handle_close(vmo), "handle_close");
}
TEST(VmoTestCase, Cache) {
zx::vmo vmo;
const size_t size = zx_system_get_page_size();
EXPECT_OK(zx::vmo::create(size, 0, &vmo), "creation for cache_policy");
// clean vmo can have all valid cache policies set
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_UNCACHED));
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_UNCACHED_DEVICE));
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_WRITE_COMBINING));
// bad cache policy
EXPECT_EQ(ZX_ERR_INVALID_ARGS, vmo.set_cache_policy(ZX_CACHE_POLICY_MASK + 1));
// map the vmo, make sure policy doesn't set
uintptr_t ptr;
EXPECT_OK(zx::vmar::root_self()->map(ZX_VM_PERM_READ, 0, vmo, 0, size, &ptr));
EXPECT_EQ(ZX_ERR_BAD_STATE, vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
EXPECT_OK(zx::vmar::root_self()->unmap(ptr, size));
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
// clone the vmo, make sure policy doesn't set
zx::vmo clone;
EXPECT_OK(vmo.create_child(ZX_VMO_CHILD_SNAPSHOT, 0, size, &clone));
EXPECT_EQ(ZX_ERR_BAD_STATE, vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
clone.reset();
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
// clone the vmo, try to set policy on the clone
EXPECT_OK(vmo.create_child(ZX_VMO_CHILD_SNAPSHOT, 0, size, &clone));
EXPECT_EQ(ZX_ERR_BAD_STATE, clone.set_cache_policy(ZX_CACHE_POLICY_CACHED));
clone.reset();
// set the policy, make sure future clones do not go through
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_UNCACHED));
EXPECT_EQ(ZX_ERR_BAD_STATE, vmo.create_child(ZX_VMO_CHILD_SNAPSHOT, 0, size, &clone));
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
EXPECT_OK(vmo.create_child(ZX_VMO_CHILD_SNAPSHOT, 0, size, &clone));
clone.reset();
// set the policy, make sure vmo read/write do not work
char c;
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_UNCACHED));
EXPECT_EQ(ZX_ERR_BAD_STATE, vmo.read(&c, 0, sizeof(c)));
EXPECT_EQ(ZX_ERR_BAD_STATE, vmo.write(&c, 0, sizeof(c)));
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
EXPECT_OK(vmo.read(&c, 0, sizeof(c)));
EXPECT_OK(vmo.write(&c, 0, sizeof(c)));
vmo.reset();
// Create a large sparsely populated VMO and check setting cache policy works.
EXPECT_OK(zx::vmo::create(size << 40, 0, &vmo));
c = 42;
EXPECT_OK(vmo.write(&c, 1ull << 50, sizeof(c)));
EXPECT_OK(vmo.set_cache_policy(ZX_CACHE_POLICY_UNCACHED));
vmo.reset();
}
TEST(VmoTestCase, PhysicalSlice) {
vmo_test::PhysVmo phys;
if (auto res = vmo_test::GetTestPhysVmo(); !res.is_ok()) {
if (res.error_value() == ZX_ERR_NOT_SUPPORTED) {
printf("Root resource not available, skipping\n");
}
return;
} else {
phys = std::move(res.value());
}
const size_t size = zx_system_get_page_size() * 2;
ASSERT_GE(phys.size, size);
// Switch to a cached policy as we are operating on real memory and do not need to be uncached.
EXPECT_OK(phys.vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED));
zx_info_vmo_t phys_vmo_info;
ASSERT_OK(
phys.vmo.get_info(ZX_INFO_VMO, &phys_vmo_info, sizeof(phys_vmo_info), nullptr, nullptr));
ASSERT_NE(phys_vmo_info.koid, 0ul);
ASSERT_EQ(phys_vmo_info.parent_koid, 0ul);
// Create a slice of the second page.
zx::vmo slice_vmo;
EXPECT_OK(phys.vmo.create_child(ZX_VMO_CHILD_SLICE, size / 2, size / 2, &slice_vmo));
// Sliced VMO should have correct parent_koid in its VMO info struct.
zx_info_vmo_t slice_vmo_info;
ASSERT_OK(
slice_vmo.get_info(ZX_INFO_VMO, &slice_vmo_info, sizeof(slice_vmo_info), nullptr, nullptr));
ASSERT_EQ(slice_vmo_info.parent_koid, phys_vmo_info.koid);
// Map both VMOs in so we can access them.
uintptr_t parent_vaddr;
EXPECT_OK(zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, phys.vmo, 0, size,
&parent_vaddr));
uintptr_t slice_vaddr;
EXPECT_OK(zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, slice_vmo, 0,
size / 2, &slice_vaddr));
// Just do some tests using the first byte of each page
char *parent_private_test = (char *)parent_vaddr;
char *parent_shared_test = (char *)(parent_vaddr + size / 2);
char *slice_test = (char *)slice_vaddr;
// We expect parent_shared_test and slice_test to be accessing the same physical pages, but we
// should have gotten different mappings for them.
EXPECT_NE(parent_shared_test, slice_test);
*parent_private_test = 0;
*parent_shared_test = 1;
// This should have set the child.
EXPECT_EQ(*slice_test, 1);
// Write to the child now and validate parent changed correctly.
*slice_test = 42;
EXPECT_EQ(*parent_shared_test, 42);
EXPECT_EQ(*parent_private_test, 0);
}
TEST(VmoTestCase, CacheOp) {
constexpr size_t normal_size = 0x8000;
zx_handle_t normal_vmo = ZX_HANDLE_INVALID;
EXPECT_OK(zx_vmo_create(normal_size, 0, &normal_vmo), "creation for cache op (normal vmo)");
vmo_test::PhysVmo phys;
if (auto res = vmo_test::GetTestPhysVmo(); res.is_ok()) {
phys = std::move(res.value());
// Go ahead and set the cache policy; we don't want the op_range calls
// below to potentially skip running any code.
EXPECT_OK(phys.vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED), "zx_vmo_set_cache_policy");
ASSERT_GE(phys.size, normal_size);
}
auto test_vmo = [](zx_handle_t vmo, size_t size) {
if (vmo == ZX_HANDLE_INVALID) {
return;
}
auto test_op = [vmo, size](uint32_t op) {
EXPECT_OK(zx_vmo_op_range(vmo, op, 0, 1, nullptr, 0), "0 1");
EXPECT_OK(zx_vmo_op_range(vmo, op, 0, 1, nullptr, 0), "0 1");
EXPECT_OK(zx_vmo_op_range(vmo, op, 1, 1, nullptr, 0), "1 1");
EXPECT_OK(zx_vmo_op_range(vmo, op, 0, size, nullptr, 0), "0 size");
EXPECT_OK(zx_vmo_op_range(vmo, op, 1, size - 1, nullptr, 0), "1 size-1");
EXPECT_OK(zx_vmo_op_range(vmo, op, 0x5200, 1, nullptr, 0), "0x5200 1");
EXPECT_OK(zx_vmo_op_range(vmo, op, 0x5200, 0x800, nullptr, 0), "0x5200 0x800");
EXPECT_OK(zx_vmo_op_range(vmo, op, 0x5200, 0x1000, nullptr, 0), "0x5200 0x1000");
EXPECT_OK(zx_vmo_op_range(vmo, op, 0x5200, 0x1200, nullptr, 0), "0x5200 0x1200");
EXPECT_EQ(ZX_ERR_INVALID_ARGS, zx_vmo_op_range(vmo, op, 0, 0, nullptr, 0), "0 0");
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, zx_vmo_op_range(vmo, op, 1, size, nullptr, 0), "0 size");
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, zx_vmo_op_range(vmo, op, size, 1, nullptr, 0), "size 1");
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, zx_vmo_op_range(vmo, op, size + 1, 1, nullptr, 0), "size+1 1");
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, zx_vmo_op_range(vmo, op, UINT64_MAX - 1, 1, nullptr, 0),
"UINT64_MAX-1 1");
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, zx_vmo_op_range(vmo, op, UINT64_MAX, 1, nullptr, 0),
"UINT64_MAX 1");
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, zx_vmo_op_range(vmo, op, UINT64_MAX, UINT64_MAX, nullptr, 0),
"UINT64_MAX UINT64_MAX");
};
test_op(ZX_VMO_OP_CACHE_SYNC);
test_op(ZX_VMO_OP_CACHE_CLEAN);
test_op(ZX_VMO_OP_CACHE_CLEAN_INVALIDATE);
test_op(ZX_VMO_OP_CACHE_INVALIDATE);
};
ASSERT_NE(ZX_HANDLE_INVALID, normal_vmo);
test_vmo(normal_vmo, normal_size);
// No need for a test ASSERT/EXPECT here. If we have access to the root
// resource, but could not create a physical VMO to test with, then
// GetTestPhysVmo has already signaled a test failure for us.
if (phys.vmo.is_valid()) {
test_vmo(phys.vmo.get(), phys.size);
}
EXPECT_OK(zx_handle_close(normal_vmo), "close handle (normal vmo)");
// Closing ZX_HANDLE_INVALID is not an error.
EXPECT_OK(zx_handle_close(phys.vmo.release()), "close handle (physical vmo)");
}
TEST(VmoTestCase, CacheOpLargeVmo) {
zx::vmo vmo;
const uint64_t kMaxSize = UINT64_MAX - static_cast<uint64_t>(zx_system_get_page_size()) * 64 + 1;
ASSERT_OK(zx::vmo::create(kMaxSize, 0, &vmo));
// Cache ops should be quick on this VMO has it has no committed pages.
EXPECT_OK(vmo.op_range(ZX_VMO_OP_CACHE_CLEAN, 0, kMaxSize, nullptr, 0));
// Commit some pages around.
constexpr uint64_t kCommitPages = 64;
for (uint64_t i = 0; i < kCommitPages; i++) {
uint64_t val = 42;
const uint64_t offset = kMaxSize / kCommitPages * i;
EXPECT_OK(vmo.write(&val, offset, sizeof(val)));
}
// With these committed pages, ops should still be fast.
EXPECT_OK(vmo.op_range(ZX_VMO_OP_CACHE_CLEAN, 0, kMaxSize, nullptr, 0));
}
TEST(VmoTestCase, CacheOpOutOfRange) {
zx::vmo vmo;
ASSERT_OK(zx::vmo::create(zx_system_get_page_size() * 2, 0, &vmo));
// Commit the second page
EXPECT_OK(vmo.write("A", zx_system_get_page_size(), 1));
// Generate a bad cache op that exceeds the range of the vmo.
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, vmo.op_range(ZX_VMO_OP_CACHE_CLEAN_INVALIDATE,
zx_system_get_page_size(), UINT64_MAX, nullptr, 0));
// Generate a cache op close to integer wrap around
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
vmo.op_range(ZX_VMO_OP_CACHE_CLEAN_INVALIDATE,
UINT64_MAX - zx_system_get_page_size() + 1, 1, nullptr, 0));
}
TEST(VmoTestCase, CacheFlush) {
zx_handle_t vmo;
const size_t size = 0x8000;
EXPECT_OK(zx_vmo_create(size, 0, &vmo), "creation for cache op");
uintptr_t ptr_ro;
EXPECT_EQ(ZX_OK, zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ, 0, vmo, 0, size, &ptr_ro),
"map");
EXPECT_NE(ptr_ro, 0, "map address");
void *pro = (void *)ptr_ro;
uintptr_t ptr_rw;
EXPECT_EQ(ZX_OK,
zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size,
&ptr_rw),
"map");
EXPECT_NE(ptr_rw, 0, "map address");
void *prw = (void *)ptr_rw;
zx_vmo_op_range(vmo, ZX_VMO_OP_COMMIT, 0, size, NULL, 0);
EXPECT_OK(zx_cache_flush(prw, size, ZX_CACHE_FLUSH_INSN), "rw flush insn");
EXPECT_OK(zx_cache_flush(prw, size, ZX_CACHE_FLUSH_DATA), "rw clean");
EXPECT_OK(zx_cache_flush(prw, size, ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INSN),
"rw clean w/ insn");
EXPECT_OK(zx_cache_flush(prw, size, ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE),
"rw clean/invalidate");
EXPECT_EQ(ZX_OK,
zx_cache_flush(prw, size,
ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE | ZX_CACHE_FLUSH_INSN),
"rw all");
EXPECT_OK(zx_cache_flush(pro, size, ZX_CACHE_FLUSH_INSN), "ro flush insn");
EXPECT_OK(zx_cache_flush(pro, size, ZX_CACHE_FLUSH_DATA), "ro clean");
EXPECT_OK(zx_cache_flush(pro, size, ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INSN),
"ro clean w/ insn");
EXPECT_OK(zx_cache_flush(pro, size, ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE),
"ro clean/invalidate");
EXPECT_OK(zx_cache_flush(pro, size, ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE),
"ro clean/invalidate");
EXPECT_EQ(ZX_OK,
zx_cache_flush(pro, size,
ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE | ZX_CACHE_FLUSH_INSN),
"ro all");
// Above checks all valid options combinations; check that invalid
// combinations are handled correctly here.
EXPECT_EQ(ZX_ERR_INVALID_ARGS, zx_cache_flush(pro, size, 0), "no args");
EXPECT_EQ(ZX_ERR_INVALID_ARGS, zx_cache_flush(pro, size, ZX_CACHE_FLUSH_INVALIDATE),
"invalidate requires data");
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
zx_cache_flush(pro, size, ZX_CACHE_FLUSH_INSN | ZX_CACHE_FLUSH_INVALIDATE),
"invalidate requires data");
EXPECT_EQ(ZX_ERR_INVALID_ARGS, zx_cache_flush(pro, size, 1u << 3), "out of range a");
EXPECT_EQ(ZX_ERR_INVALID_ARGS, zx_cache_flush(pro, size, ~0u), "out of range b");
zx_vmar_unmap(zx_vmar_root_self(), ptr_rw, size);
zx_vmar_unmap(zx_vmar_root_self(), ptr_ro, size);
EXPECT_OK(zx_handle_close(vmo), "close handle");
}
TEST(VmoTestCase, DecommitMisaligned) {
zx_handle_t vmo;
EXPECT_OK(zx_vmo_create(zx_system_get_page_size() * 2, 0, &vmo), "creation for decommit test");
// Forbid unaligned decommit, even if there's nothing committed.
zx_status_t status = zx_vmo_op_range(vmo, ZX_VMO_OP_DECOMMIT, 0x10, 0x100, NULL, 0);
EXPECT_EQ(ZX_ERR_INVALID_ARGS, status, "decommitting uncommitted memory");
status = zx_vmo_op_range(vmo, ZX_VMO_OP_COMMIT, 0x10, 0x100, NULL, 0);
EXPECT_OK(status, "committing memory");
status = zx_vmo_op_range(vmo, ZX_VMO_OP_DECOMMIT, 0x10, 0x100, NULL, 0);
EXPECT_EQ(ZX_ERR_INVALID_ARGS, status, "decommitting memory");
EXPECT_OK(zx_handle_close(vmo), "close handle");
}
// Resizing a regular mapped VMO causes a fault.
TEST(VmoTestCase, ResizeHazard) {
const size_t size = zx_system_get_page_size() * 2;
zx_handle_t vmo;
ASSERT_OK(zx_vmo_create(size, ZX_VMO_RESIZABLE, &vmo));
uintptr_t ptr_rw;
EXPECT_OK(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size,
&ptr_rw),
"map");
auto int_arr = reinterpret_cast<int *>(ptr_rw);
EXPECT_EQ(int_arr[1], 0);
EXPECT_OK(zx_vmo_set_size(vmo, 0u));
EXPECT_EQ(false, probe_for_read(&int_arr[1]), "read probe");
EXPECT_EQ(false, probe_for_write(&int_arr[1]), "write probe");
EXPECT_OK(zx_handle_close(vmo));
EXPECT_OK(zx_vmar_unmap(zx_vmar_root_self(), ptr_rw, size), "unmap");
}
TEST(VmoTestCase, CompressedContiguous) {
if (!get_root_resource) {
printf("Root resource not available, skipping\n");
return;
}
zx::unowned_resource root_res(get_root_resource());
zx::iommu iommu;
zx::bti bti;
zx_iommu_desc_dummy_t desc;
auto final_bti_check = vmo_test::CreateDeferredBtiCheck(bti);
EXPECT_OK(zx::iommu::create(*root_res, ZX_IOMMU_TYPE_DUMMY, &desc, sizeof(desc), &iommu));
bti = vmo_test::CreateNamedBti(iommu, 0, 0xdeadbeef, "VmoTestCase::CompressedContiguous");
zx_info_bti_t bti_info;
EXPECT_OK(bti.get_info(ZX_INFO_BTI, &bti_info, sizeof(bti_info), nullptr, nullptr));
constexpr uint32_t kMaxAddrs = 2;
// If the minimum contiguity is too high this won't be an effective test, but
// the code should still work.
uint64_t size = std::min(128ul * 1024 * 1024, bti_info.minimum_contiguity * kMaxAddrs);
zx::vmo contig_vmo;
EXPECT_OK(zx::vmo::create_contiguous(bti, size, 0, &contig_vmo));
zx_paddr_t paddrs[kMaxAddrs];
uint64_t num_addrs =
fbl::round_up(size, bti_info.minimum_contiguity) / bti_info.minimum_contiguity;
zx::pmt pmt;
EXPECT_OK(
bti.pin(ZX_BTI_COMPRESS | ZX_BTI_PERM_READ, contig_vmo, 0, size, paddrs, num_addrs, &pmt));
pmt.unpin();
if (num_addrs > 1) {
zx::pmt pmt2;
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
bti.pin(ZX_BTI_COMPRESS | ZX_BTI_PERM_READ, contig_vmo, 0, size, paddrs, 1, &pmt2));
}
}
TEST(VmoTestCase, UncachedContiguous) {
if (!get_root_resource) {
printf("Root resource not available, skipping\n");
return;
}
zx::unowned_resource root_res(get_root_resource());
zx::iommu iommu;
zx::bti bti;
zx_iommu_desc_dummy_t desc;
auto final_bti_check = vmo_test::CreateDeferredBtiCheck(bti);
EXPECT_OK(zx::iommu::create(*root_res, ZX_IOMMU_TYPE_DUMMY, &desc, sizeof(desc), &iommu));
bti = vmo_test::CreateNamedBti(iommu, 0, 0xdeadbeef, "VmoTestCase::UncachedContiguous");
const uint64_t kSize = zx_system_get_page_size() * 4;
zx::vmo contig_vmo;
EXPECT_OK(zx::vmo::create_contiguous(bti, kSize, 0, &contig_vmo));
// Attempt to make the vmo uncached.
EXPECT_OK(contig_vmo.set_cache_policy(ZX_CACHE_POLICY_UNCACHED));
// Validate that it really is uncached by making sure operations that should fail, do.
uint64_t data = 42;
EXPECT_EQ(contig_vmo.write(&data, 0, sizeof(data)), ZX_ERR_BAD_STATE);
// Pin part of the vmo and validate we cannot change the cache policy whilst pinned.
zx_paddr_t paddr;
zx::pmt pmt;
EXPECT_OK(bti.pin(ZX_BTI_COMPRESS | ZX_BTI_PERM_READ, contig_vmo, 0, zx_system_get_page_size(),
&paddr, 1, &pmt));
EXPECT_EQ(contig_vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED), ZX_ERR_BAD_STATE);
// Unpin and then validate that we cannot move committed pages from uncached->cached
pmt.unpin();
EXPECT_EQ(contig_vmo.set_cache_policy(ZX_CACHE_POLICY_CACHED), ZX_ERR_BAD_STATE);
}
// Test various pinning operations. In particular, we would like to test
//
// ++ Pinning of normal VMOs, contiguous VMOs, and RAM backed physical VMOs.
// ++ Pinning of child-slices of VMOs.
// ++ Attempting to overpin regions section of VMOs, particularly overpin
// operations which do not fit in a target child-slice, but _would_ fit within
// the main parent VMO. See bug 53547 for details.
TEST(VmoTestCase, PinTests) {
if (!get_root_resource) {
printf("Root resource not available, skipping\n");
return;
}
constexpr size_t kTestPages = 6;
zx::unowned_resource root_res(get_root_resource());
zx::iommu iommu;
zx::bti bti;
zx_iommu_desc_dummy_t desc;
auto final_bti_check = vmo_test::CreateDeferredBtiCheck(bti);
EXPECT_OK(zx::iommu::create(*root_res, ZX_IOMMU_TYPE_DUMMY, &desc, sizeof(desc), &iommu));
bti = vmo_test::CreateNamedBti(iommu, 0, 0xdeadbeef, "VmoTestCase::PinTests");
enum class VmoFlavor { Normal, Contig, Physical };
constexpr std::array FLAVORS = {VmoFlavor::Normal, VmoFlavor::Contig, VmoFlavor::Physical};
for (auto flavor : FLAVORS) {
struct Level {
Level(size_t offset_pages, size_t size_pages)
: offset(offset_pages * zx_system_get_page_size()),
size(size_pages * zx_system_get_page_size()) {}
zx::vmo vmo;
const size_t offset;
const size_t size;
size_t size_past_end = 0;
};
std::array levels = {
Level{0, kTestPages},
Level{1, kTestPages - 2},
Level{1, kTestPages - 4},
};
// Create the root level of the child-slice hierarchy based on the flavor we
// are currently testing.
switch (flavor) {
case VmoFlavor::Normal:
ASSERT_OK(zx::vmo::create(levels[0].size, 0, &levels[0].vmo));
break;
case VmoFlavor::Contig:
ASSERT_OK(zx::vmo::create_contiguous(bti, levels[0].size, 0, &levels[0].vmo));
break;
case VmoFlavor::Physical:
if (auto res = vmo_test::GetTestPhysVmo(levels[0].size); !res.is_ok()) {
ASSERT_OK(res.error_value());
} else {
levels[0].vmo = std::move(res->vmo);
ASSERT_EQ(levels[0].size, res->size);
}
break;
}
// Now that we have our root, create each of our child slice levels. Each
// level will be offset by level[i].offset bytes into level[i - 1].vmo.
for (size_t i = 1; i < levels.size(); ++i) {
auto &child = levels[i];
auto &parent = levels[i - 1];
ASSERT_OK(parent.vmo.create_child(ZX_VMO_CHILD_SLICE, child.offset, child.size, &child.vmo));
// Compute the amount of space past this end of this child slice which
// still exists in the root VMO.
ASSERT_LE(child.size + child.offset, parent.size);
child.size_past_end = parent.size_past_end + (parent.size - (child.size + child.offset));
}
// OK, now we should be ready to test each of the levels.
for (const auto &level : levels) {
// Make sure that we test ranges which have starting and ending points
// entirely inside of the VMO, in the region after the VMO but inside the
// root VMO, and entirely outside of even the root VMO.
size_t root_end = level.size + level.size_past_end;
for (size_t start = 0; start <= root_end; start += zx_system_get_page_size()) {
for (size_t end = start + zx_system_get_page_size();
end <= (root_end + zx_system_get_page_size()); end += zx_system_get_page_size()) {
zx::pmt pmt;
uint64_t paddrs[kTestPages];
size_t size = end - start;
size_t expected_addrs = std::min(size / zx_system_get_page_size(), std::size(paddrs));
zx_status_t expected_status =
((start >= level.size) || (end > level.size)) ? ZX_ERR_OUT_OF_RANGE : ZX_OK;
EXPECT_STATUS(
bti.pin(ZX_BTI_PERM_READ, level.vmo, start, size, paddrs, expected_addrs, &pmt),
expected_status,
"Op was pin offset 0x%zx size 0x%zx in VMO (offset 0x%zx size 0x%zx spe 0x%zx)",
start, size, level.offset, level.size, level.size_past_end);
if (pmt.is_valid()) {
pmt.unpin();
pmt.reset();
}
}
}
}
}
}
TEST(VmoTestCase, DecommitChildSliceTests) {
constexpr size_t kTestPages = 6;
struct Level {
Level(size_t offset_pages, size_t size_pages)
: offset(offset_pages * zx_system_get_page_size()),
size(size_pages * zx_system_get_page_size()) {}
zx::vmo vmo;
const size_t offset;
const size_t size;
size_t size_past_end = 0;
};
std::array levels = {
Level{0, kTestPages},
Level{1, kTestPages - 2},
Level{1, kTestPages - 4},
};
// Create the root level of the child-slice hierarchy.
ASSERT_OK(zx::vmo::create(levels[0].size, 0, &levels[0].vmo));
// Now that we have our root, create each of our child slice levels. Each
// level will be offset by level[i].offset bytes into level[i - 1].vmo.
for (size_t i = 1; i < levels.size(); ++i) {
auto &child = levels[i];
auto &parent = levels[i - 1];
ASSERT_OK(parent.vmo.create_child(ZX_VMO_CHILD_SLICE, child.offset, child.size, &child.vmo));
// Compute the amount of space past this end of this child slice which
// still exists in the root VMO.
ASSERT_LE(child.size + child.offset, parent.size);
child.size_past_end = parent.size_past_end + (parent.size - (child.size + child.offset));
}
// OK, now we should be ready to test each of the levels.
for (const auto &level : levels) {
// Make sure that we test ranges which have starting and ending points
// entirely inside of the VMO, in the region after the VMO but inside the
// root VMO, and entirely outside of even the root VMO.
size_t root_end = level.size + level.size_past_end;
bool exercised_out_of_range = false;
bool exercised_ok = false;
for (size_t start = 0; start <= (root_end + zx_system_get_page_size());
start += zx_system_get_page_size()) {
for (size_t end = start + zx_system_get_page_size();
end <= (root_end + (2 * zx_system_get_page_size())); end += zx_system_get_page_size()) {
size_t size = end - start;
// Attempt to completely commit the root before the decommit operation.
EXPECT_OK(levels[0].vmo.op_range(ZX_VMO_OP_COMMIT, 0, levels[0].size, nullptr, 0));
// Now attempt to decommit our test range and check to make sure that we
// get the expected result. We only expect failure if our offset is out
// of range for our child VMO. We expect extra long sizes to be
// silently trimmed for us.
zx_status_t expected_status;
if (start > level.size) {
expected_status = ZX_ERR_OUT_OF_RANGE;
exercised_out_of_range = true;
} else {
expected_status = ZX_OK;
exercised_ok = true;
}
EXPECT_STATUS(
level.vmo.op_range(ZX_VMO_OP_DECOMMIT, start, size, nullptr, 0), expected_status,
"Decommit op was offset 0x%zx size 0x%zx in VMO (offset 0x%zx size 0x%zx spe 0x%zx)",
start, size, level.offset, level.size, level.size_past_end);
}
}
// For every level that we test, make sure we have at least one test vector
// which expects ZX_ERR_OUT_OF_RANGE and at least one which expects ZX_OK.
EXPECT_TRUE(exercised_out_of_range);
EXPECT_TRUE(exercised_ok);
}
}
TEST(VmoTestCase, MetadataBytes) {
zx::vmo vmo;
EXPECT_OK(zx::vmo::create(zx_system_get_page_size(), 0, &vmo));
// Until we use the VMO we expect metadata to be zero
zx_info_vmo_t info;
EXPECT_OK(vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr));
EXPECT_EQ(info.metadata_bytes, 0);
// This is a paged VMO so once we do something to commit a page we expect non-zero metadata.
EXPECT_OK(vmo.write(&info, 0, sizeof(info)));
EXPECT_OK(vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr));
EXPECT_NE(info.metadata_bytes, 0);
}
TEST(VmoTestCase, V1Info) {
zx::vmo vmo;
EXPECT_OK(zx::vmo::create(zx_system_get_page_size(), 0, &vmo));
// Check that the old info can be queried and makes sense
zx_info_vmo_v1_t v1info;
zx_info_vmo_t info;
EXPECT_OK(vmo.get_info(ZX_INFO_VMO_V1, &v1info, sizeof(v1info), nullptr, nullptr));
EXPECT_OK(vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr));
// Check a subset of the fields that we expect to be stable and non-racy between the two different
// get_info invocations.
EXPECT_EQ(v1info.koid, info.koid);
EXPECT_EQ(v1info.size_bytes, info.size_bytes);
EXPECT_EQ(v1info.parent_koid, info.parent_koid);
EXPECT_EQ(v1info.num_children, info.num_children);
EXPECT_EQ(v1info.num_mappings, info.num_mappings);
EXPECT_EQ(v1info.share_count, info.share_count);
EXPECT_EQ(v1info.flags, info.flags);
EXPECT_EQ(v1info.handle_rights, info.handle_rights);
EXPECT_EQ(v1info.cache_policy, info.cache_policy);
}
TEST(VmoTestCase, Discardable) {
// Create a discardable VMO.
zx::vmo vmo;
const size_t kSize = 3 * zx_system_get_page_size();
ASSERT_OK(zx::vmo::create(kSize, ZX_VMO_DISCARDABLE, &vmo));
// Verify that the discardable bit is set.
zx_info_vmo_t info;
EXPECT_OK(vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr));
EXPECT_NE(0, info.flags & ZX_INFO_VMO_DISCARDABLE);
// Lock the VMO.
zx_vmo_lock_state_t lock_state = {};
EXPECT_OK(vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, &lock_state, sizeof(lock_state)));
// Make sure we read zeros.
uint8_t buf[kSize];
memset(buf, 0xff, sizeof(buf));
EXPECT_OK(vmo.read(buf, 0, sizeof(buf)));
uint8_t comp[kSize];
memset(comp, 0, sizeof(comp));
EXPECT_BYTES_EQ(buf, comp, sizeof(buf));
// Write something to verify later.
memset(buf, 0xbb, sizeof(buf));
EXPECT_OK(vmo.write(buf, 0, sizeof(buf)));
// Mapping with READ | WRITE should succeed.
uintptr_t ptr;
EXPECT_OK(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo.get(), 0,
kSize, &ptr));
EXPECT_NE(0u, ptr);
// Verify the contents written last. Overwrite it via the mapped address.
EXPECT_BYTES_EQ(buf, (uint8_t *)ptr, sizeof(buf));
memset((uint8_t *)ptr, 0xcc, sizeof(buf));
// Verify contents again.
memset(comp, 0xcc, sizeof(comp));
EXPECT_OK(vmo.read(buf, 0, sizeof(buf)));
EXPECT_BYTES_EQ(buf, comp, sizeof(buf));
// Unlock and unmap.
EXPECT_OK(vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
EXPECT_OK(zx_vmar_unmap(zx_vmar_root_self(), ptr, kSize));
// Cannot create clones of any type for discardable VMOs.
zx::vmo child;
EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, vmo.create_child(ZX_VMO_CHILD_SLICE, 0, kSize, &child));
EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, vmo.create_child(ZX_VMO_CHILD_SNAPSHOT, 0, kSize, &child));
EXPECT_EQ(ZX_ERR_NOT_SUPPORTED,
vmo.create_child(ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE, 0, kSize, &child));
// Cannot create a discardable pager backed VMO.
zx::pager pager;
EXPECT_OK(zx::pager::create(0, &pager));
zx::port port;
EXPECT_OK(zx::port::create(0, &port));
zx::vmo pager_vmo;
EXPECT_EQ(ZX_ERR_INVALID_ARGS, pager.create_vmo(ZX_VMO_DISCARDABLE, port, 0, kSize, &pager_vmo));
}
TEST(VmoTestCase, LockUnlock) {
// Lock/unlock only works with discardable VMOs.
zx::vmo vmo;
const size_t kSize = 3 * zx_system_get_page_size();
ASSERT_OK(zx::vmo::create(kSize, 0, &vmo));
EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, vmo.op_range(ZX_VMO_OP_TRY_LOCK, 0, kSize, nullptr, 0));
EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, nullptr, 0));
EXPECT_EQ(ZX_ERR_NOT_SUPPORTED, vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
vmo.reset();
ASSERT_OK(zx::vmo::create(kSize, ZX_VMO_DISCARDABLE, &vmo));
EXPECT_OK(vmo.op_range(ZX_VMO_OP_TRY_LOCK, 0, kSize, nullptr, 0));
EXPECT_OK(vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
zx_vmo_lock_state_t lock_state = {};
EXPECT_OK(vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, &lock_state, sizeof(lock_state)));
EXPECT_OK(vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
// Lock/unlock requires read/write rights.
zx_info_handle_basic_t info;
size_t a1, a2;
EXPECT_OK(vmo.get_info(ZX_INFO_HANDLE_BASIC, &info, sizeof(info), &a1, &a2));
EXPECT_NE(0u, info.rights & ZX_RIGHT_READ);
EXPECT_NE(0u, info.rights & ZX_RIGHT_WRITE);
EXPECT_OK(vmo.replace(info.rights & ~ZX_RIGHT_WRITE, &vmo));
EXPECT_OK(vmo.op_range(ZX_VMO_OP_TRY_LOCK, 0, kSize, nullptr, 0));
EXPECT_OK(vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
EXPECT_OK(vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, &lock_state, sizeof(lock_state)));
EXPECT_OK(vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
EXPECT_OK(vmo.replace(info.rights & ~(ZX_RIGHT_READ | ZX_RIGHT_WRITE), &vmo));
EXPECT_EQ(ZX_ERR_ACCESS_DENIED, vmo.op_range(ZX_VMO_OP_TRY_LOCK, 0, kSize, nullptr, 0));
EXPECT_EQ(ZX_ERR_ACCESS_DENIED,
vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, &lock_state, sizeof(lock_state)));
EXPECT_EQ(ZX_ERR_ACCESS_DENIED, vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
vmo.reset();
ASSERT_OK(zx::vmo::create(kSize, ZX_VMO_DISCARDABLE, &vmo));
// Lock/unlock work only on the entire VMO.
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
vmo.op_range(ZX_VMO_OP_TRY_LOCK, 0, zx_system_get_page_size(), nullptr, 0));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, vmo.op_range(ZX_VMO_OP_LOCK, 0, zx_system_get_page_size(),
&lock_state, sizeof(lock_state)));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
vmo.op_range(ZX_VMO_OP_UNLOCK, 0, zx_system_get_page_size(), nullptr, 0));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, vmo.op_range(ZX_VMO_OP_TRY_LOCK, zx_system_get_page_size(),
kSize - zx_system_get_page_size(), nullptr, 0));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
vmo.op_range(ZX_VMO_OP_LOCK, zx_system_get_page_size(),
kSize - zx_system_get_page_size(), &lock_state, sizeof(lock_state)));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, vmo.op_range(ZX_VMO_OP_UNLOCK, zx_system_get_page_size(),
kSize - zx_system_get_page_size(), nullptr, 0));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, vmo.op_range(ZX_VMO_OP_TRY_LOCK, zx_system_get_page_size(),
zx_system_get_page_size(), nullptr, 0));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
vmo.op_range(ZX_VMO_OP_LOCK, zx_system_get_page_size(), zx_system_get_page_size(),
&lock_state, sizeof(lock_state)));
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE, vmo.op_range(ZX_VMO_OP_UNLOCK, zx_system_get_page_size(),
zx_system_get_page_size(), nullptr, 0));
// Lock requires a zx_vmo_lock_state_t arg.
EXPECT_EQ(ZX_ERR_INVALID_ARGS, vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, nullptr, 0));
EXPECT_EQ(ZX_ERR_INVALID_ARGS, vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, &lock_state, 0));
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, nullptr, sizeof(lock_state)));
uint64_t tmp;
EXPECT_EQ(ZX_ERR_INVALID_ARGS, vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, &tmp, sizeof(tmp)));
// Verify the lock state returned on a successful lock.
EXPECT_OK(vmo.op_range(ZX_VMO_OP_LOCK, 0, kSize, &lock_state, sizeof(lock_state)));
EXPECT_EQ(0u, lock_state.offset);
EXPECT_EQ(kSize, lock_state.size);
EXPECT_OK(vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
// Unlock on an unlocked VMO should fail.
EXPECT_EQ(ZX_ERR_BAD_STATE, vmo.op_range(ZX_VMO_OP_UNLOCK, 0, kSize, nullptr, 0));
}
TEST(VmoTestCase, NoWriteResizable) {
zx::vmo vmo;
ASSERT_OK(zx::vmo::create(zx_system_get_page_size(), 0, &vmo));
// Show that any way of creating a child that is no write and resizable fails.
zx::vmo child;
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
vmo.create_child(ZX_VMO_CHILD_SNAPSHOT | ZX_VMO_CHILD_NO_WRITE | ZX_VMO_CHILD_RESIZABLE,
0, zx_system_get_page_size(), &child));
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
vmo.create_child(ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE | ZX_VMO_CHILD_NO_WRITE |
ZX_VMO_CHILD_RESIZABLE,
0, zx_system_get_page_size(), &child));
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
vmo.create_child(ZX_VMO_CHILD_SLICE | ZX_VMO_CHILD_NO_WRITE | ZX_VMO_CHILD_RESIZABLE, 0,
zx_system_get_page_size(), &child));
// Prove that creating a non-resizable one works.
EXPECT_OK(vmo.create_child(ZX_VMO_CHILD_SNAPSHOT | ZX_VMO_CHILD_NO_WRITE, 0,
zx_system_get_page_size(), &child));
// Do it again with a resziable parent to show the resizability of the parent is irrelevant.
child.reset();
vmo.reset();
ASSERT_OK(zx::vmo::create(zx_system_get_page_size(), ZX_VMO_RESIZABLE, &vmo));
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
vmo.create_child(ZX_VMO_CHILD_SNAPSHOT | ZX_VMO_CHILD_NO_WRITE | ZX_VMO_CHILD_RESIZABLE,
0, zx_system_get_page_size(), &child));
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
vmo.create_child(ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE | ZX_VMO_CHILD_NO_WRITE |
ZX_VMO_CHILD_RESIZABLE,
0, zx_system_get_page_size(), &child));
EXPECT_EQ(ZX_ERR_INVALID_ARGS,
vmo.create_child(ZX_VMO_CHILD_SLICE | ZX_VMO_CHILD_NO_WRITE | ZX_VMO_CHILD_RESIZABLE, 0,
zx_system_get_page_size(), &child));
EXPECT_OK(vmo.create_child(ZX_VMO_CHILD_SNAPSHOT | ZX_VMO_CHILD_NO_WRITE, 0,
zx_system_get_page_size(), &child));
}
} // namespace