src/sys/fuzzing/common/shared-memory-unittest.cc

// Copyright 2020 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 "src/sys/fuzzing/common/shared-memory.h"

#include <zircon/errors.h>

#include <limits>
#include <random>

#include <gtest/gtest.h>
#include <sanitizer/asan_interface.h>

namespace fuzzing {
namespace {

// Test fixtures.

constexpr size_t kCapacity = 0x1000;

// Helper function to create a deterministically pseudorandom integer type.
template <typename T>
T Pick() {
  static std::mt19937_64 prng;
  return static_cast<T>(prng() & std::numeric_limits<T>::max());
}

// Helper function to create an array of deterministically pseudorandom integer types.
template <typename T>
void PickArray(T* out, size_t out_len) {
  for (size_t i = 0; i < out_len; ++i) {
    out[i] = Pick<T>();
  }
}

// Helper function to create a vector of deterministically pseudorandom integer types.
template <typename T = uint8_t>
std::vector<T> PickVector(size_t size) {
  std::vector<T> v;
  v.reserve(size);
  for (size_t i = 0; i < size; ++i) {
    v.push_back(Pick<T>());
  }
  return v;
}

// These macros test memory poisoning when AddressSanitizer is available.
#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
#define EXPECT_POISONED(addr, size) EXPECT_NE(__asan_region_is_poisoned(addr, size), nullptr)
#define EXPECT_UNPOISONED(addr, size) EXPECT_EQ(__asan_region_is_poisoned(addr, size), nullptr)
#else
#define EXPECT_POISONED(addr, size)
#define EXPECT_UNPOISONED(addr, size)
#endif  // __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)

// Unit tests.

TEST(SharedMemoryTest, Reserve) {
  SharedMemory shmem;

  EXPECT_EQ(shmem.Reserve(kCapacity), ZX_OK);
  zx::vmo vmo;
  EXPECT_EQ(shmem.Share(&vmo), ZX_OK);
  EXPECT_TRUE(vmo.is_valid());
  size_t size;
  EXPECT_EQ(vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &size, sizeof(size)), ZX_OK);
  EXPECT_EQ(size, 0U);

  size_t mapped_size;
  EXPECT_EQ(vmo.get_size(&mapped_size), ZX_OK);
  EXPECT_POISONED(shmem.data(), mapped_size);

  // Can recreate.
  EXPECT_EQ(shmem.Reserve(kCapacity * 2), ZX_OK);
  EXPECT_EQ(shmem.Share(&vmo), ZX_OK);
  EXPECT_TRUE(vmo.is_valid());
  EXPECT_EQ(vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &size, sizeof(size)), ZX_OK);
  EXPECT_EQ(size, 0U);

  EXPECT_EQ(vmo.get_size(&mapped_size), ZX_OK);
  EXPECT_POISONED(shmem.data(), mapped_size);
}

TEST(SharedMemoryTest, Mirror) {
  SharedMemory shmem;
  uint8_t region[kCapacity * 2];

  EXPECT_EQ(shmem.Mirror(region, sizeof(region)), ZX_OK);
  EXPECT_EQ(shmem.size(), sizeof(region));
  zx::vmo vmo;
  EXPECT_EQ(shmem.Share(&vmo), ZX_OK);
  EXPECT_TRUE(vmo.is_valid());

  size_t size;
  EXPECT_EQ(vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &size, sizeof(size)), ZX_OK);
  EXPECT_EQ(size, shmem.size());
  EXPECT_UNPOISONED(shmem.data(), shmem.size());

  // Can recreate. Pick a size that should have at least one ASAN alignment boundary between it and
  // the next page boundary.
  size = kCapacity + (zx_system_get_page_size() / 2);
  EXPECT_EQ(shmem.Mirror(region, size * sizeof(region[0])), ZX_OK);
  EXPECT_EQ(shmem.size(), size);
  EXPECT_EQ(shmem.Share(&vmo), ZX_OK);
  EXPECT_TRUE(vmo.is_valid());
  EXPECT_EQ(vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &size, sizeof(size)), ZX_OK);
  EXPECT_EQ(size, shmem.size());

  EXPECT_EQ(vmo.get_property(ZX_PROP_VMO_CONTENT_SIZE, &size, sizeof(size)), ZX_OK);
  EXPECT_EQ(size, shmem.size());
  EXPECT_UNPOISONED(shmem.data(), shmem.size());

  size_t mapped_size;
  EXPECT_EQ(vmo.get_size(&mapped_size), ZX_OK);
  EXPECT_POISONED(shmem.data() + size, mapped_size - size);
}

TEST(SharedMemoryTest, Link) {
  SharedMemory shmem;

  zx::vmo vmo;
  EXPECT_EQ(zx::vmo::create(kCapacity, 0, &vmo), ZX_OK);
  size_t size = kCapacity;
  EXPECT_EQ(vmo.set_property(ZX_PROP_VMO_CONTENT_SIZE, &size, sizeof(size)), ZX_OK);
  EXPECT_EQ(shmem.Link(std::move(vmo)), ZX_OK);
  EXPECT_GE(shmem.size(), kCapacity);

  // Can remap.
  EXPECT_EQ(zx::vmo::create(kCapacity * 2, 0, &vmo), ZX_OK);
  size = kCapacity / 2;
  EXPECT_EQ(vmo.set_property(ZX_PROP_VMO_CONTENT_SIZE, &size, sizeof(size)), ZX_OK);
  EXPECT_EQ(shmem.Link(std::move(vmo)), ZX_OK);
  EXPECT_GE(shmem.size(), kCapacity / 2);
}

TEST(SharedMemoryTest, Write) {
  SharedMemory shmem;

  EXPECT_EQ(shmem.Reserve(kCapacity), ZX_OK);
  auto bytes = PickVector(shmem.size());
  size_t half = bytes.size() / 2;

  // Can write before sharing...
  EXPECT_EQ(shmem.size(), 0u);
  EXPECT_EQ(shmem.Write(bytes.data(), half), ZX_OK);
  EXPECT_EQ(shmem.size(), half);

  zx::vmo vmo;
  EXPECT_EQ(shmem.Share(&vmo), ZX_OK);
  SharedMemory other;
  EXPECT_EQ(other.Link(std::move(vmo)), ZX_OK);

  auto actual = std::vector<uint8_t>(other.data(), other.data() + other.size());
  auto expected = std::vector(bytes.data(), bytes.data() + half);
  EXPECT_EQ(actual, expected);

  // ...and after sharing
  EXPECT_EQ(shmem.Write(bytes.data(), bytes.size()), ZX_OK);
  EXPECT_EQ(other.Read(), ZX_OK);

  actual = std::vector<uint8_t>(other.data(), other.data() + other.size());
  expected = std::move(bytes);
  EXPECT_EQ(actual, expected);
}

TEST(SharedMemoryTest, Update) {
  SharedMemory shmem;
  auto expected = PickVector(kCapacity);

  // Valid
  EXPECT_EQ(shmem.Mirror(expected.data(), expected.size()), ZX_OK);
  EXPECT_EQ(shmem.size(), kCapacity);
  zx::vmo vmo;
  EXPECT_EQ(shmem.Share(&vmo), ZX_OK);

  SharedMemory other;
  EXPECT_EQ(other.Link(std::move(vmo)), ZX_OK);
  EXPECT_EQ(other.size(), expected.size());
  auto actual = std::vector<uint8_t>(other.data(), other.data() + other.size());
  EXPECT_EQ(actual, expected);

  //  Change source data, but don't update. Uses |cksum| to verify |expected| did in fact change.
  auto* begin = expected.data();
  auto* end = begin + expected.size();
  auto cksum = std::accumulate(begin, end, 0, std::bit_xor<>());
  PickArray(expected.data(), expected.size());
  EXPECT_NE(cksum, std::accumulate(begin, end, 0, std::bit_xor<>()));
  actual = std::vector<uint8_t>(other.data(), other.data() + other.size());
  EXPECT_NE(actual, expected);

  //  Now update
  shmem.Update();
  actual = std::vector<uint8_t>(other.data(), other.data() + other.size());
  EXPECT_EQ(actual, expected);
}

}  // namespace
}  // namespace fuzzing