src/devices/block/drivers/block-verity/superblock-verifier.h

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

#ifndef SRC_DEVICES_BLOCK_DRIVERS_BLOCK_VERITY_SUPERBLOCK_VERIFIER_H_
#define SRC_DEVICES_BLOCK_DRIVERS_BLOCK_VERITY_SUPERBLOCK_VERIFIER_H_

#include <lib/zx/vmo.h>

#include <array>
#include <memory>

#include "src/devices/block/drivers/block-verity/constants.h"
#include "src/devices/block/drivers/block-verity/device-info.h"
#include "src/devices/block/drivers/block-verity/superblock.h"

namespace block_verity {

typedef void (*SuperblockVerifierCallback)(void* cookie, zx_status_t status,
                                           const Superblock* superblock);

// `SuperblockVerifier` encapsulates asynchronously loading and verifying that a
// superblock hashes to the `expected_superblock_hash` provided to the
// constructor, and also verifies that the configuration expressed therein is
// supported by this version of the driver.
// Example:
//   SuperblockVerifier verifier(std::move(info), superblock_hash);
//   if (rc != verifier.StartVerifying(this, OnSuperblockVerificationComplete)) {
//     return rc;
//   }
//   /* OnSuperblockVerificationComplete does something useful with the superblock */
class SuperblockVerifier final {
 public:
  SuperblockVerifier(DeviceInfo info,
                     const std::array<uint8_t, kHashOutputSize>& expected_superblock_hash);
  ~SuperblockVerifier() = default;

  // Load the superblock from the device specified in `info_` and verify its hash
  // matches `expected_superblock_hash_`.  If it does, calls `callback` with
  // ZX_OK and a borrowed pointer to a superblock struct in `superblock` which
  // will cease to be valid at the end of the callback.  If not, calls `callback`
  // with a non-ZX_OK status and a null pointer for `superblock`.
  zx_status_t StartVerifying(void* cookie, SuperblockVerifierCallback callback);

  // Callback for underlying async block device I/O.
  void OnReadCompleted(zx_status_t status, block_op_t* block);

 private:
  // Driver geometry/block client handle.
  const DeviceInfo info_;

  // A single block op request buffer, allocated to be the size of the parent
  // block op size request.
  std::unique_ptr<uint8_t[]> block_op_buf_;

  // A vmo used in block device operations.  Don't bother mapping it; it's going
  // to be a single block and zx_vmo_read is faster for small ops.
  zx::vmo block_op_vmo_;

  // Holds the callback function and context pointer across async boundaries.
  // Saved when StartVerifying is called and called exactly once.
  SuperblockVerifierCallback callback_;
  void* cookie_;

  Superblock superblock_;

  // The expected superblock hash
  const std::array<uint8_t, kHashOutputSize> expected_superblock_hash_;
};

}  // namespace block_verity

#endif  // SRC_DEVICES_BLOCK_DRIVERS_BLOCK_VERITY_SUPERBLOCK_VERIFIER_H_