lifecycle.hpp

 
  ErrorCode Get(Database::KeyBase& key) override
  {
    auto ans = SearchKey(key.name_);
    if (!ans)
    {
      return ErrorCode::NOT_FOUND;
    }
 
    KeyInfo key_buffer;
    ReadFlashOrExit(ans, key_buffer);
 
    if (key.raw_data_.size_ != key_buffer.GetDataSize())
    {
      return ErrorCode::FAILED;
    }
 
    ReadFlashOrExit(GetKeyData(ans), key.raw_data_);
 
    return ErrorCode::OK;
  }
 
  ErrorCode Set(KeyBase& key, RawData data) override
  {
    return SetKey(key.name_, data.addr_, data.size_);
  }
 
  ErrorCode Add(KeyBase& key) override
  {
    return AddKey(key.name_, key.raw_data_.addr_, key.raw_data_.size_);
  }
 
  explicit DatabaseRaw(Flash& flash, size_t recycle_threshold = 128)
      : recycle_threshold_(recycle_threshold), flash_(flash)
  {
    ASSERT(flash.MinEraseSize() * 2 <= flash_.Size());
    ASSERT(flash_.MinWriteSize() <= MinWriteSize);
    auto block_num = static_cast<size_t>(flash_.Size() / flash.MinEraseSize());
    block_size_ = block_num / 2 * flash.MinEraseSize();
    Init();
  }
 
  void Init()
  {
    if (!IsBlockValid(BlockType::MAIN))
    {
      if (!IsBlockValid(BlockType::BACKUP) || IsBlockEmpty(BlockType::BACKUP))
      {
        InitBlock(BlockType::MAIN);
      }
      else
      {
        size_t used_size = 0;
        if (!TryGetUsedBlockSize(BlockType::BACKUP, used_size))
        {
          InvalidateBlock(BlockType::BACKUP);
          InitBlock(BlockType::MAIN);
        }
        else
        {
          EraseFlashOrExit(0, block_size_);
          CopyBlockPrefixAndChecksum(BlockType::MAIN, BlockType::BACKUP, used_size);
          InvalidateBlock(BlockType::BACKUP);
        }
      }
    }
    else if (IsBlockValid(BlockType::BACKUP) && !IsBlockEmpty(BlockType::BACKUP))
    {
      // A stale backup must not stay recoverable once the main block is already good.
      InvalidateBlock(BlockType::BACKUP);
    }
 
    KeyInfo key;
    size_t key_offset = LibXR::OffsetOf(&FlashInfo::key);
    ReadFlashOrExit(key_offset, key);
    size_t need_cycle = 0;
    while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key))
    {
      key_offset = GetNextKey(key_offset);
 
      if (key_offset + AlignSize(sizeof(KeyInfo)) > GetChecksumOffset())
      {
        InitBlock(BlockType::MAIN);
        break;
      }
 
      ReadFlashOrExit(key_offset, key);
 
      // 当前策略仍然是“看到未完成键就整块重建”，还没有实现更细粒度的坏数据恢复。
      // The current policy still rebuilds the whole block when it sees an
      // incomplete key; finer-grained damaged-data recovery is not implemented
      // yet.
      if (BlockBoolUtil<MinWriteSize>::ReadFlag(key.uninit))
      {
        InitBlock(BlockType::MAIN);
        break;
      }
      if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.available_flag))
      {
        need_cycle += 1;
      }
    }
 
    if (need_cycle > recycle_threshold_)
    {
      Recycle();
    }
  }
 
  void Restore()
  {
    InitBlock(BlockType::MAIN);
    InitBlock(BlockType::BACKUP);
  }
 
  ErrorCode Recycle()
  {
    if (IsBlockEmpty(BlockType::MAIN))
    {
      return ErrorCode::OK;
    }
 
    KeyInfo key;
    size_t key_offset = LibXR::OffsetOf(&FlashInfo::key);
    ReadFlashOrExit(key_offset, key);
 
    if (!IsBlockValid(BlockType::BACKUP) || !IsBlockEmpty(BlockType::BACKUP))
    {
      InitBlock(BlockType::BACKUP);
    }
 
    size_t write_buff_offset = LibXR::OffsetOf(&FlashInfo::key) + block_size_;
 
    auto new_key = KeyInfo{};
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.uninit, false);
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.available_flag, false);
    BlockBoolUtil<MinWriteSize>::SetFlag(new_key.no_next_key, false);
    WriteFlashOrExit(write_buff_offset, new_key);
 
    write_buff_offset += GetKeySize(write_buff_offset);
 
    do
    {
      key_offset = GetNextKey(key_offset);
      ReadFlashOrExit(key_offset, key);
 
      if (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.available_flag))
      {
        continue;
      }
 
      WriteFlashOrExit(write_buff_offset, key);
      write_buff_offset += AlignSize(sizeof(KeyInfo));
      CopyFlashData(write_buff_offset, GetKeyName(key_offset), key.GetNameLength());
      write_buff_offset += AlignSize(key.GetNameLength());
      CopyFlashData(write_buff_offset, GetKeyData(key_offset), key.GetDataSize());
      write_buff_offset += AlignSize(key.GetDataSize());
    } while (!BlockBoolUtil<MinWriteSize>::ReadFlag(key.no_next_key));
 
    const size_t used_size = write_buff_offset - block_size_;
    EraseFlashOrExit(0, block_size_);
    CopyBlockPrefixAndChecksum(BlockType::MAIN, BlockType::BACKUP, used_size);
 
    InitBlock(BlockType::BACKUP);
 
    return ErrorCode::OK;
  }