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 WriteEmptyBlockPrefix(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)});
}
 
void WriteBlockChecksum(BlockType block)
{
  WriteFlashOrExit(GetBlockOffset(block) + GetChecksumOffset(),
                   {&CHECKSUM_BYTE, sizeof(CHECKSUM_BYTE)});
}
 
void InitBlock(BlockType block)
{
  WriteEmptyBlockPrefix(block);
  WriteBlockChecksum(block);
}
 
void PrepareBackup() { WriteEmptyBlockPrefix(BlockType::BACKUP); }
 
bool IsBackupPrepared()
{
  const size_t sentinel_offset = GetSentinelOffset(BlockType::BACKUP);
  FlashInfo info;
  ReadFlashOrExit(GetBlockOffset(BlockType::BACKUP), info);
  if (info.header != FLASH_HEADER ||
      !BlockBoolUtil<MinWriteSize>::ReadFlag(info.key.no_next_key) ||
      !BlockBoolUtil<MinWriteSize>::ReadFlag(info.key.available_flag) ||
      info.key.raw_info != 0)
  {
    return false;
  }
  return IsErased(sentinel_offset + AlignSize(sizeof(KeyInfo)),
                  GetBlockOffset(BlockType::BACKUP) + block_size_);
}
 
size_t GetCrcSize() { return AlignSize(sizeof(uint32_t)); }
 
uint32_t GetBackupCrc(size_t used_size)
{
  uint32_t crc = 0xFFFFFFFFU;
  uint8_t buffer[32];
  const size_t offset = GetBlockOffset(BlockType::BACKUP);
  for (size_t done = 0; done < used_size;)
  {
    const size_t size = LibXR::min<size_t>(sizeof(buffer), used_size - done);
    ReadFlashOrExit(offset + done, RawData(buffer, size));
    for (size_t i = 0; i < size; ++i)
    {
      crc ^= buffer[i];
      for (int bit = 0; bit < 8; ++bit)
      {
        crc = (crc >> 1) ^ (0xEDB88320U & (0U - (crc & 1U)));
      }
    }
    done += size;
  }
  return ~crc;
}
 
bool IsBackupRestorable(size_t& used_size)
{
  return IsBlockValid(BlockType::BACKUP) && !IsBlockEmpty(BlockType::BACKUP) &&
         TryGetUsedBlockSize(BlockType::BACKUP, used_size);
}
 
bool IsBackupComplete(size_t& used_size)
{
  if (!IsBackupRestorable(used_size) || used_size + GetCrcSize() > GetChecksumOffset())
  {
    return false;
  }
  uint32_t stored_crc = 0;
  ReadFlashOrExit(GetBlockOffset(BlockType::BACKUP) + used_size, stored_crc);
  return stored_crc == GetBackupCrc(used_size);
}
 
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)
{
  if (!IsBlockInited(block) || IsBlockError(block))
  {
    return false;
  }
  KeyInfo sentinel;
  ReadFlashOrExit(GetSentinelOffset(block), sentinel);
  return sentinel.raw_info == 0;
}
 
size_t GetSentinelOffset(BlockType block)
{
  return GetBlockOffset(block) + LibXR::OffsetOf(&FlashInfo::key);
}
 
bool IsErased(size_t offset, size_t end)
{
  uint8_t buffer[32];
  while (offset < end)
  {
    const size_t size = LibXR::min<size_t>(sizeof(buffer), end - offset);
    ReadFlashOrExit(offset, RawData(buffer, size));
    for (size_t i = 0; i < size; ++i)
    {
      if (buffer[i] != 0xFF)
      {
        return false;
      }
    }
    offset += size;
  }
  return true;
}
 
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)
{
  return GetNextKey(GetLastKey(block)) - GetBlockOffset(block);
}
 
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();
 
  DEV_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());
}