key_ops.hpp

 
size_t GetKeyData(size_t offset)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  return offset + AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength());
}
 
size_t GetKeyName(size_t offset) { return offset + AlignSize(sizeof(KeyInfo)); }
 
size_t GetKeySpan(const KeyInfo& key)
{
  return AlignSize(sizeof(KeyInfo)) + AlignSize(key.GetNameLength()) +
         AlignSize(key.GetDataSize());
}
 
size_t GetKeySize(size_t offset)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  return GetKeySpan(key);
}
 
size_t GetNextKey(size_t offset) { return offset + GetKeySize(offset); }
 
static bool IsKeyLive(const KeyInfo& key)
{
  return BlockBoolUtil<MinWriteSize>::ReadFlag(key.available_flag) &&
         !BlockBoolUtil<MinWriteSize>::ReadFlag(key.uninit);
}
 
void ClearKeyFlag(size_t key_offset, BlockBoolData<MinWriteSize> KeyInfo::* flag)
{
  const size_t flag_offset = key_offset + LibXR::OffsetOf(flag);
  BlockBoolData<MinWriteSize> value;
  ReadFlashOrExit(flag_offset, value);
  if (!BlockBoolUtil<MinWriteSize>::ReadFlag(value))
  {
    return;
  }
  BlockBoolUtil<MinWriteSize>::SetFlag(value, false);
  WriteFlashOrExit(flag_offset, value);
}
 
void LinkKey(BlockType block, size_t last_key_offset)
{
  if (last_key_offset == GetSentinelOffset(block))
  {
    ClearKeyFlag(last_key_offset, &KeyInfo::available_flag);
  }
  ClearKeyFlag(last_key_offset, &KeyInfo::no_next_key);
}
 
void WriteKeyHeader(size_t key_offset, size_t name_len, size_t size)
{
  KeyInfo key;
  key.SetNameLength(static_cast<uint8_t>(name_len));
  key.SetDataSize(static_cast<uint32_t>(size));
  WriteFlashOrExit(key_offset + LibXR::OffsetOf(&KeyInfo::raw_info), key.raw_info);
}
 
bool NextChainKey(BlockType block, size_t& key_offset, KeyInfo& key)
{
  if (BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key))
  {
    return false;
  }
 
  const size_t limit = GetBlockOffset(block) + GetChecksumOffset();
  const size_t next_offset = key_offset + GetKeySpan(key);
  if (next_offset + AlignSize(sizeof(KeyInfo)) > limit)
  {
    return false;
  }
 
  KeyInfo next_key;
  ReadFlashOrExit(next_offset, next_key);
  if (next_offset + GetKeySpan(next_key) > limit)
  {
    return false;
  }
 
  key_offset = next_offset;
  key = next_key;
  return true;
}
 
size_t GetLastKey(BlockType block)
{
  size_t key_offset = GetSentinelOffset(block);
  KeyInfo key;
  ReadFlashOrExit(key_offset, key);
  while (NextChainKey(block, key_offset, key))
  {
  }
  return key_offset;
}
 
bool KeyDataCompare(size_t offset, const void* data, size_t size)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  size_t key_data_offset = GetKeyData(offset);
  uint8_t data_buffer = 0;
  for (size_t i = 0; i < size; i++)
  {
    ReadFlashOrExit(key_data_offset + i, data_buffer);
    if (data_buffer != (reinterpret_cast<const uint8_t*>(data))[i])
    {
      return true;
    }
  }
  return false;
}
 
bool KeyNameCompare(size_t offset, const char* name)
{
  KeyInfo key;
  ReadFlashOrExit(offset, key);
  for (size_t i = 0; i < key.GetNameLength(); i++)
  {
    uint8_t data_buffer = 0;
    ReadFlashOrExit(offset + AlignSize(sizeof(KeyInfo)) + i, data_buffer);
    if (data_buffer != name[i])
    {
      return true;
    }
  }
  return false;
}
 
bool IsKeyNameTerminated(size_t key_offset, const KeyInfo& key)
{
  const size_t name_len = key.GetNameLength();
  if (name_len == 0)
  {
    return false;
  }
  uint8_t last_byte = 0xFF;
  ReadFlashOrExit(GetKeyName(key_offset) + name_len - 1, last_byte);
  return last_byte == 0;
}
 
size_t FindKey(const char* name, size_t& dead_keys)
{
  size_t key_offset = GetSentinelOffset(BlockType::MAIN);
  KeyInfo key;
  ReadFlashOrExit(key_offset, key);
  dead_keys = 0;
 
  while (NextChainKey(BlockType::MAIN, key_offset, key))
  {
    if (!IsKeyLive(key))
    {
      dead_keys++;
      continue;
    }
    if (!KeyNameCompare(key_offset, name))
    {
      return key_offset;
    }
  }
  return 0;
}
 
size_t SearchKey(const char* name)
{
  size_t dead_keys = 0;
  const size_t ans = FindKey(name, dead_keys);
  if (dead_keys > recycle_threshold_)
  {
    Recycle();
    return FindKey(name, dead_keys);
  }
  return ans;
}
 
ErrorCode ReserveKey(size_t name_len, size_t size, size_t& last_key_offset)
{
  const size_t needed =
      AlignSize(sizeof(KeyInfo)) + AlignSize(name_len) + AlignSize(size);
  if (AvailableSize() < needed)
  {
    Recycle();
    if (AvailableSize() < needed)
    {
      return ErrorCode::FULL;
    }
  }
  last_key_offset = GetLastKey(BlockType::MAIN);
  return ErrorCode::OK;
}
 
ErrorCode AddKey(const char* name, const void* data, size_t size)
{
  if (SearchKey(name))
  {
    return SetKey(name, data, size);
  }
 
  const size_t name_len = strlen(name) + 1;
  size_t last_key_offset = 0;
  const ErrorCode ec = ReserveKey(name_len, size, last_key_offset);
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  const size_t key_offset = GetNextKey(last_key_offset);
  WriteKeyHeader(key_offset, name_len, size);
  WriteFlashOrExit(GetKeyName(key_offset),
                   {reinterpret_cast<const uint8_t*>(name), name_len});
  WriteFlashOrExit(GetKeyData(key_offset),
                   {reinterpret_cast<const uint8_t*>(data), size});
  ClearKeyFlag(key_offset, &KeyInfo::uninit);
  LinkKey(BlockType::MAIN, last_key_offset);
  return ErrorCode::OK;
}
 
ErrorCode SetKey(const char* name, const void* data, size_t size, bool recycle = true)
{
  const size_t key_offset = SearchKey(name);
  if (!key_offset)
  {
    return ErrorCode::FAILED;
  }
 
  KeyInfo key;
  ReadFlashOrExit(key_offset, key);
  if (key.GetDataSize() != size)
  {
    return ErrorCode::FAILED;
  }
  if (!KeyDataCompare(key_offset, data, size))
  {
    return ErrorCode::OK;
  }
 
  const size_t name_len = key.GetNameLength();
  if (AvailableSize() <
      AlignSize(sizeof(KeyInfo)) + AlignSize(name_len) + AlignSize(size))
  {
    if (!recycle)
    {
      return ErrorCode::FULL;
    }
    Recycle();
    return SetKey(name, data, size, false);
  }
 
  const size_t last_key_offset = GetLastKey(BlockType::MAIN);
  const size_t new_key_offset = GetNextKey(last_key_offset);
  WriteKeyHeader(new_key_offset, name_len, size);
  CopyFlashData(GetKeyName(new_key_offset), GetKeyName(key_offset), name_len);
  WriteFlashOrExit(GetKeyData(new_key_offset),
                   {reinterpret_cast<const uint8_t*>(data), size});
  ClearKeyFlag(new_key_offset, &KeyInfo::uninit);
  ClearKeyFlag(key_offset, &KeyInfo::available_flag);
  LinkKey(BlockType::MAIN, last_key_offset);
  return ErrorCode::OK;
}
 
bool CompleteUnlinkedKey(size_t last_key_offset, size_t key_offset)
{
  const size_t checksum_offset = GetChecksumOffset();
  if (key_offset + AlignSize(sizeof(KeyInfo)) > checksum_offset)
  {
    return false;
  }
 
  KeyInfo key;
  ReadFlashOrExit(key_offset, key);
  const size_t end_offset = key_offset + GetKeySpan(key);
  if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key) || !IsKeyLive(key) ||
      end_offset > checksum_offset || !IsKeyNameTerminated(key_offset, key) ||
      !IsErased(end_offset, checksum_offset))
  {
    return false;
  }
 
  char name[0x80] = {};
  ReadFlashOrExit(GetKeyName(key_offset), RawData(name, key.GetNameLength()));
  size_t dead_keys = 0;
  const size_t old_offset = FindKey(name, dead_keys);
  if (old_offset != 0)
  {
    KeyInfo old_key;
    ReadFlashOrExit(old_offset, old_key);
    if (old_key.GetDataSize() != key.GetDataSize())
    {
      return false;
    }
    ClearKeyFlag(old_offset, &KeyInfo::available_flag);
  }
 
  LinkKey(BlockType::MAIN, last_key_offset);
  return true;
}
 
void RepairMainChain()
{
  size_t key_offset = GetSentinelOffset(BlockType::MAIN);
  KeyInfo key;
  ReadFlashOrExit(key_offset, key);
  size_t dead_keys = 0;
  while (NextChainKey(BlockType::MAIN, key_offset, key))
  {
    if (!IsKeyLive(key))
    {
      dead_keys++;
    }
  }
 
  const bool chain_complete = BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key);
  const size_t tail_offset = key_offset + GetKeySpan(key);
  if (chain_complete && IsErased(tail_offset, GetChecksumOffset()))
  {
    if (dead_keys > recycle_threshold_)
    {
      Recycle();
    }
    return;
  }
 
  if (chain_complete && CompleteUnlinkedKey(key_offset, tail_offset))
  {
    return;
  }
 
  // Recycle() 只在整理后的键加上 CRC 单元放不下时返回 FULL，而链尾之后的残留至少占一个
  // 键头，不小于 CRC 单元，所以需要清理残留时回收总能进行。
  // Recycle() returns FULL only when the compacted keys plus the CRC unit do not fit,
  // and leftovers after the chain take at least one key header, no smaller than the CRC
  // unit, so a recycle can always run when leftovers have to be cleared.
  Recycle();
}