src/firmware/lib/fastboot/sparse_format.cc

// Copyright 2025 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/firmware/lib/fastboot/sparse_format.h"

#include <algorithm>

#include "src/storage/lib/sparse/c/sparse.h"
#include "third_party/android/platform/system/core/libsparse/sparse_format.h"
// The above header includes the
// third_party/android/platform/system/core/libsparse/sparse_defs.h which defines a `error()`
// macro. It confuses the compiler when we try to create a zx::result with zx::error(). Thus,
// we need to undefine the macro.
#ifdef error
#undef error
#endif

namespace fastboot {

namespace {

bool VmoWrite(void* dst_handle, uint64_t dst_offset, SparseIoBufferHandle src_handle,
              uint64_t src_offset, size_t size) {
  const auto& src_buffer = *reinterpret_cast<fzl::OwnedVmoMapper*>(src_handle);
  if ((size + src_offset) > src_buffer.size()) {
    return false;
  }
  const uint8_t* src = reinterpret_cast<const uint8_t*>(src_buffer.start());
  const auto& dst_buffer = *reinterpret_cast<zx::vmo*>(dst_handle);
  return dst_buffer.write(src + src_offset, dst_offset, size) == ZX_OK;
}

SparseIoBufferOps MappedVmoOps() {
  struct OwnedVmoMapperOps {
    static size_t Size(SparseIoBufferHandle handle) {
      const auto& buffer = *reinterpret_cast<fzl::OwnedVmoMapper*>(handle);
      return buffer.size();
    }

    static bool Read(SparseIoBufferHandle handle, uint64_t offset, uint8_t* dst, size_t size) {
      const auto& buffer = *reinterpret_cast<fzl::OwnedVmoMapper*>(handle);
      const uint8_t* src = reinterpret_cast<const uint8_t*>(buffer.start());
      std::memcpy(dst, src + offset, size);
      return true;
    }

    static bool Fill(SparseIoBufferHandle handle, uint32_t payload) {
      const auto& fill_buffer = *reinterpret_cast<fzl::OwnedVmoMapper*>(handle);
      if (fill_buffer.size() % sizeof payload != 0) {
        return false;
      }
      const size_t fill_amount = fill_buffer.size() / sizeof payload;
      uint32_t* dst = reinterpret_cast<uint32_t*>(fill_buffer.start());
      std::fill(dst, dst + fill_amount, payload);
      return true;
    }
  };

  return {
      .size = &OwnedVmoMapperOps::Size,
      .read = &OwnedVmoMapperOps::Read,
      .fill = &OwnedVmoMapperOps::Fill,
  };
}

}  // namespace

std::optional<uint64_t> GetUnsparsedSize(const void* buffer, uint64_t size) {
  if (size < sizeof(sparse_header_t)) {
    return std::nullopt;
  }
  const sparse_header_t* header = reinterpret_cast<const sparse_header_t*>(buffer);
  if (header->magic != SPARSE_HEADER_MAGIC) {
    return std::nullopt;
  }
  return uint64_t{header->blk_sz} * uint64_t{header->total_blks};
}

std::optional<uint64_t> GetUnsparsedSize(const fzl::OwnedVmoMapper& buffer) {
  return GetUnsparsedSize(buffer.start(), buffer.size());
}

bool IsSparseFormat(const fzl::OwnedVmoMapper& buffer) {
  return GetUnsparsedSize(buffer).has_value();
}

zx::result<> Unsparse(fzl::OwnedVmoMapper& src, zx::vmo& dst, fzl::OwnedVmoMapper& fill_buffer,
                      UnsparseErrorLogger logger) {
  if (!logger) {
    logger = &sparse_nop_logger;
  }
  SparseIoInterface io = {
      .ctx = &dst,
      .fill_handle = &fill_buffer,
      .handle_ops = MappedVmoOps(),
      .write = &VmoWrite,
  };

  if (!sparse_unpack_image(&io, logger, &src)) {
    return zx::error(ZX_ERR_IO_DATA_INTEGRITY);
  }
  return zx::ok();
}

}  // namespace fastboot