src/storage/lib/buffer/mapped_vmo.cc

// Copyright 2026 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/storage/lib/buffer/mapped_vmo.h"

#include <lib/zx/result.h>
#include <lib/zx/vmar.h>
#include <lib/zx/vmo.h>
#include <string.h>
#include <zircon/assert.h>
#include <zircon/errors.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/object.h>
#include <zircon/types.h>

#include <cstdint>
#include <limits>
#include <string_view>
#include <utility>

#include <fbl/algorithm.h>

namespace storage {

namespace {

zx::result<size_t> RoundUpToPageSize(size_t size) {
  const size_t page_size = zx_system_get_page_size();
  if (size > std::numeric_limits<size_t>::max() - (page_size - 1)) {
    return zx::error(ZX_ERR_INVALID_ARGS);
  }
  return zx::ok(fbl::round_up(size, page_size));
}

}  // namespace

MappedVmo::MappedVmo(MappedVmo&& other) noexcept {
  start_ = other.start_;
  other.start_ = 0;
  size_ = other.size_;
  other.size_ = 0;
  vmo_ = std::move(other.vmo_);
}

MappedVmo& MappedVmo::operator=(MappedVmo&& other) noexcept {
  if (this != &other) {
    Reset();
    start_ = other.start_;
    other.start_ = 0;
    size_ = other.size_;
    other.size_ = 0;
    vmo_ = std::move(other.vmo_);
  }
  return *this;
}

zx::result<> MappedVmo::CreateAndMap(uint64_t size, std::string_view name) {
  if (size == 0) {
    return zx::error(ZX_ERR_INVALID_ARGS);
  }
  if (vmo_.is_valid()) {
    return zx::error(ZX_ERR_BAD_STATE);
  }
  zx::result<size_t> rounded_size = RoundUpToPageSize(size);
  if (rounded_size.is_error()) {
    return rounded_size.take_error();
  }
  size = rounded_size.value();

  zx::vmo vmo;
  if (zx_status_t status = zx::vmo::create(0, ZX_VMO_UNBOUNDED, &vmo); status != ZX_OK) {
    return zx::error(status);
  }
  if (!name.empty()) {
    if (zx_status_t status = vmo.set_property(ZX_PROP_NAME, name.data(), name.size());
        status != ZX_OK) {
      return zx::error(status);
    }
  }

  if (zx_status_t status = zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0,
                                                      size, &start_)) {
    return zx::error(status);
  }
  vmo_ = std::move(vmo);
  size_ = size;
  return zx::ok();
}

zx::result<> MappedVmo::Grow(size_t size) {
  if (!vmo_.is_valid()) {
    return zx::error(ZX_ERR_BAD_STATE);
  }
  zx::result<size_t> rounded_size = RoundUpToPageSize(size);
  if (rounded_size.is_error()) {
    return rounded_size.take_error();
  }
  size = rounded_size.value();
  if (size < size_) {
    return zx::error(ZX_ERR_INVALID_ARGS);
  }
  if (size == size_) {
    return zx::ok();
  }

  zx::unowned_vmar vmar = zx::vmar::root_self();
  uintptr_t new_start;
  if (zx_status_t status =
          vmar->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo_, 0, size, &new_start)) {
    return zx::error(status);
  }

  if (zx_status_t status = vmar->unmap(start_, size_); status != ZX_OK) {
    // Rollback the new mapping if we failed to unmap the old one.
    [[maybe_unused]] zx_status_t rollback_status = vmar->unmap(new_start, size);
    ZX_DEBUG_ASSERT(rollback_status == ZX_OK);
    return zx::error(status);
  }

  start_ = new_start;
  size_ = size;
  return zx::ok();
}

zx::result<> MappedVmo::Shrink(size_t size) {
  if (!vmo_.is_valid()) {
    return zx::error(ZX_ERR_BAD_STATE);
  }
  if (size == 0 || size > size_) {
    return zx::error(ZX_ERR_INVALID_ARGS);
  }
  size = fbl::round_up(size, zx_system_get_page_size());
  if (size == size_) {
    return zx::ok();
  }

  const size_t old_size = size_;
  if (zx_status_t status = zx::vmar::root_self()->unmap(start_ + size, old_size - size);
      status != ZX_OK) {
    return zx::error(status);
  }
  size_ = size;
  if (zx_status_t status = vmo_.op_range(ZX_VMO_OP_DECOMMIT, size, old_size - size, nullptr, 0);
      status != ZX_OK) {
    return zx::error(status);
  }
  return zx::ok();
}

void MappedVmo::Reset() {
  if (!vmo_.is_valid()) {
    return;
  }
  vmo_.reset();
  [[maybe_unused]] zx_status_t status = zx::vmar::root_self()->unmap(start_, size_);
  ZX_DEBUG_ASSERT(status == ZX_OK);
  start_ = 0;
  size_ = 0;
}

}  // namespace storage