src/firmware/gigaboot/cpp/gpt.h

// 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.

#ifndef SRC_FIRMWARE_GIGABOOT_CPP_GPT_H_
#define SRC_FIRMWARE_GIGABOOT_CPP_GPT_H_

#include <lib/fit/result.h>
#include <lib/storage/gpt_utils.h>
#include <zircon/hw/gpt.h>

#include <array>
#include <memory>
#include <optional>
#include <string_view>

#include <fbl/vector.h>

#include "utils.h"

namespace gigaboot {

class EfiGptBlockDevice {
 public:
  static fit::result<efi_status, EfiGptBlockDevice> Create(efi_handle device_handle);

  // No copy.
  EfiGptBlockDevice(const EfiGptBlockDevice &) = delete;
  EfiGptBlockDevice &operator=(const EfiGptBlockDevice &) = delete;

  EfiGptBlockDevice(EfiGptBlockDevice &&) = default;
  EfiGptBlockDevice &operator=(EfiGptBlockDevice &&) = default;

  fit::result<efi_status> ReadPartition(std::string_view name, size_t offset, size_t length,
                                        void *out);
  fit::result<efi_status> WritePartition(std::string_view name, const void *data, size_t offset,
                                         size_t length);

  gpt_header_t const &GptHeader() const { return gpt_header_; }
  cpp20::span<const std::array<char, GPT_NAME_LEN / 2>> ListPartitionNames() const;

  size_t BlockSize() { return block_io_protocol_->Media->BlockSize; }
  uint64_t LastBlock() { return block_io_protocol_->Media->LastBlock; }

  // Find partition info.
  //
  // Note: this function will reload the GPT if the on-disk GPT has been reinitialized
  // by another EfiGptBlockDevice that references the same physical device.
  const gpt_entry_t *FindPartition(std::string_view name);

  // Load GPT from device.
  //
  // Note: this function MAY reset the primary GPT but NOT the backup.
  // The backup is only read and verified if the primary is corrupted;
  // if this is the case the primary is restored from the backup.
  //
  // There is a hole where the backup is corrupted first.
  // At some point, if the primary is ever corrupted, the load will fail.
  // To prevent this we would need to read both tables all the time during boot
  // and then repair any damage done to either table.
  // Reading both tables all the time slows down boot in the common case where
  // both tables are fine. This sort of verification and repair is arguably better
  // suited to a post-boot daemon.
  fit::result<efi_status> Load();

  // Create a FuchsiaFirmwareStorage structure for the firmware SDK storage library.
  FuchsiaFirmwareStorage GenerateStorageOps() {
    if (!storage_scratch_) {
      storage_scratch_ = std::make_unique<uint8_t[]>(BlockSize());
    }

    return FuchsiaFirmwareStorage{
        .block_size = BlockSize(),
        .total_blocks = LastBlock() + 1,
        .scratch_buffer = storage_scratch_.get(),
        .ctx = this,
        .read = RawRead,
        .write = RawWrite,
    };
  }

  // Reinitialize device's GPT.
  //
  // Generates the factory default partition table, writes it to disk,
  // and updates internal data structures.
  // Return values from FindPartition are invalidated.
  // Return values from ListPartitionNames are invalidated.
  //
  // Note: this function requires all other EfiGptBlockDevice objects
  // that reference the same disk to reread the disk's partition information.
  // Subsequent method calls on those objects may result in reloading
  // the partition information from disk.
  fit::result<efi_status> Reinitialize();

 private:
  static uint64_t GENERATION_ID;
  uint64_t generation_id_;

  std::unique_ptr<uint8_t[]> storage_scratch_;

  // The parameters we need for reading/writing partitions live in both block and disk io protocols.
  EfiProtocolPtr<efi_block_io_protocol> block_io_protocol_;
  EfiProtocolPtr<efi_disk_io_protocol> disk_io_protocol_;

  gpt_header_t gpt_header_;

  // These two vectors are tied together:
  // utf8_names_[i] is the name for entries_[i].
  // The reason that they are two separate vectors is that it's
  // much easier to read the entries straight off the disk and
  // into a vector in a single operation,
  // and it's also easier to calculate the entries' crc on the raw bytes
  // as a single, contiguous chunk.
  fbl::Vector<gpt_entry_t> entries_;
  fbl::Vector<std::array<char, GPT_NAME_LEN / 2>> utf8_names_;

  static bool RawRead(void *ctx, size_t block_offset, size_t blocks_count, void *dest);
  static bool RawWrite(void *ctx, size_t block_offset, size_t blocks_count, const void *src);

  EfiGptBlockDevice() : generation_id_(GENERATION_ID - 1) {}
  efi_status Read(void *buffer, size_t offset, size_t length);
  efi_status Write(const void *data, size_t offset, size_t length);

  fit::result<efi_status> LoadGptEntries(const gpt_header_t &);
  fit::result<efi_status> RestoreFromBackup();

  // Check that the given range is within boundary of a partition and returns the absolute offset
  // relative to the storage start.
  fit::result<efi_status, size_t> CheckAndGetPartitionAccessRangeInStorage(std::string_view name,
                                                                           size_t offset,
                                                                           size_t length);
};

fit::result<efi_status, EfiGptBlockDevice> FindEfiGptDevice();

}  // namespace gigaboot

#endif  // SRC_FIRMWARE_GIGABOOT_CPP_GPT_H_