// 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 <assert.h>
#include <errno.h>
#include <lib/fzl/memory-probe.h>
#include <lib/zx/job.h>
#include <lib/zx/process.h>
#include <lib/zx/vmar.h>
#include <lib/zx/vmo.h>
#include <stdalign.h>
#include <sys/mman.h>
#include <unistd.h>
#include <zircon/process.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/exception.h>
#include <zircon/syscalls/object.h>

#include <atomic>
#include <climits>
#include <limits>
#include <thread>

#include <fbl/algorithm.h>
#include <unittest/unittest.h>

#define ROUNDUP(a, b) (((a) + ((b)-1)) & ~((b)-1))

// These tests focus on the semantics of the VMARs themselves.  For heavier
// testing of the mapping permissions, see the VMO tests.

namespace {

const char kProcessName[] = "test-proc-vmar";

const zx_vm_option_t kRwxMapPerm = ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_PERM_EXECUTE;
const zx_vm_option_t kRwxAllocPerm =
    ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_EXECUTE;

// Helper routine for other tests.  If bit i (< *page_count*) in *bitmap* is set, then
// checks that *base* + i * PAGE_SIZE is mapped.  Otherwise checks that it is not mapped.
bool check_pages_mapped(zx_handle_t process, uintptr_t base, uint64_t bitmap, size_t page_count) {
  uint8_t buf[1];
  size_t len;

  size_t i = 0;
  while (bitmap && i < page_count) {
    zx_status_t expected = (bitmap & 1) ? ZX_OK : ZX_ERR_NO_MEMORY;
    if (zx_process_read_memory(process, base + i * PAGE_SIZE, buf, 1, &len) != expected) {
      return false;
    }
    ++i;
    bitmap >>= 1;
  }
  return true;
}

bool destroy_root_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  EXPECT_EQ(zx_vmar_destroy(vmar), ZX_OK);

  zx_handle_t region;
  uintptr_t region_addr;
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, 10 * PAGE_SIZE,
                             &region, &region_addr),
            ZX_ERR_BAD_STATE);

  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

bool basic_allocate_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t region1, region2;
  uintptr_t region1_addr, region2_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t region1_size = PAGE_SIZE * 10;
  const size_t region2_size = PAGE_SIZE;

  ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, region1_size,
                             &region1, &region1_addr),
            ZX_OK);

  ASSERT_EQ(zx_vmar_allocate(region1, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, region2_size,
                             &region2, &region2_addr),
            ZX_OK);
  EXPECT_GE(region2_addr, region1_addr);
  EXPECT_LE(region2_addr + region2_size, region1_addr + region1_size);

  EXPECT_EQ(zx_handle_close(region1), ZX_OK);
  EXPECT_EQ(zx_handle_close(region2), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

bool map_in_compact_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  zx_handle_t region;
  uintptr_t region_addr, map_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t region_size = PAGE_SIZE * 10;
  const size_t map_size = PAGE_SIZE;

  ASSERT_EQ(zx_vmo_create(map_size, 0, &vmo), ZX_OK);

  ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_COMPACT, 0,
                             region_size, &region, &region_addr),
            ZX_OK);

  ASSERT_EQ(zx_vmar_map(region, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, map_size, &map_addr),
            ZX_OK);
  EXPECT_GE(map_addr, region_addr);
  EXPECT_LE(map_addr + map_size, region_addr + region_size);

  // Make a second allocation
  ASSERT_EQ(zx_vmar_map(region, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, map_size, &map_addr),
            ZX_OK);
  EXPECT_GE(map_addr, region_addr);
  EXPECT_LE(map_addr + map_size, region_addr + region_size);

  EXPECT_EQ(zx_handle_close(region), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Attempt to allocate out of the region bounds
bool allocate_oob_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t region1, region2;
  uintptr_t region1_addr, region2_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t region1_size = PAGE_SIZE * 10;

  ASSERT_EQ(
      zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
                       region1_size, &region1, &region1_addr),
      ZX_OK);

  EXPECT_EQ(zx_vmar_allocate(region1, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC,
                             region1_size, PAGE_SIZE, &region2, &region2_addr),
            ZX_ERR_INVALID_ARGS);

  EXPECT_EQ(zx_vmar_allocate(region1, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC,
                             region1_size - PAGE_SIZE, PAGE_SIZE * 2, &region2, &region2_addr),
            ZX_ERR_INVALID_ARGS);

  EXPECT_EQ(zx_handle_close(region1), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Attempt to make unsatisfiable allocations
bool allocate_unsatisfiable_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t region1, region2, region3;
  uintptr_t region1_addr, region2_addr, region3_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t region1_size = PAGE_SIZE * 10;

  ASSERT_EQ(
      zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
                       region1_size, &region1, &region1_addr),
      ZX_OK);

  // Too large to fit in the region should get ZX_ERR_INVALID_ARGS
  EXPECT_EQ(zx_vmar_allocate(region1, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0,
                             region1_size + PAGE_SIZE, &region2, &region2_addr),
            ZX_ERR_INVALID_ARGS);

  // Allocate the whole range, should work
  ASSERT_EQ(zx_vmar_allocate(region1, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, region1_size,
                             &region2, &region2_addr),
            ZX_OK);
  EXPECT_EQ(region2_addr, region1_addr);

  // Attempt to allocate a page inside of the full region
  EXPECT_EQ(zx_vmar_allocate(region1, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, PAGE_SIZE,
                             &region3, &region3_addr),
            ZX_ERR_NO_MEMORY);

  EXPECT_EQ(zx_handle_close(region2), ZX_OK);
  EXPECT_EQ(zx_handle_close(region1), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Validate that when we destroy a VMAR, all operations on it
// and its children fail.
bool destroyed_vmar_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  zx_handle_t region[3] = {};
  uintptr_t region_addr[3];
  uintptr_t map_addr[2];

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo), ZX_OK);

  ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, 10 * PAGE_SIZE,
                             &region[0], &region_addr[0]),
            ZX_OK);

  // Create a mapping in region[0], so we can try to unmap it later
  ASSERT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, PAGE_SIZE,
                        &map_addr[0]),
            ZX_OK);

  // Create a subregion in region[0], so we can try to operate on it later
  ASSERT_EQ(zx_vmar_allocate(region[0], ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, PAGE_SIZE,
                             &region[1], &region_addr[1]),
            ZX_OK);

  // Create a mapping in region[1], so we can try to unmap it later
  ASSERT_EQ(zx_vmar_map(region[1], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, PAGE_SIZE,
                        &map_addr[1]),
            ZX_OK);

  // Check that both mappings work
  {
    uint8_t buf = 5;
    size_t len;
    EXPECT_EQ(zx_process_write_memory(process, map_addr[0], &buf, 1, &len), ZX_OK);
    EXPECT_EQ(len, 1U);

    buf = 0;
    EXPECT_EQ(zx_process_read_memory(process, map_addr[1], &buf, 1, &len), ZX_OK);
    EXPECT_EQ(len, 1U);
    EXPECT_EQ(buf, 5U);
  }

  // Destroy region[0], which should also destroy region[1]
  ASSERT_EQ(zx_vmar_destroy(region[0]), ZX_OK);

  for (size_t i = 0; i < 2; ++i) {
    // Make sure the handles are still valid
    EXPECT_EQ(zx_object_get_info(region[i], ZX_INFO_HANDLE_VALID, NULL, 0u, NULL, NULL), ZX_OK);

    // Make sure we can't access the memory mappings anymore
    {
      uint8_t buf;
      size_t read;
      EXPECT_EQ(zx_process_read_memory(process, map_addr[i], &buf, 1, &read), ZX_ERR_NO_MEMORY);
    }

    // All operations on region[0] and region[1] should fail with ZX_ERR_BAD_STATE
    EXPECT_EQ(zx_vmar_destroy(region[i]), ZX_ERR_BAD_STATE);
    EXPECT_EQ(zx_vmar_allocate(region[i], ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, PAGE_SIZE,
                               &region[1], &region_addr[2]),
              ZX_ERR_BAD_STATE);
    EXPECT_EQ(zx_vmar_unmap(region[i], map_addr[i], PAGE_SIZE), ZX_ERR_BAD_STATE);
    EXPECT_EQ(zx_vmar_protect(region[i], ZX_VM_PERM_READ, map_addr[i], PAGE_SIZE),
              ZX_ERR_BAD_STATE);
    EXPECT_EQ(zx_vmar_map(region[i], ZX_VM_PERM_READ, 0, vmo, 0, PAGE_SIZE, &map_addr[i]),
              ZX_ERR_BAD_STATE);
  }

  // Make sure we can still operate on the parent of region[0]
  ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, PAGE_SIZE,
                             &region[2], &region_addr[2]),
            ZX_OK);

  for (zx_handle_t h : region) {
    EXPECT_EQ(zx_handle_close(h), ZX_OK);
  }

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Create a mapping, destroy the VMAR it is in, then attempt to create a new
// mapping over it.
bool map_over_destroyed_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo, vmo2;
  zx_handle_t region[2] = {};
  uintptr_t region_addr[2];
  uintptr_t map_addr;
  size_t len;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo), ZX_OK);
  ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo2), ZX_OK);

  ASSERT_EQ(
      zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
                       10 * PAGE_SIZE, &region[0], &region_addr[0]),
      ZX_OK);

  // Create a subregion in region[0], so we can try to operate on it later
  ASSERT_EQ(zx_vmar_allocate(region[0], ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, PAGE_SIZE,
                             &region[1], &region_addr[1]),
            ZX_OK);

  // Create a mapping in region[1], so we can try to unmap it later
  ASSERT_EQ(
      zx_vmar_map(region[1], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, PAGE_SIZE, &map_addr),
      ZX_OK);

  // Check that the mapping worked
  {
    uint8_t buf = 5;
    ASSERT_EQ(zx_vmo_write(vmo, &buf, 0, 1), ZX_OK);

    buf = 0;
    EXPECT_EQ(zx_process_read_memory(process, map_addr, &buf, 1, &len), ZX_OK);
    EXPECT_EQ(len, 1U);
    EXPECT_EQ(buf, 5U);
  }

  // Destroy region[1], which should unmap the VMO
  ASSERT_EQ(zx_vmar_destroy(region[1]), ZX_OK);

  // Make sure we can't access the memory mappings anymore
  {
    uint8_t buf;
    size_t read;
    EXPECT_EQ(zx_process_read_memory(process, map_addr, &buf, 1, &read), ZX_ERR_NO_MEMORY);
  }

  uintptr_t new_map_addr;
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        map_addr - region_addr[0], vmo2, 0, PAGE_SIZE, &new_map_addr),
            ZX_OK);
  EXPECT_EQ(new_map_addr, map_addr);

  // Make sure we can read, and we don't see the old memory mapping
  {
    uint8_t buf;
    size_t read;
    EXPECT_EQ(zx_process_read_memory(process, map_addr, &buf, 1, &read), ZX_OK);
    EXPECT_EQ(read, 1U);
    EXPECT_EQ(buf, 0U);
  }

  for (zx_handle_t h : region) {
    EXPECT_EQ(zx_handle_close(h), ZX_OK);
  }

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo2), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

struct AlignTestdata {
  zx_vm_option_t aligment;
  int zero_bits;
};

AlignTestdata align_data[]{
    {ZX_VM_ALIGN_1KB, 10},   {ZX_VM_ALIGN_2KB, 11},   {ZX_VM_ALIGN_4KB, 12},
    {ZX_VM_ALIGN_8KB, 13},   {ZX_VM_ALIGN_16KB, 14},  {ZX_VM_ALIGN_32KB, 15},
    {ZX_VM_ALIGN_64KB, 16},  {ZX_VM_ALIGN_128KB, 17}, {ZX_VM_ALIGN_256KB, 18},
    {ZX_VM_ALIGN_512KB, 19}, {ZX_VM_ALIGN_1MB, 20},   {ZX_VM_ALIGN_2MB, 21},
    {ZX_VM_ALIGN_4MB, 22},   {ZX_VM_ALIGN_8MB, 23},   {ZX_VM_ALIGN_16MB, 24},
    {ZX_VM_ALIGN_32MB, 25},  {ZX_VM_ALIGN_64MB, 26},  {ZX_VM_ALIGN_128MB, 27},
    {ZX_VM_ALIGN_256MB, 28}, {ZX_VM_ALIGN_512MB, 29}, {ZX_VM_ALIGN_1GB, 30},
    {ZX_VM_ALIGN_2GB, 31},   {ZX_VM_ALIGN_4GB, 32}};

// Create a manually aligned |vmar| to |vmar_size|, this is needed only
// needed when testing the alignment flags.
zx_status_t MakeManualAlignedVmar(size_t vmar_size, zx_handle_t* vmar) {
  zx_info_vmar_t vmar_info;
  auto status = zx_object_get_info(zx_vmar_root_self(), ZX_INFO_VMAR, &vmar_info, sizeof(vmar_info),
                                   NULL, NULL);
  if (status != ZX_OK) {
    return status;
  }

  const size_t root_vmar_end = vmar_info.base + vmar_info.len;
  size_t start = fbl::round_up(vmar_info.base, vmar_size);

  zx_vaddr_t root_addr = 0u;
  for (; start < root_vmar_end; start += vmar_size) {
    status = zx_vmar_allocate(
        zx_vmar_root_self(),
        ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC | ZX_VM_SPECIFIC,
        (start - vmar_info.base), vmar_size, vmar, &root_addr);
    if (status == ZX_OK) {
      break;
    }
  }
  return status;
}

bool alignment_vmar_map_test() {
  BEGIN_TEST;

  const size_t size = PAGE_SIZE * 2;
  const auto vmar_size = (8ull * 1024 * 1024 * 1024);

  zx_handle_t vmo;
  ASSERT_EQ(zx_vmo_create(size, 0, &vmo), ZX_OK);
  zx_handle_t vmar;
  ASSERT_EQ(MakeManualAlignedVmar(vmar_size, &vmar), ZX_OK);

  // Specific base + offset does not meet the alignment, so it fails.
  zx_vaddr_t dummy;
  EXPECT_EQ(
      zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_ALIGN_64KB | ZX_VM_SPECIFIC,
                  4096, vmo, 0, size, &dummy),
      ZX_ERR_INVALID_ARGS);

  // Specific base + offset meets alignment, it should succeed.
  EXPECT_EQ(
      zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_ALIGN_64KB | ZX_VM_SPECIFIC,
                  64 * 1024, vmo, 0, size, &dummy),
      ZX_OK);
  ASSERT_EQ(zx_vmar_unmap(vmar, dummy, 64 * 1024), ZX_OK);

  // Minimum supported alignments range is 2^10 to 2^32
  zx_vm_option_t bad_align_low = (9u << ZX_VM_ALIGN_BASE);
  zx_vm_option_t bad_align_high = (33u << ZX_VM_ALIGN_BASE);

  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | bad_align_low, 0, vmo, 0, size,
                        &dummy),
            ZX_ERR_INVALID_ARGS);

  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | bad_align_high, 0, vmo, 0, size,
                        &dummy),
            ZX_ERR_INVALID_ARGS);

  // Test all supported alignments.
  for (const auto& d : align_data) {
    zx_vaddr_t mapping_addr = 0u;
    ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | d.aligment, 0, vmo, 0, size,
                          &mapping_addr),
              ZX_OK);

    ASSERT_NE(mapping_addr, 0u);
    EXPECT_GE(__builtin_ctzll(mapping_addr), d.zero_bits);
    // touch memory and unmap.
    reinterpret_cast<uint64_t*>(mapping_addr)[1] = 0x1234321;
    ASSERT_EQ(zx_vmar_unmap(vmar, mapping_addr, size), ZX_OK);
  }

  // Alignment cannot be used with compact vmars. This is ZX-3978.
  zx_handle_t child_vmar;
  uintptr_t mapping_addr = 0u;
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_COMPACT, 0,
                             size, &child_vmar, &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_vmar_map(child_vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_ALIGN_8KB, 0, vmo, 0,
                        PAGE_SIZE, &dummy),
            ZX_ERR_INVALID_ARGS);
  ASSERT_EQ(zx_vmar_destroy(child_vmar), ZX_OK);
  ASSERT_EQ(zx_handle_close(child_vmar), ZX_OK);

  ASSERT_EQ(zx_vmar_destroy(vmar), ZX_OK);
  ASSERT_EQ(zx_handle_close(vmar), ZX_OK);
  ASSERT_EQ(zx_handle_close(vmo), ZX_OK);
  END_TEST;
}

bool alignment_vmar_allocate_test() {
  BEGIN_TEST;

  const size_t size = PAGE_SIZE * 16;
  const auto vmar_size = (8ull * 1024 * 1024 * 1024);

  zx_handle_t vmar;
  ASSERT_EQ(MakeManualAlignedVmar(vmar_size, &vmar), ZX_OK);

  // Specific base + offset does not meet the alignment, so it fails.
  zx_vaddr_t dummy_a;
  zx_handle_t dummy_h;
  EXPECT_EQ(zx_vmar_allocate(
                vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_ALIGN_64KB | ZX_VM_SPECIFIC,
                4096, size, &dummy_h, &dummy_a),
            ZX_ERR_INVALID_ARGS);

  // Specific base + offset meets alignment, it should succeed.
  EXPECT_EQ(zx_vmar_allocate(
                vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_ALIGN_64KB | ZX_VM_SPECIFIC,
                64 * 1024, size, &dummy_h, &dummy_a),
            ZX_OK);
  ASSERT_EQ(zx_vmar_destroy(dummy_h), ZX_OK);
  ASSERT_EQ(zx_handle_close(dummy_h), ZX_OK);

  // Minimum supported alignments range is 2^10 to 2^32
  const zx_vm_option_t bad_align_low = (9u << ZX_VM_ALIGN_BASE);
  const zx_vm_option_t bad_align_high = (33u << ZX_VM_ALIGN_BASE);

  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | bad_align_low, 0,
                             size, &dummy_h, &dummy_a),
            ZX_ERR_INVALID_ARGS);

  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | bad_align_high, 0,
                             size, &dummy_h, &dummy_a),
            ZX_ERR_INVALID_ARGS);

  // Test all supported alignments.
  for (const auto& d : align_data) {
    zx_handle_t child_vmar;
    uintptr_t mapping_addr = 0u;
    ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | d.aligment, 0, size,
                               &child_vmar, &mapping_addr),
              ZX_OK);

    ASSERT_NE(mapping_addr, 0u);
    EXPECT_GE(__builtin_ctzll(mapping_addr), d.zero_bits);
    ASSERT_EQ(zx_vmar_destroy(child_vmar), ZX_OK);
    ASSERT_EQ(zx_handle_close(child_vmar), ZX_OK);
  }

  // Compact aligned vmars can be allocated, but alignment can't
  // be used with compact vmars. This is ZX-3978.
  zx_handle_t child_vmar;
  uintptr_t mapping_addr = 0u;
  EXPECT_EQ(zx_vmar_allocate(
                vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_ALIGN_64KB | ZX_VM_COMPACT,
                0, size, &child_vmar, &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_vmar_allocate(child_vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_ALIGN_8KB,
                             0, PAGE_SIZE, &dummy_h, &dummy_a),
            ZX_ERR_INVALID_ARGS);
  ASSERT_EQ(zx_vmar_destroy(child_vmar), ZX_OK);
  ASSERT_EQ(zx_handle_close(child_vmar), ZX_OK);

  ASSERT_EQ(zx_vmar_destroy(vmar), ZX_OK);
  ASSERT_EQ(zx_handle_close(vmar), ZX_OK);
  END_TEST;
}

// Test to ensure we can map from a given VMO offset with MAP_RANGE enabled. This tests against
// a bug found when creating MmioBuffer with a provided VMO and an offset.
bool vmar_map_range_offset_test() {
  BEGIN_TEST;
  zx::vmar vmar;
  zx::vmo vmo;
  zx::process process;
  ASSERT_EQ(zx::process::create(*zx::job::default_job(), kProcessName, sizeof(kProcessName) - 1, 0,
                                &process, &vmar),
            ZX_OK);
  ASSERT_EQ(zx::vmo::create(PAGE_SIZE * 4, 0, &vmo), ZX_OK);
  uintptr_t mapping;
  EXPECT_EQ(vmar.map(0, vmo, 0x2000, 0x1000, ZX_VM_MAP_RANGE, &mapping), ZX_OK);
  END_TEST;
}

// Attempt overmapping with FLAG_SPECIFIC to ensure it fails
bool overmapping_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t region[3] = {};
  zx_handle_t vmar;
  zx_handle_t vmo, vmo2;
  uintptr_t region_addr[3];
  uintptr_t map_addr[2];

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo), ZX_OK);
  ASSERT_EQ(zx_vmo_create(PAGE_SIZE * 4, 0, &vmo2), ZX_OK);

  ASSERT_EQ(
      zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC, 0,
                       10 * PAGE_SIZE, &region[0], &region_addr[0]),
      ZX_OK);

  // Create a mapping, and try to map on top of it
  ASSERT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE,
                        vmo, 0, 2 * PAGE_SIZE, &map_addr[0]),
            ZX_OK);

  // Attempt a full overmapping
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        map_addr[0] - region_addr[0], vmo2, 0, 2 * PAGE_SIZE, &map_addr[1]),
            ZX_ERR_NO_MEMORY);

  // Attempt a partial overmapping
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        map_addr[0] - region_addr[0], vmo2, 0, PAGE_SIZE, &map_addr[1]),
            ZX_ERR_NO_MEMORY);

  // Attempt an overmapping that is larger than the original mapping
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        map_addr[0] - region_addr[0], vmo2, 0, 4 * PAGE_SIZE, &map_addr[1]),
            ZX_ERR_NO_MEMORY);

  // Attempt to allocate a region on top
  EXPECT_EQ(zx_vmar_allocate(region[0], ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC,
                             map_addr[0] - region_addr[0], PAGE_SIZE, &region[1], &region_addr[1]),
            ZX_ERR_NO_MEMORY);

  // Unmap the mapping
  ASSERT_EQ(zx_vmar_unmap(region[0], map_addr[0], 2 * PAGE_SIZE), ZX_OK);

  // Create a region, and try to map on top of it
  ASSERT_EQ(zx_vmar_allocate(region[0], ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC,
                             PAGE_SIZE, 2 * PAGE_SIZE, &region[1], &region_addr[1]),
            ZX_OK);

  // Attempt a full overmapping
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        region_addr[1] - region_addr[0], vmo2, 0, 2 * PAGE_SIZE, &map_addr[1]),
            ZX_ERR_NO_MEMORY);

  // Attempt a partial overmapping
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        region_addr[1] - region_addr[0], vmo2, 0, PAGE_SIZE, &map_addr[1]),
            ZX_ERR_NO_MEMORY);

  // Attempt an overmapping that is larger than the original region
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        region_addr[1] - region_addr[0], vmo2, 0, 4 * PAGE_SIZE, &map_addr[1]),
            ZX_ERR_NO_MEMORY);

  // Attempt to allocate a region on top
  EXPECT_EQ(
      zx_vmar_allocate(region[0], ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC,
                       region_addr[1] - region_addr[0], PAGE_SIZE, &region[2], &region_addr[2]),
      ZX_ERR_NO_MEMORY);

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo2), ZX_OK);
  EXPECT_EQ(zx_handle_close(region[0]), ZX_OK);
  EXPECT_EQ(zx_handle_close(region[1]), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Test passing in bad arguments
bool invalid_args_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  zx_handle_t region;
  uintptr_t region_addr, map_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);
  ASSERT_EQ(zx_vmo_create(4 * PAGE_SIZE, 0, &vmo), ZX_OK);

  // Bad handle
  EXPECT_EQ(zx_vmar_destroy(vmo), ZX_ERR_WRONG_TYPE);
  EXPECT_EQ(zx_vmar_allocate(vmo, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, 10 * PAGE_SIZE,
                             &region, &region_addr),
            ZX_ERR_WRONG_TYPE);
  EXPECT_EQ(
      zx_vmar_map(vmo, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE, &map_addr),
      ZX_ERR_WRONG_TYPE);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, process, 0, 4 * PAGE_SIZE,
                        &map_addr),
            ZX_ERR_WRONG_TYPE);
  EXPECT_EQ(zx_vmar_unmap(vmo, 0, 0), ZX_ERR_WRONG_TYPE);
  EXPECT_EQ(zx_vmar_protect(vmo, ZX_VM_PERM_READ, 0, 0), ZX_ERR_WRONG_TYPE);

  // Allocating with non-zero offset and without FLAG_SPECIFIC
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, PAGE_SIZE,
                             10 * PAGE_SIZE, &region, &region_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, PAGE_SIZE, vmo, 0, 4 * PAGE_SIZE,
                        &map_addr),
            ZX_ERR_INVALID_ARGS);

  // Allocate with ZX_VM_PERM_READ.
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_PERM_READ, PAGE_SIZE, 10 * PAGE_SIZE,
                             &region, &region_addr),
            ZX_ERR_INVALID_ARGS);

  // Using MAP_RANGE with SPECIFIC_OVERWRITE
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_SPECIFIC_OVERWRITE | ZX_VM_MAP_RANGE,
                        PAGE_SIZE, vmo, 0, 4 * PAGE_SIZE, &map_addr),
            ZX_ERR_INVALID_ARGS);

  // Bad OUT pointers
  uintptr_t* bad_addr_ptr = reinterpret_cast<uintptr_t*>(1);
  zx_handle_t* bad_handle_ptr = reinterpret_cast<zx_handle_t*>(1);
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, 10 * PAGE_SIZE,
                             &region, bad_addr_ptr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, 10 * PAGE_SIZE,
                             bad_handle_ptr, &region_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(
      zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE, bad_addr_ptr),
      ZX_ERR_INVALID_ARGS);

  // Non-page-aligned arguments
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, PAGE_SIZE - 1,
                             &region, &region_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(
      zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC,
                       PAGE_SIZE - 1, PAGE_SIZE, &region, &region_addr),
      ZX_ERR_INVALID_ARGS);
  // Try the invalid maps with and without ZX_VM_MAP_RANGE.
  for (size_t i = 0; i < 2; ++i) {
    const uint32_t map_range = i ? ZX_VM_MAP_RANGE : 0;
    // Specific, misaligned vmar offset
    EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC | map_range,
                          PAGE_SIZE - 1, vmo, 0, 4 * PAGE_SIZE, &map_addr),
              ZX_ERR_INVALID_ARGS);
    // Specific, misaligned vmo offset
    EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC | map_range,
                          PAGE_SIZE, vmo, PAGE_SIZE - 1, 3 * PAGE_SIZE, &map_addr),
              ZX_ERR_INVALID_ARGS);
    // Non-specific, misaligned vmo offset
    EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | map_range, 0, vmo,
                          PAGE_SIZE - 1, 3 * PAGE_SIZE, &map_addr),
              ZX_ERR_INVALID_ARGS);
  }
  EXPECT_EQ(
      zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE, &map_addr),
      ZX_OK);
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr + 1, PAGE_SIZE), ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, map_addr + 1, PAGE_SIZE), ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, 4 * PAGE_SIZE), ZX_OK);

  // Overflowing vmo_offset
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo,
                        UINT64_MAX + 1 - PAGE_SIZE, PAGE_SIZE, &map_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo,
                        UINT64_MAX + 1 - 2 * PAGE_SIZE, PAGE_SIZE, &map_addr),
            ZX_OK);
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, PAGE_SIZE), ZX_OK);

  // size=0
  EXPECT_EQ(
      zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, 0, &region, &region_addr),
      ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 0, &map_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(
      zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE, &map_addr),
      ZX_OK);
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, 0), ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, map_addr, 0), ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, 4 * PAGE_SIZE), ZX_OK);

  // size rounds up to 0
  constexpr size_t bad_size = std::numeric_limits<size_t>::max() - PAGE_SIZE + 2;
  static_assert(((bad_size + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)) == 0, "");
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, bad_size, &region,
                             &region_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, bad_size, &map_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_MAP_RANGE, 0, vmo, 0, bad_size, &map_addr),
            ZX_ERR_INVALID_ARGS);
  // Attempt bad protect/unmaps
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE, vmo,
                        0, 4 * PAGE_SIZE, &map_addr),
            ZX_OK);
  for (ssize_t i = -1; i < 2; ++i) {
    EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, map_addr + PAGE_SIZE * i, bad_size),
              ZX_ERR_INVALID_ARGS);
    EXPECT_EQ(zx_vmar_unmap(vmar, map_addr + PAGE_SIZE * i, bad_size), ZX_ERR_INVALID_ARGS);
  }
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, 4 * PAGE_SIZE), ZX_OK);

  // Flags with invalid bits set
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_PERM_READ | ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0,
                             4 * PAGE_SIZE, &region, &region_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | (1 << 31), 0, 4 * PAGE_SIZE, &region,
                             &region_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_CAN_MAP_EXECUTE, 0, vmo, 0,
                        4 * PAGE_SIZE, &map_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | (1 << 31), 0, vmo, 0,
                        4 * PAGE_SIZE, &map_addr),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(
      zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE, &map_addr),
      ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ | ZX_VM_CAN_MAP_WRITE, map_addr, 4 * PAGE_SIZE),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ | (1 << 31), map_addr, 4 * PAGE_SIZE),
            ZX_ERR_INVALID_ARGS);
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, 4 * PAGE_SIZE), ZX_OK);

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Test passing in unaligned lens to unmap/protect
bool unaligned_len_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  uintptr_t map_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);
  ASSERT_EQ(zx_vmo_create(4 * PAGE_SIZE, 0, &vmo), ZX_OK);

  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ, 0, vmo, 0, 4 * PAGE_SIZE, &map_addr), ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, map_addr, 4 * PAGE_SIZE - 1),
            ZX_OK);
  EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, 4 * PAGE_SIZE - 1), ZX_OK);

  // Make sure we can't access the last page of the memory mappings anymore
  {
    uint8_t buf;
    size_t read;
    EXPECT_EQ(zx_process_read_memory(process, map_addr + 3 * PAGE_SIZE, &buf, 1, &read),
              ZX_ERR_NO_MEMORY);
  }

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Test passing in unaligned lens to map
bool unaligned_len_map_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  uintptr_t map_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);
  ASSERT_EQ(zx_vmo_create(4 * PAGE_SIZE, 0, &vmo), ZX_OK);

  for (size_t i = 0; i < 2; ++i) {
    const uint32_t map_range = i ? ZX_VM_MAP_RANGE : 0;
    ASSERT_EQ(
        zx_vmar_map(vmar, ZX_VM_PERM_READ | map_range, 0, vmo, 0, 4 * PAGE_SIZE - 1, &map_addr),
        ZX_OK);

    // Make sure we can access the last page of the memory mapping
    {
      uint8_t buf;
      size_t read;
      EXPECT_EQ(zx_process_read_memory(process, map_addr + 3 * PAGE_SIZE, &buf, 1, &read), ZX_OK);
    }

    EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, 4 * PAGE_SIZE - 1), ZX_OK);
    // Make sure we can't access the last page of the memory mappings anymore
    {
      uint8_t buf;
      size_t read;
      EXPECT_EQ(zx_process_read_memory(process, map_addr + 3 * PAGE_SIZE, &buf, 1, &read),
                ZX_ERR_NO_MEMORY);
    }
  }

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Validate that dropping vmar handle rights affects mapping privileges
bool rights_drop_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  zx_handle_t region;
  uintptr_t map_addr;
  uintptr_t region_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);
  ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo), ZX_OK);
  ASSERT_EQ(zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo), ZX_OK);

  const uint32_t test_rights[][3] = {
      {ZX_RIGHT_READ, ZX_VM_PERM_READ},
      {ZX_RIGHT_READ | ZX_RIGHT_WRITE, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE},
      {ZX_RIGHT_READ | ZX_RIGHT_EXECUTE, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE},
  };
  for (size_t i = 0; i < fbl::count_of(test_rights); ++i) {
    uint32_t right = test_rights[i][0];
    uint32_t perm = test_rights[i][1];

    zx_handle_t new_h;
    ASSERT_EQ(zx_handle_duplicate(vmar, right, &new_h), ZX_OK);

    // Try to create a mapping with permissions we don't have
    EXPECT_EQ(zx_vmar_map(new_h, kRwxMapPerm, 0, vmo, 0, PAGE_SIZE, &map_addr),
              ZX_ERR_ACCESS_DENIED);

    // Try to create a mapping with permissions we do have
    ASSERT_EQ(zx_vmar_map(new_h, perm, 0, vmo, 0, PAGE_SIZE, &map_addr), ZX_OK);

    // Attempt to use protect to increase privileges
    EXPECT_EQ(zx_vmar_protect(new_h, kRwxMapPerm, map_addr, PAGE_SIZE), ZX_ERR_ACCESS_DENIED);

    EXPECT_EQ(zx_vmar_unmap(new_h, map_addr, PAGE_SIZE), ZX_OK);

    // Attempt to create a region that can map write (this would allow us to
    // then make writeable mappings inside of it).
    EXPECT_EQ(zx_vmar_allocate(new_h, kRwxAllocPerm, 0, 10 * PAGE_SIZE, &region, &region_addr),
              ZX_ERR_ACCESS_DENIED);

    EXPECT_EQ(zx_handle_close(new_h), ZX_OK);
  }

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Validate that protect can't be used to escalate mapping privileges beyond
// the VMAR handle's and the original VMO handle's
bool protect_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  uintptr_t map_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);
  ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo), ZX_OK);
  ASSERT_EQ(zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo), ZX_OK);

  const uint32_t test_rights[][3] = {
      {ZX_RIGHT_READ, ZX_VM_PERM_READ},
      {ZX_RIGHT_READ | ZX_RIGHT_WRITE, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE},
      {ZX_RIGHT_READ | ZX_RIGHT_EXECUTE, ZX_VM_PERM_READ | ZX_VM_PERM_EXECUTE},
  };
  for (size_t i = 0; i < fbl::count_of(test_rights); ++i) {
    uint32_t right = test_rights[i][0];
    zx_vm_option_t perm = test_rights[i][1];

    zx_handle_t new_h;
    ASSERT_EQ(zx_handle_duplicate(vmo, right | ZX_RIGHT_MAP, &new_h), ZX_OK);

    // Try to create a mapping with permissions we don't have
    EXPECT_EQ(zx_vmar_map(vmar, kRwxMapPerm, 0, new_h, 0, PAGE_SIZE, &map_addr),
              ZX_ERR_ACCESS_DENIED);

    // Try to create a mapping with permissions we do have
    ASSERT_EQ(zx_vmar_map(vmar, perm, 0, new_h, 0, PAGE_SIZE, &map_addr), ZX_OK);

    // Attempt to use protect to increase privileges to a level allowed by
    // the VMAR but not by the VMO handle
    EXPECT_EQ(zx_vmar_protect(vmar, kRwxMapPerm, map_addr, PAGE_SIZE), ZX_ERR_ACCESS_DENIED);

    EXPECT_EQ(zx_handle_close(new_h), ZX_OK);

    // Try again now that we closed the VMO handle
    EXPECT_EQ(zx_vmar_protect(vmar, kRwxMapPerm, map_addr, PAGE_SIZE), ZX_ERR_ACCESS_DENIED);

    EXPECT_EQ(zx_vmar_unmap(vmar, map_addr, PAGE_SIZE), ZX_OK);
  }

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Validate that a region can't be created with higher RWX privileges than its
// parent.
bool nested_region_perms_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  zx_handle_t region[2] = {};
  uintptr_t region_addr[2];
  uintptr_t map_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo), ZX_OK);
  ASSERT_EQ(zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &vmo), ZX_OK);

  // List of pairs of alloc/map perms to try to exclude
  const zx_vm_option_t test_perm[][2] = {
      {ZX_VM_CAN_MAP_READ, ZX_VM_PERM_READ},
      {ZX_VM_CAN_MAP_WRITE, ZX_VM_PERM_WRITE},
      {ZX_VM_CAN_MAP_EXECUTE, ZX_VM_PERM_EXECUTE},
  };

  for (size_t i = 0; i < fbl::count_of(test_perm); ++i) {
    const zx_vm_option_t excluded_alloc_perm = test_perm[i][0];
    const zx_vm_option_t excluded_map_perm = test_perm[i][1];

    ASSERT_EQ(zx_vmar_allocate(vmar, kRwxAllocPerm ^ excluded_alloc_perm, 0, 10 * PAGE_SIZE,
                               &region[0], &region_addr[0]),
              ZX_OK);

    // Should fail since region[0] does not have the right perms
    EXPECT_EQ(zx_vmar_allocate(region[0], kRwxAllocPerm, 0, PAGE_SIZE, &region[1], &region_addr[1]),
              ZX_ERR_ACCESS_DENIED);

    // Try to create a mapping in region[0] with the dropped rights
    EXPECT_EQ(zx_vmar_map(region[0], kRwxMapPerm, 0, vmo, 0, PAGE_SIZE, &map_addr),
              ZX_ERR_ACCESS_DENIED);

    // Successfully create a mapping in region[0] (skip if we excluded READ,
    // since all mappings must be readable on most CPUs)
    if (excluded_map_perm != ZX_VM_PERM_READ) {
      EXPECT_EQ(
          zx_vmar_map(region[0], kRwxMapPerm ^ excluded_map_perm, 0, vmo, 0, PAGE_SIZE, &map_addr),
          ZX_OK);
      EXPECT_EQ(zx_vmar_unmap(region[0], map_addr, PAGE_SIZE), ZX_OK);
    }

    // Successfully create a subregion in region[0]
    EXPECT_EQ(zx_vmar_allocate(region[0], kRwxAllocPerm ^ excluded_alloc_perm, 0, PAGE_SIZE,
                               &region[1], &region_addr[1]),
              ZX_OK);
    EXPECT_EQ(zx_vmar_destroy(region[1]), ZX_OK);
    EXPECT_EQ(zx_handle_close(region[1]), ZX_OK);

    EXPECT_EQ(zx_vmar_destroy(region[0]), ZX_OK);
    EXPECT_EQ(zx_handle_close(region[0]), ZX_OK);
  }

  // Make sure we can't use SPECIFIC in a region without CAN_MAP_SPECIFIC
  ASSERT_EQ(zx_vmar_allocate(vmar, kRwxAllocPerm, 0, 10 * PAGE_SIZE, &region[0], &region_addr[0]),
            ZX_OK);
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_SPECIFIC | ZX_VM_PERM_READ, PAGE_SIZE, vmo, 0, PAGE_SIZE,
                        &map_addr),
            ZX_ERR_ACCESS_DENIED);
  EXPECT_EQ(zx_vmar_map(region[0], ZX_VM_SPECIFIC_OVERWRITE | ZX_VM_PERM_READ, PAGE_SIZE, vmo, 0,
                        PAGE_SIZE, &map_addr),
            ZX_ERR_ACCESS_DENIED);
  EXPECT_EQ(zx_vmar_destroy(region[0]), ZX_OK);
  EXPECT_EQ(zx_handle_close(region[0]), ZX_OK);

  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

bool object_info_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t region;
  uintptr_t region_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t region_size = PAGE_SIZE * 10;

  ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE, 0, region_size,
                             &region, &region_addr),
            ZX_OK);

  zx_info_vmar_t info;
  ASSERT_EQ(zx_object_get_info(region, ZX_INFO_VMAR, &info, sizeof(info), NULL, NULL), ZX_OK);
  EXPECT_EQ(info.base, region_addr);
  EXPECT_EQ(info.len, region_size);

  EXPECT_EQ(zx_handle_close(region), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Verify that we can split a single mapping with an unmap call
bool unmap_split_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  uintptr_t mapping_addr[3];

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  ASSERT_EQ(zx_vmo_create(4 * PAGE_SIZE, 0, &vmo), ZX_OK);

  // Set up mappings to test on
  for (uintptr_t& addr : mapping_addr) {
    EXPECT_EQ(
        zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE, &addr),
        ZX_OK);
  }

  // Unmap from the left
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 2 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1100, 4));
  // Unmap the rest
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0] + 2 * PAGE_SIZE, 2 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000, 4));

  // Unmap from the right
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[1] + 2 * PAGE_SIZE, 2 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[1], 0b0011, 4));
  // Unmap the rest
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[1], 2 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[1], 0b0000, 4));

  // Unmap from the center
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[2] + PAGE_SIZE, 2 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[2], 0b1001, 4));
  // Unmap the rest
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[2], PAGE_SIZE), ZX_OK);
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[2] + 3 * PAGE_SIZE, PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[2], 0b0000, 4));

  zx_info_vmar_t info;
  ASSERT_EQ(zx_object_get_info(vmar, ZX_INFO_VMAR, &info, sizeof(info), NULL, NULL), ZX_OK);

  // Make sure we can map over these again
  for (uintptr_t addr : mapping_addr) {
    const size_t offset = addr - info.base;
    EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, offset, vmo, 0,
                          4 * PAGE_SIZE, &addr),
              ZX_OK);
    EXPECT_TRUE(check_pages_mapped(process, addr, 0b1111, 4));
    EXPECT_EQ(zx_vmar_unmap(vmar, addr, 4 * PAGE_SIZE), ZX_OK);
  }

  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Verify that we can unmap multiple ranges simultaneously
bool unmap_multiple_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  zx_handle_t subregion;
  uintptr_t mapping_addr[3];
  uintptr_t subregion_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t mapping_size = 4 * PAGE_SIZE;
  ASSERT_EQ(zx_vmo_create(mapping_size, 0, &vmo), ZX_OK);

  // Create two mappings
  for (size_t i = 0; i < 2; ++i) {
    ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                          i * mapping_size, vmo, 0, mapping_size, &mapping_addr[i]),
              ZX_OK);
  }
  EXPECT_EQ(mapping_addr[0] + mapping_size, mapping_addr[1]);
  // Unmap from the right of the first and the left of the second
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0] + 2 * PAGE_SIZE, 3 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1110'0011, 8), "");
  // Unmap the rest
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 2 * PAGE_SIZE), ZX_OK, "");
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[1] + 1 * PAGE_SIZE, 3 * PAGE_SIZE), ZX_OK, "");
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000, 8));

  // Create two mappings with a gap, and verify we can unmap them
  for (size_t i = 0; i < 2; ++i) {
    ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                          2 * i * mapping_size, vmo, 0, mapping_size, &mapping_addr[i]),
              ZX_OK);
  }
  EXPECT_EQ(mapping_addr[0] + 2 * mapping_size, mapping_addr[1]);
  // Unmap all of the left one and some of the right one
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 2 * mapping_size + PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1110'0000'0000, 12));
  // Unmap the rest
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[1] + 1 * PAGE_SIZE, 3 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));

  // Create two mappings with a subregion between, should be able to unmap
  // them (and destroy the subregion in the process).
  for (size_t i = 0; i < 2; ++i) {
    ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                          2 * i * mapping_size, vmo, 0, mapping_size, &mapping_addr[i]),
              ZX_OK);
  }
  ASSERT_EQ(
      zx_vmar_allocate(
          vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC | ZX_VM_SPECIFIC,
          mapping_size, mapping_size, &subregion, &subregion_addr),
      ZX_OK);
  ASSERT_EQ(zx_vmar_map(subregion, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        PAGE_SIZE, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(mapping_addr[0] + 2 * mapping_size, mapping_addr[1]);
  EXPECT_EQ(mapping_addr[0] + mapping_size, mapping_addr[2]);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1111'0001'1111, 12));
  // Unmap all of the left one and some of the right one
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 2 * mapping_size + PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1110'0000'0000, 12));
  // Try to map in the subregion again, should fail due to being destroyed
  ASSERT_EQ(zx_vmar_map(subregion, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE,
                        vmo, 0, PAGE_SIZE, &mapping_addr[2]),
            ZX_ERR_BAD_STATE);
  // Unmap the rest
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[1] + 1 * PAGE_SIZE, 3 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));
  EXPECT_EQ(zx_handle_close(subregion), ZX_OK);

  // Create two mappings with a subregion after.  Partial unmap of the
  // subregion should fail, full unmap should succeed.
  for (size_t i = 0; i < 2; ++i) {
    ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                          i * mapping_size, vmo, 0, mapping_size, &mapping_addr[i]),
              ZX_OK);
  }
  ASSERT_EQ(
      zx_vmar_allocate(
          vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC | ZX_VM_SPECIFIC,
          2 * mapping_size, mapping_size, &subregion, &subregion_addr),
      ZX_OK);
  ASSERT_EQ(zx_vmar_map(subregion, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        PAGE_SIZE, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(mapping_addr[0] + mapping_size, mapping_addr[1]);
  EXPECT_EQ(mapping_addr[0] + 2 * mapping_size, mapping_addr[2]);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0001'1111'1111, 12));
  // Unmap some of the left one through to all but the last page of the subregion
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0] + PAGE_SIZE, 3 * mapping_size - 2 * PAGE_SIZE),
            ZX_ERR_INVALID_ARGS);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0001'1111'1111, 12));
  // Try again, but unmapping all of the subregion
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0] + PAGE_SIZE, 3 * mapping_size - PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0001, 12));
  // Try to map in the subregion again, should fail due to being destroyed
  ASSERT_EQ(zx_vmar_map(subregion, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE,
                        vmo, 0, PAGE_SIZE, &mapping_addr[2]),
            ZX_ERR_BAD_STATE);
  // Unmap the rest
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));
  EXPECT_EQ(zx_handle_close(subregion), ZX_OK);

  // Create two mappings with a subregion before.  Partial unmap of the
  // subregion should fail, full unmap should succeed.
  for (size_t i = 0; i < 2; ++i) {
    ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                          (i + 1) * mapping_size, vmo, 0, mapping_size, &mapping_addr[i]),
              ZX_OK);
  }
  ASSERT_EQ(
      zx_vmar_allocate(
          vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_CAN_MAP_SPECIFIC | ZX_VM_SPECIFIC,
          0, mapping_size, &subregion, &subregion_addr),
      ZX_OK);
  ASSERT_EQ(zx_vmar_map(subregion, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                        mapping_size - PAGE_SIZE, vmo, 0, PAGE_SIZE, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(subregion_addr + mapping_size, mapping_addr[0]);
  EXPECT_EQ(subregion_addr + 2 * mapping_size, mapping_addr[1]);
  EXPECT_TRUE(check_pages_mapped(process, subregion_addr, 0b1111'1111'1000, 12));
  // Try to unmap everything except the first page of the subregion
  EXPECT_EQ(zx_vmar_unmap(vmar, subregion_addr + PAGE_SIZE, 3 * mapping_size - PAGE_SIZE),
            ZX_ERR_INVALID_ARGS);
  EXPECT_TRUE(check_pages_mapped(process, subregion_addr, 0b1111'1111'1000, 12));
  // Try again, but unmapping all of the subregion
  EXPECT_EQ(zx_vmar_unmap(vmar, subregion_addr, 3 * mapping_size), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, subregion_addr, 0b0000'0000'0000, 12));
  // Try to map in the subregion again, should fail due to being destroyed
  ASSERT_EQ(zx_vmar_map(subregion, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE,
                        vmo, 0, PAGE_SIZE, &mapping_addr[2]),
            ZX_ERR_BAD_STATE);
  EXPECT_EQ(zx_handle_close(subregion), ZX_OK);

  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Verify that we can unmap multiple ranges simultaneously
bool unmap_base_not_mapped_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  uintptr_t mapping_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t mapping_size = 4 * PAGE_SIZE;
  ASSERT_EQ(zx_vmo_create(mapping_size, 0, &vmo), ZX_OK);

  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE, vmo,
                        0, mapping_size, &mapping_addr),
            ZX_OK);
  ASSERT_EQ(zx_vmar_unmap(vmar, mapping_addr - PAGE_SIZE, mapping_size + PAGE_SIZE), ZX_OK);

  // Try again, but this time with a mapping below where base is
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        mapping_size, &mapping_addr),
            ZX_OK);
  for (size_t gap = PAGE_SIZE; gap < 3 * PAGE_SIZE; gap += PAGE_SIZE) {
    ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC,
                          mapping_size + gap, vmo, 0, mapping_size, &mapping_addr),
              ZX_OK);
    ASSERT_EQ(zx_vmar_unmap(vmar, mapping_addr - PAGE_SIZE, mapping_size + PAGE_SIZE), ZX_OK);
  }

  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Verify that we can overwrite subranges and multiple ranges simultaneously
bool map_specific_overwrite_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo, vmo2;
  zx_handle_t subregion;
  uintptr_t mapping_addr[2];
  uintptr_t subregion_addr;
  uint8_t buf[1];
  size_t len;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  const size_t mapping_size = 4 * PAGE_SIZE;
  ASSERT_EQ(zx_vmo_create(mapping_size * 2, 0, &vmo), ZX_OK);
  ASSERT_EQ(zx_vmo_create(mapping_size * 2, 0, &vmo2), ZX_OK);

  // Tag each page of the VMOs so we can identify which mappings are from
  // which.
  for (size_t i = 0; i < mapping_size / PAGE_SIZE; ++i) {
    buf[0] = 1;
    ASSERT_EQ(zx_vmo_write(vmo, buf, i * PAGE_SIZE, 1), ZX_OK);
    buf[0] = 2;
    ASSERT_EQ(zx_vmo_write(vmo2, buf, i * PAGE_SIZE, 1), ZX_OK);
  }

  // Create a single mapping and overwrite it
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE, vmo,
                        0, mapping_size, &mapping_addr[0]),
            ZX_OK);
  // Try over mapping with SPECIFIC but not SPECIFIC_OVERWRITE
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, PAGE_SIZE, vmo2,
                        0, mapping_size, &mapping_addr[1]),
            ZX_ERR_NO_MEMORY);
  // Try again with SPECIFIC_OVERWRITE
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC_OVERWRITE,
                        PAGE_SIZE, vmo2, 0, mapping_size, &mapping_addr[1]),
            ZX_OK);
  EXPECT_EQ(mapping_addr[0], mapping_addr[1]);
  for (size_t i = 0; i < mapping_size / PAGE_SIZE; ++i) {
    EXPECT_EQ(zx_process_read_memory(process, mapping_addr[0] + i * PAGE_SIZE, buf, 1, &len),
              ZX_OK);
    EXPECT_EQ(buf[0], 2u);
  }

  // Overmap the middle of it
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC_OVERWRITE,
                        2 * PAGE_SIZE, vmo, 0, 2 * PAGE_SIZE, &mapping_addr[0]),
            ZX_OK);
  EXPECT_EQ(mapping_addr[0], mapping_addr[1] + PAGE_SIZE);
  for (size_t i = 0; i < mapping_size / PAGE_SIZE; ++i) {
    EXPECT_EQ(zx_process_read_memory(process, mapping_addr[1] + i * PAGE_SIZE, buf, 1, &len),
              ZX_OK);
    EXPECT_EQ(buf[0], (i == 0 || i == 3) ? 2u : 1u);
  }

  // Create an adjacent sub-region, try to overmap it
  ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC,
                             PAGE_SIZE + mapping_size, mapping_size, &subregion, &subregion_addr),
            ZX_OK);
  EXPECT_EQ(subregion_addr, mapping_addr[1] + mapping_size);
  EXPECT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC_OVERWRITE,
                        PAGE_SIZE, vmo2, 0, 2 * mapping_size, &mapping_addr[0]),
            ZX_ERR_INVALID_ARGS);
  // Tear it all down
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[1], 2 * mapping_size), ZX_OK);

  EXPECT_EQ(zx_handle_close(subregion), ZX_OK);

  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo2), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Verify that we can split a single mapping with a protect call
bool protect_split_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo;
  uintptr_t mapping_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);

  ASSERT_EQ(zx_vmo_create(4 * PAGE_SIZE, 0, &vmo), ZX_OK);

  // Protect from the left
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE,
                        &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, mapping_addr, 2 * PAGE_SIZE), ZX_OK);
  // TODO(teisenbe): Test to validate perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr, 0b1111, 4));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr, 4 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr, 0b0000, 4));

  // Protect from the right
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE,
                        &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, mapping_addr + 2 * PAGE_SIZE, 2 * PAGE_SIZE),
            ZX_OK);
  // TODO(teisenbe): Test to validate perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr, 0b1111, 4));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr, 4 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr, 0b0000, 4));

  // Protect from the center
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, 4 * PAGE_SIZE,
                        &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, mapping_addr + PAGE_SIZE, 2 * PAGE_SIZE), ZX_OK);
  // TODO(teisenbe): Test to validate perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr, 0b1111, 4));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr, 4 * PAGE_SIZE), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr, 0b0000, 4));

  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Validate that protect can be used across multiple mappings.  Make sure intersecting a subregion
// or gap fails
bool protect_multiple_test() {
  BEGIN_TEST;

  zx_handle_t process;
  zx_handle_t vmar;
  zx_handle_t vmo, vmo2;
  zx_handle_t subregion;
  uintptr_t mapping_addr[3];
  uintptr_t subregion_addr;

  ASSERT_EQ(zx_process_create(zx_job_default(), kProcessName, sizeof(kProcessName) - 1, 0, &process,
                              &vmar),
            ZX_OK);
  const size_t mapping_size = 4 * PAGE_SIZE;
  ASSERT_EQ(zx_vmo_create(mapping_size, 0, &vmo), ZX_OK);
  ASSERT_EQ(zx_handle_duplicate(vmo, ZX_RIGHT_MAP | ZX_RIGHT_READ, &vmo2), ZX_OK);

  // Protect from the right on the first mapping, all of the second mapping,
  // and from the left on the third mapping.
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        mapping_size, &mapping_addr[0]),
            ZX_OK);
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, mapping_size,
                        vmo, 0, mapping_size, &mapping_addr[1]),
            ZX_OK);
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 2 * mapping_size,
                        vmo, 0, mapping_size, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, mapping_addr[0] + PAGE_SIZE,
                            3 * mapping_size - 2 * PAGE_SIZE),
            ZX_OK);
  // TODO(teisenbe): Test to validate perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1111'1111'1111, 12));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 3 * mapping_size), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));

  // Same thing, but map middle region with a VMO without the WRITE right
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        mapping_size, &mapping_addr[0]),
            ZX_OK);
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_SPECIFIC, mapping_size, vmo2, 0, mapping_size,
                        &mapping_addr[1]),
            ZX_OK);
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 2 * mapping_size,
                        vmo, 0, mapping_size, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, mapping_addr[0] + PAGE_SIZE,
                            3 * mapping_size - 2 * PAGE_SIZE),
            ZX_ERR_ACCESS_DENIED);
  // TODO(teisenbe): Test to validate no perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1111'1111'1111, 12));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 3 * mapping_size), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));

  // Try to protect across a gap
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        mapping_size, &mapping_addr[0]),
            ZX_OK);
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 2 * mapping_size,
                        vmo, 0, mapping_size, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, mapping_addr[0] + PAGE_SIZE,
                            3 * mapping_size - 2 * PAGE_SIZE),
            ZX_ERR_NOT_FOUND);
  // TODO(teisenbe): Test to validate no perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1111'0000'1111, 12));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 3 * mapping_size), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));

  // Try to protect across an empty subregion
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        mapping_size, &mapping_addr[0]),
            ZX_OK);
  ASSERT_EQ(zx_vmar_allocate(vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC,
                             mapping_size, mapping_size, &subregion, &subregion_addr),
            ZX_OK);
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 2 * mapping_size,
                        vmo, 0, mapping_size, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, mapping_addr[0] + PAGE_SIZE,
                            3 * mapping_size - 2 * PAGE_SIZE),
            ZX_ERR_INVALID_ARGS);
  // TODO(teisenbe): Test to validate no perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1111'0000'1111, 12));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 3 * mapping_size), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));
  EXPECT_EQ(zx_handle_close(subregion), ZX_OK);

  // Try to protect across a subregion filled with mappings
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        mapping_size, &mapping_addr[0]),
            ZX_OK);
  ASSERT_EQ(
      zx_vmar_allocate(
          vmar, ZX_VM_CAN_MAP_READ | ZX_VM_CAN_MAP_WRITE | ZX_VM_SPECIFIC | ZX_VM_CAN_MAP_SPECIFIC,
          mapping_size, mapping_size, &subregion, &subregion_addr),
      ZX_OK);
  ASSERT_EQ(zx_vmar_map(subregion, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 0, vmo, 0,
                        mapping_size, &mapping_addr[1]),
            ZX_OK);
  ASSERT_EQ(zx_vmar_map(vmar, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_SPECIFIC, 2 * mapping_size,
                        vmo, 0, mapping_size, &mapping_addr[2]),
            ZX_OK);
  EXPECT_EQ(zx_vmar_protect(vmar, ZX_VM_PERM_READ, mapping_addr[0] + PAGE_SIZE,
                            3 * mapping_size - 2 * PAGE_SIZE),
            ZX_ERR_INVALID_ARGS);
  // TODO(teisenbe): Test to validate no perms changed, need to export more debug
  // info
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b1111'1111'1111, 12));
  EXPECT_EQ(zx_vmar_unmap(vmar, mapping_addr[0], 3 * mapping_size), ZX_OK);
  EXPECT_TRUE(check_pages_mapped(process, mapping_addr[0], 0b0000'0000'0000, 12));
  EXPECT_EQ(zx_handle_close(subregion), ZX_OK);

  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo2), ZX_OK);
  EXPECT_EQ(zx_handle_close(vmar), ZX_OK);
  EXPECT_EQ(zx_handle_close(process), ZX_OK);

  END_TEST;
}

// Verify that we can change protections on a demand paged mapping successfully.
bool protect_over_demand_paged_test() {
  BEGIN_TEST;

  zx_handle_t vmo;
  const size_t size = 100 * PAGE_SIZE;
  ASSERT_EQ(zx_vmo_create(size, 0, &vmo), ZX_OK);

  // TODO(teisenbe): Move this into a separate process; currently we don't
  // have an easy way to run a small test routine in another process.
  uintptr_t mapping_addr;
  ASSERT_EQ(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size,
                        &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);

  std::atomic_uint8_t* target = reinterpret_cast<std::atomic_uint8_t*>(mapping_addr);
  target[0].store(5);
  target[size / 2].store(6);
  target[size - 1].store(7);

  ASSERT_EQ(zx_vmar_protect(zx_vmar_root_self(), ZX_VM_PERM_READ, mapping_addr, size), ZX_OK);

  // Attempt to write to the mapping again
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr)),
               "mapping should no longer be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size / 4)),
               "mapping should no longer be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size / 2)),
               "mapping should no longer be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size - 1)),
               "mapping should no longer be writeable");

  EXPECT_EQ(zx_vmar_unmap(zx_vmar_root_self(), mapping_addr, size), ZX_OK);

  END_TEST;
}

// Verify that we can change protections on unmapped pages successfully.
bool protect_large_uncommitted_test() {
  BEGIN_TEST;

  zx_handle_t vmo;
  // Create a 1GB VMO
  const size_t size = 1ull << 30;
  ASSERT_EQ(zx_vmo_create(size, 0, &vmo), ZX_OK);

  // TODO(teisenbe): Move this into a separate process; currently we don't
  // have an easy way to run a small test routine in another process.
  uintptr_t mapping_addr;
  ASSERT_EQ(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size,
                        &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);

  // Make sure some pages exist
  std::atomic_uint8_t* target = reinterpret_cast<std::atomic_uint8_t*>(mapping_addr);
  target[0].store(5);
  target[size / 2].store(6);
  target[size - 1].store(7);

  // Ensure we're misaligned relative to a larger paging structure level.
  // TODO(teisenbe): Would be nice for this to be more arch aware.
  const uintptr_t base = ROUNDUP(mapping_addr, 512 * PAGE_SIZE) + PAGE_SIZE;
  const size_t protect_size = mapping_addr + size - base;
  ASSERT_EQ(zx_vmar_protect(zx_vmar_root_self(), ZX_VM_PERM_READ, base, protect_size), ZX_OK);

  // Attempt to write to the mapping again
  EXPECT_TRUE(probe_for_write(reinterpret_cast<void*>(mapping_addr)),
              "mapping should still be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size / 4)),
               "mapping should no longer be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size / 2)),
               "mapping should no longer be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size - 1)),
               "mapping should no longer be writeable");

  EXPECT_EQ(zx_vmar_unmap(zx_vmar_root_self(), mapping_addr, size), ZX_OK);

  END_TEST;
}

// Attempt to unmap a large mostly uncommitted VMO
bool unmap_large_uncommitted_test() {
  BEGIN_TEST;

  zx_handle_t vmo;
  // Create a 1GB VMO
  const size_t size = 1ull << 30;
  ASSERT_EQ(zx_vmo_create(size, 0, &vmo), ZX_OK);

  // TODO(teisenbe): Move this into a separate process; currently we don't
  // have an easy way to run a small test routine in another process.
  uintptr_t mapping_addr;
  ASSERT_EQ(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size,
                        &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);

  // Make sure some pages exist
  std::atomic_uint8_t* target = reinterpret_cast<std::atomic_uint8_t*>(mapping_addr);
  target[0].store(5);
  target[size / 2].store(6);
  target[size - 1].store(7);

  // Ensure we're misaligned relative to a larger paging structure level.
  // TODO(teisenbe): Would be nice for this to be more arch aware.
  const uintptr_t base = ROUNDUP(mapping_addr, 512 * PAGE_SIZE) + PAGE_SIZE;
  const size_t unmap_size = mapping_addr + size - base;
  ASSERT_EQ(zx_vmar_unmap(zx_vmar_root_self(), base, unmap_size), ZX_OK);

  // Attempt to write to the mapping again
  EXPECT_TRUE(probe_for_write(reinterpret_cast<void*>(mapping_addr)),
              "mapping should still be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size / 4)),
               "mapping should no longer be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size / 2)),
               "mapping should no longer be writeable");
  EXPECT_FALSE(probe_for_write(reinterpret_cast<void*>(mapping_addr + size - 1)),
               "mapping should no longer be writeable");

  EXPECT_EQ(zx_vmar_unmap(zx_vmar_root_self(), mapping_addr, size), ZX_OK);

  END_TEST;
}

bool partial_unmap_and_read() {
  BEGIN_TEST;

  // Map a two-page VMO.
  zx_handle_t vmo;
  ASSERT_EQ(zx_vmo_create(PAGE_SIZE * 2, 0, &vmo), ZX_OK);
  uintptr_t mapping_addr;
  ASSERT_EQ(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0,
                        PAGE_SIZE * 2, &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);

  char* ptr = (char*)mapping_addr;
  memset(ptr, 0, PAGE_SIZE * 2);

  // Unmap the second page.
  zx_vmar_unmap(zx_vmar_root_self(), mapping_addr + PAGE_SIZE, PAGE_SIZE);

  char buffer[PAGE_SIZE * 2];
  size_t actual_read;

  // First page succeeds.
  EXPECT_EQ(
      zx_process_read_memory(zx_process_self(), mapping_addr, buffer, PAGE_SIZE, &actual_read),
      ZX_OK);
  EXPECT_EQ(actual_read, PAGE_SIZE);

  // Second page fails.
  EXPECT_EQ(zx_process_read_memory(zx_process_self(), mapping_addr + PAGE_SIZE, buffer, PAGE_SIZE,
                                   &actual_read),
            ZX_ERR_NO_MEMORY);

  // Reading the whole region succeeds, but only reads the first page.
  EXPECT_EQ(
      zx_process_read_memory(zx_process_self(), mapping_addr, buffer, PAGE_SIZE * 2, &actual_read),
      ZX_OK);
  EXPECT_EQ(actual_read, PAGE_SIZE);

  // Read at the boundary straddling the pages.
  EXPECT_EQ(zx_process_read_memory(zx_process_self(), mapping_addr + PAGE_SIZE - 1, buffer, 2,
                                   &actual_read),
            ZX_OK);
  EXPECT_EQ(actual_read, 1);

  // Unmap the left over first page.
  EXPECT_EQ(zx_vmar_unmap(zx_vmar_root_self(), mapping_addr, PAGE_SIZE), ZX_OK);

  END_TEST;
}

bool partial_unmap_and_write() {
  BEGIN_TEST;

  // Map a two-page VMO.
  zx_handle_t vmo;
  ASSERT_EQ(zx_vmo_create(PAGE_SIZE * 2, 0, &vmo), ZX_OK);
  uintptr_t mapping_addr;
  ASSERT_EQ(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0,
                        PAGE_SIZE * 2, &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);

  char* ptr = (char*)mapping_addr;
  memset(ptr, 0, PAGE_SIZE * 2);

  // Unmap the second page.
  zx_vmar_unmap(zx_vmar_root_self(), mapping_addr + PAGE_SIZE, PAGE_SIZE);

  char buffer[PAGE_SIZE * 2];
  size_t actual_written;
  memset(buffer, 0, PAGE_SIZE * 2);

  // First page succeeds.
  EXPECT_EQ(
      zx_process_write_memory(zx_process_self(), mapping_addr, buffer, PAGE_SIZE, &actual_written),
      ZX_OK);
  EXPECT_EQ(actual_written, PAGE_SIZE);

  // Second page fails.
  EXPECT_EQ(zx_process_write_memory(zx_process_self(), mapping_addr + PAGE_SIZE, buffer, PAGE_SIZE,
                                    &actual_written),
            ZX_ERR_NO_MEMORY);

  // Writing to the whole region succeeds, but only writes the first page.
  EXPECT_EQ(zx_process_write_memory(zx_process_self(), mapping_addr, buffer, PAGE_SIZE * 2,
                                    &actual_written),
            ZX_OK);
  EXPECT_EQ(actual_written, PAGE_SIZE);

  // Write at the boundary straddling the pages.
  EXPECT_EQ(zx_process_write_memory(zx_process_self(), mapping_addr + PAGE_SIZE - 1, buffer, 2,
                                    &actual_written),
            ZX_OK);
  EXPECT_EQ(actual_written, 1);

  // Unmap the left over first page.
  EXPECT_EQ(zx_vmar_unmap(zx_vmar_root_self(), mapping_addr, PAGE_SIZE), ZX_OK);

  END_TEST;
}

bool partial_unmap_with_vmar_offset() {
  BEGIN_TEST;

  constexpr size_t kOffset = 0x1000;
  constexpr size_t kVmoSize = PAGE_SIZE * 10;
  // Map a VMO, using an offset into the VMO.
  zx_handle_t vmo;
  ASSERT_EQ(zx_vmo_create(kVmoSize, 0, &vmo), ZX_OK);
  uintptr_t mapping_addr;
  ASSERT_EQ(zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, kOffset,
                        kVmoSize - kOffset, &mapping_addr),
            ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);

  char* ptr = (char*)mapping_addr;
  memset(ptr, 0, kVmoSize - kOffset);

  // Make sure both reads and writes to both the beginning and the end are allowed.
  char buffer[kVmoSize - kOffset];
  size_t actual;
  EXPECT_EQ(
      zx_process_write_memory(zx_process_self(), mapping_addr, buffer, kVmoSize - kOffset, &actual),
      ZX_OK);
  EXPECT_EQ(actual, kVmoSize - kOffset);

  EXPECT_EQ(
      zx_process_read_memory(zx_process_self(), mapping_addr, buffer, kVmoSize - kOffset, &actual),
      ZX_OK);
  EXPECT_EQ(actual, kVmoSize - kOffset);

  // That reads and writes right at the end are OK.
  EXPECT_EQ(zx_process_write_memory(zx_process_self(), mapping_addr + kVmoSize - kOffset - 1,
                                    buffer, 1, &actual),
            ZX_OK);
  EXPECT_EQ(zx_process_read_memory(zx_process_self(), mapping_addr + kVmoSize - kOffset - 1, buffer,
                                   1, &actual),
            ZX_OK);

  // That reads and writes one past the end fail.
  EXPECT_EQ(zx_process_write_memory(zx_process_self(), mapping_addr + kVmoSize - kOffset, buffer, 1,
                                    &actual),
            ZX_ERR_NO_MEMORY);
  EXPECT_EQ(zx_process_read_memory(zx_process_self(), mapping_addr + kVmoSize - kOffset, buffer, 1,
                                   &actual),
            ZX_ERR_NO_MEMORY);

  // And crossing the boundary works as expected.
  EXPECT_EQ(zx_process_write_memory(zx_process_self(), mapping_addr + kVmoSize - kOffset - 1,
                                    buffer, 2, &actual),
            ZX_OK);
  EXPECT_EQ(actual, 1);
  EXPECT_EQ(zx_process_read_memory(zx_process_self(), mapping_addr + kVmoSize - kOffset - 1, buffer,
                                   2, &actual),
            ZX_OK);
  EXPECT_EQ(actual, 1);

  END_TEST;
}

bool allow_faults_test() {
  BEGIN_TEST;

  // No-op test that checks the current default behavior.
  // TODO(stevensd): Add meaningful tests once the flag is actually implemented.
  zx_handle_t vmo;
  ASSERT_EQ(zx_vmo_create(ZX_PAGE_SIZE, ZX_VMO_RESIZABLE, &vmo), ZX_OK);
  uintptr_t mapping_addr;
  ASSERT_EQ(
      zx_vmar_map(zx_vmar_root_self(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE | ZX_VM_ALLOW_FAULTS, 0,
                  vmo, 0, ZX_PAGE_SIZE, &mapping_addr),
      ZX_OK);
  EXPECT_EQ(zx_handle_close(vmo), ZX_OK);

  EXPECT_EQ(zx_vmar_unmap(zx_vmar_root_self(), mapping_addr, PAGE_SIZE), ZX_OK);

  END_TEST;
}

// Regression test for a scenario where process_read_memory could use a stale RefPtr<VmObject>
// This will not always detect the failure scenario, but will never false positive.
bool concurrent_unmap_read_memory() {
  BEGIN_TEST;

  auto root_vmar = zx::vmar::root_self();

  zx::vmar child_vmar;
  uintptr_t addr;
  ASSERT_EQ(root_vmar->allocate(0, ZX_PAGE_SIZE * 4, ZX_VM_CAN_MAP_SPECIFIC | ZX_VM_CAN_MAP_READ,
                                &child_vmar, &addr),
            ZX_OK);

  std::atomic<bool> running = true;
  std::thread t = std::thread([addr, &running] {
    auto self = zx::process::self();
    while (running) {
      uint64_t data;
      size_t temp;
      self->read_memory(addr, &data, sizeof(data), &temp);
    }
  });

  // Iterate some number of times to attempt to hit the race condition. This is a best effort and
  // even when the bug is present it could take minutes of running to trigger it.
  for (int i = 0; i < 1000; i++) {
    uintptr_t temp;
    // vmo must be created in the loop so that it is destroyed each iteration leading to there
    // being no references to the underlying VmObject in the kernel.
    zx::vmo vmo;
    ASSERT_EQ(zx::vmo::create(ZX_PAGE_SIZE, 0, &vmo), ZX_OK);
    ASSERT_EQ(child_vmar.map(0, vmo, 0, ZX_PAGE_SIZE, ZX_VM_SPECIFIC | ZX_VM_PERM_READ, &temp),
              ZX_OK);
    ASSERT_EQ(child_vmar.unmap(addr, ZX_PAGE_SIZE), ZX_OK);
  }

  running = false;
  t.join();

  END_TEST;
}

}  // namespace

BEGIN_TEST_CASE(vmar_tests)
RUN_TEST(destroy_root_test);
RUN_TEST(basic_allocate_test);
RUN_TEST(allocate_oob_test);
RUN_TEST(allocate_unsatisfiable_test);
RUN_TEST(destroyed_vmar_test);
RUN_TEST(map_over_destroyed_test);
RUN_TEST(alignment_vmar_map_test);
RUN_TEST(alignment_vmar_allocate_test);
RUN_TEST(map_in_compact_test);
RUN_TEST(vmar_map_range_offset_test);
RUN_TEST(overmapping_test);
RUN_TEST(invalid_args_test);
RUN_TEST(unaligned_len_test);
RUN_TEST(unaligned_len_map_test);
RUN_TEST(rights_drop_test);
RUN_TEST(protect_test);
RUN_TEST(nested_region_perms_test);
RUN_TEST(object_info_test);
RUN_TEST(unmap_split_test);
RUN_TEST(unmap_multiple_test);
RUN_TEST(unmap_base_not_mapped_test);
RUN_TEST(map_specific_overwrite_test);
RUN_TEST(protect_split_test);
RUN_TEST(protect_multiple_test);
RUN_TEST(protect_over_demand_paged_test);
RUN_TEST(protect_large_uncommitted_test);
RUN_TEST(unmap_large_uncommitted_test);
RUN_TEST(partial_unmap_and_read);
RUN_TEST(partial_unmap_and_write);
RUN_TEST(partial_unmap_with_vmar_offset);
RUN_TEST(allow_faults_test);
RUN_TEST(concurrent_unmap_read_memory);
END_TEST_CASE(vmar_tests)