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());
}