Method onKeyHashRetrievalFromLocation

cachelib/navy/block_cache/BlockCache.cpp:801–897

To retrieve the 64bit key hash from the given address. This function will not (and cannot) check if index changed in between this function call for whatever reasons. It's caller's responsibility to make sure the index is not changed and no race condition happens.

// the index is not changed and no race condition happens.
//
std::optional<uint64_t> BlockCache::onKeyHashRetrievalFromLocation(
    uint32_t address) {
  auto addrEnd = decodeRelAddress(address);
  // It won't care about seq number here (giving it as std::nullopt). It's
  // caller's responsibility to check about the race condition for the index
  // change.
  auto desc = regionManager_.openForRead(addrEnd.rid(), std::nullopt);

  if (desc.status() != OpenStatus::Ready) {
    // In rare cases, Region can return 'Retry' when it's being released after
    // the reclaim. Checking the index again will resolve it since index should
    // have been updated with the new location
    return std::nullopt;
  }

  EntryDesc entryDesc{};
  uint8_t* entryEnd{nullptr};
  {
    SCOPE_EXIT { regionManager_.close(std::move(desc)); };
    // We only need to read EntryDesc + key. (Key is just for integrity check).
    // Since we don't know the key size before reading EntryDesc, let's just
    // read enough buffer to cover most keys. If it's not enough, we can read
    // more for the key, but that'll be rare cases.
    auto readSize = std::min(512u, addrEnd.offset());

    auto buffer = regionManager_.read(desc, addrEnd.sub(readSize), readSize);
    if (buffer.isNull()) {
      return std::nullopt;
    }

    entryEnd = buffer.data() + buffer.size();
    entryDesc = *reinterpret_cast<EntryDesc*>(entryEnd - sizeof(EntryDesc));
    // check if we have enough buffer read to cover the key
    if (buffer.size() < sizeof(EntryDesc) + entryDesc.keySize) {
      // re-read to cover the key. This should be just for the larger keys
      readSize = sizeof(EntryDesc) + entryDesc.keySize;
      if (readSize > addrEnd.offset()) {
        // something's wrong with the key size. It's not within the region
        // boundary
        XLOGF(
            ERR,
            "Key size {} in item header is crossing the region boundary in "
            "onKeyHashRetrievalFromLocation(). Region {} is likely corrupted. "
            "Offset-end: {}, Physical-offset-end: {}, Header size: {}, Header "
            "(hex): {}",
            entryDesc.keySize, addrEnd.rid().index(), addrEnd.offset(),
            regionManager_.physicalOffset(addrEnd), sizeof(EntryDesc),
            folly::hexlify(
                folly::ByteRange(entryEnd - sizeof(EntryDesc), entryEnd)));
        return std::nullopt;
      }
      buffer = regionManager_.read(desc, addrEnd.sub(readSize), readSize);
      if (buffer.isNull()) {
        return std::nullopt;
      }

      // modify the address for these variables accordingly
      entryEnd = buffer.data() + buffer.size();