src/lib/zbitl/efi.cc

// Copyright 2022 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 <lib/zbitl/efi.h>

#include <memory>

namespace zbitl {
namespace {

constexpr size_t kBufferSize = 4096;

union EfiFileInfoBuffer {
  efi_file_info info;
  char space[sizeof(efi_file_info) + sizeof(char16_t[255])];
};

fit::result<efi_status, EfiFileInfoBuffer> EfiFileGetInfo(efi_file_protocol* file) {
  EfiFileInfoBuffer buffer;
  size_t info_size = sizeof(buffer);
  efi_status status = file->GetInfo(file, &FileInfoGuid, &info_size, &buffer);
  if (status != EFI_SUCCESS) {
    return fit::error{status};
  }
  ZX_ASSERT(info_size >= sizeof(buffer.info));
  return fit::ok(buffer);
}

}  // namespace

fit::result<efi_status, uint32_t> StorageTraits<efi_file_protocol*>::Capacity(
    efi_file_protocol* file) {
  auto result = EfiFileGetInfo(file);
  if (result.is_error()) {
    return result.take_error();
  }
  const uint64_t size = result->info.FileSize;
  uint64_t capped_size = std::min<uint64_t>(size, std::numeric_limits<uint32_t>::max());
  return fit::ok(static_cast<uint32_t>(capped_size));
}

fit::result<efi_status> StorageTraits<efi_file_protocol*>::EnsureCapacity(efi_file_protocol* file,
                                                                          uint32_t capacity_bytes) {
  auto result = EfiFileGetInfo(file);
  if (result.is_error()) {
    return result.take_error();
  }
  result->info.FileSize = capacity_bytes;
  efi_status status = file->SetInfo(file, &FileInfoGuid, static_cast<size_t>(result->info.Size),
                                    std::addressof(result.value()));
  if (status != EFI_SUCCESS) {
    return fit::error{status};
  }
  return fit::ok();
}

fit::result<efi_status> StorageTraits<efi_file_protocol*>::Read(efi_file_protocol* file,
                                                                uint64_t payload, void* buffer,
                                                                uint32_t length) {
  efi_status status = file->SetPosition(file, payload);
  if (status == EFI_SUCCESS) {
    size_t read_size = length;
    status = file->Read(file, &read_size, buffer);
    if (status == EFI_SUCCESS && read_size != length) {
      status = EFI_END_OF_FILE;
    }
  }
  if (status != EFI_SUCCESS) {
    return fit::error{status};
  }
  return fit::ok();
}

fit::result<efi_status> StorageTraits<efi_file_protocol*>::Write(efi_file_protocol* file,
                                                                 uint32_t offset,
                                                                 zbitl::ByteView data) {
  if (data.empty()) {
    return fit::ok();
  }
  efi_status status = file->SetPosition(file, offset);
  if (status == EFI_SUCCESS) {
    size_t size = data.size();
    status = file->Write(file, &size, data.data());
    if (status == EFI_SUCCESS && size != data.size()) {
      status = EFI_VOLUME_FULL;
    }
  }
  if (status != EFI_SUCCESS) {
    return fit::error{status};
  }
  return fit::ok();
}

fit::result<efi_status> StorageTraits<efi_file_protocol*>::DoRead(efi_file_protocol* file,
                                                                  uint64_t offset, uint32_t length,
                                                                  bool (*cb)(void*, ByteView),
                                                                  void* arg) {
  if (length == 0) {
    cb(arg, {});
    return fit::ok();
  }

  if (efi_status status = file->SetPosition(file, offset); status != EFI_SUCCESS) {
    return fit::error{status};
  }

  auto size = [&]() { return std::min(static_cast<size_t>(length), kBufferSize); };
  std::unique_ptr<std::byte[]> buf{new std::byte[size()]};

  while (length > 0) {
    size_t read_size = size();
    efi_status status = file->Read(file, &read_size, buf.get());
    if (status != EFI_SUCCESS) {
      return fit::error{status};
    }
    ZX_ASSERT(read_size <= kBufferSize);
    if (!cb(arg, {buf.get(), read_size})) {
      break;
    }
    length -= static_cast<uint32_t>(read_size);
  }

  return fit::ok();
}

}  // namespace zbitl