block_ops.hpp

 
  size_t AvailableSize()
  {
    return GetChecksumOffset() - GetUsedBlockSize(BlockType::MAIN);
  }
 
  size_t GetBlockOffset(BlockType block)
  {
    return block == BlockType::BACKUP ? block_size_ : 0;
  }
 
  size_t GetChecksumOffset() { return block_size_ - GetChecksumSize(); }
 
  size_t GetChecksumSize() { return AlignSize(sizeof(CHECKSUM_BYTE)); }
 
  void InitBlock(BlockType block)
  {
    const size_t offset = GetBlockOffset(block);
    EraseFlashOrExit(offset, block_size_);
 
    FlashInfo info;  // padding filled with 0xFF by constructor
    info.header = FLASH_HEADER;
    KeyInfo& tmp_key = info.key;
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.no_next_key, true);
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.available_flag, true);
    BlockBoolUtil<MinWriteSize>::SetFlag(tmp_key.uninit, false);
    tmp_key.SetNameLength(0);
    tmp_key.SetDataSize(0);
    WriteFlashOrExit(offset, {reinterpret_cast<uint8_t*>(&info), sizeof(FlashInfo)});
    WriteFlashOrExit(offset + GetChecksumOffset(),
                     {&CHECKSUM_BYTE, sizeof(CHECKSUM_BYTE)});
  }
 
  bool IsBlockInited(BlockType block)
  {
    const size_t offset = GetBlockOffset(block);
    FlashInfo flash_data;
    ReadFlashOrExit(offset, flash_data);
    return flash_data.header == FLASH_HEADER;
  }
 
  bool IsBlockEmpty(BlockType block)
  {
    const size_t offset = GetBlockOffset(block);
    FlashInfo flash_data;
    ReadFlashOrExit(offset, flash_data);
    return BlockBoolUtil<MinWriteSize>::ReadFlag(flash_data.key.available_flag) == true;
  }
 
  bool IsBlockError(BlockType block)
  {
    const size_t offset = GetBlockOffset(block);
    uint32_t checksum = 0;
    ReadFlashOrExit(offset + GetChecksumOffset(), checksum);
    return checksum != CHECKSUM_BYTE;
  }
 
  bool IsBlockValid(BlockType block)
  {
    return IsBlockInited(block) && !IsBlockError(block);
  }
 
  void InvalidateBlock(BlockType block)
  {
    const uint32_t invalid_checksum = 0;
    // Keep startup cleanup erase-free so same-bank MCUs only pay a single program op.
    WriteFlashOrExit(GetBlockOffset(block) + GetChecksumOffset(),
                     {&invalid_checksum, sizeof(invalid_checksum)});
  }
 
  bool TryGetUsedBlockSize(BlockType block, size_t& used_size)
  {
    const size_t block_offset = GetBlockOffset(block);
    const size_t checksum_offset = block_offset + GetChecksumOffset();
    size_t key_offset = block_offset + LibXR::OffsetOf(&FlashInfo::key);
 
    while (true)
    {
      if (key_offset + AlignSize(sizeof(KeyInfo)) > checksum_offset)
      {
        return false;
      }
 
      KeyInfo key;
      ReadFlashOrExit(key_offset, key);
 
      // Recovery cannot trust erased or half-written key metadata to bound copies.
      if (!BlockBoolUtil<MinWriteSize>::Valid(key.no_next_key) ||
          !BlockBoolUtil<MinWriteSize>::Valid(key.available_flag) ||
          !BlockBoolUtil<MinWriteSize>::Valid(key.uninit))
      {
        return false;
      }
 
      const size_t next_key_offset =
          key_offset + AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength()) +
          AlignSize(key.GetDataSize());
      if (next_key_offset > checksum_offset)
      {
        return false;
      }
 
      if (BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key))
      {
        used_size = next_key_offset - block_offset;
        return true;
      }
 
      key_offset = next_key_offset;
    }
  }
 
  size_t GetUsedBlockSize(BlockType block)
  {
    const size_t block_offset = GetBlockOffset(block);
    const size_t first_key_offset = block_offset + LibXR::OffsetOf(&FlashInfo::key);
 
    if (IsBlockEmpty(block))
    {
      return GetNextKey(first_key_offset) - block_offset;
    }
 
    return GetNextKey(GetLastKey(block)) - block_offset;
  }
 
  void CopyBlockPrefixAndChecksum(BlockType dst_block, BlockType src_block,
                                  size_t used_size)
  {
    const size_t dst_offset = GetBlockOffset(dst_block);
    const size_t src_offset = GetBlockOffset(src_block);
    const size_t checksum_offset = GetChecksumOffset();
 
    ASSERT(used_size <= checksum_offset);
    // Only the live key prefix and checksum are needed; erased tail bytes are irrelevant.
    CopyFlashData(dst_offset, src_offset, used_size);
    CopyFlashData(dst_offset + checksum_offset, src_offset + checksum_offset,
                  GetChecksumSize());
  }