Method loadMeta

src/traffic_cache_tool/CacheDefs.cc:875–999

}

Errata
StripeSM::loadMeta()
{
  // Read from disk in chunks of this size. This needs to be a multiple of both the
  // store block size and the directory entry size so neither goes across read boundaries.
  // Beyond that the value should be in the ~10MB range for what I guess is best performance
  // vs. blocking production disk I/O on a live system.
  constexpr static int64_t N = (1 << 8) * CacheStoreBlocks::SCALE * sizeof(CacheDirEntry);

  Errata zret;

  int           fd = _span->_fd;
  Bytes         n;
  bool          found;
  MemSpan<void> data; // The current view of the read buffer.
  Bytes         delta;
  Bytes         pos = _start;
  // Avoid searching the entire span, because some of it must be content. Assume that AOS is more than 160
  // which means at most 10/160 (1/16) of the span can be directory/header.
  Bytes             limit    = pos + _len / 16;
  size_t            io_align = _span->_geometry.blocksz;
  StripeMeta const *meta;

  std::unique_ptr<char> bulk_buff;                        // Buffer for bulk reads.
  static const size_t   SBSIZE = CacheStoreBlocks::SCALE; // save some typing.
  alignas(SBSIZE) char  stripe_buff[SBSIZE];              // Use when reading a single stripe block.
  alignas(SBSIZE) char  stripe_buff2[SBSIZE];             // use to save the stripe freelist
  if (io_align > SBSIZE) {
    return Errata("Cannot load stripe {} on span [} because the I/O block alignment {} is larger than the buffer alignment {}",
                  _idx, _span->_path.string(), io_align, SBSIZE);
  }

  _directory._start = pos;
  // Header A must be at the start of the stripe block.
  // Todo: really need to check pread() for failure.
  ssize_t headerbyteCount = pread(fd, stripe_buff2, SBSIZE, pos);
  n.assign(headerbyteCount);
  data.assign(stripe_buff2, n);
  meta = static_cast<StripeMeta *>(data.data());
  // TODO:: We need to read more data at this point  to populate dir
  if (this->validateMeta(meta)) {
    delta               = Bytes(data.rebind<char>().data() - stripe_buff2);
    _meta[A][HEAD]      = *meta;
    _meta_pos[A][HEAD]  = round_down(pos + Bytes(delta));
    pos                += round_up(SBSIZE);
    _directory._skip    = Bytes(SBSIZE); // first guess, updated in @c updateLiveData when the header length is computed.
    // Search for Footer A. Nothing for it except to grub through the disk.
    // The searched data is cached so it's available for directory parsing later if needed.
    while (pos < limit) {
      char *buff = static_cast<char *>(ats_memalign(io_align, N));
      bulk_buff.reset(buff);
      n.assign(pread(fd, buff, N, pos));
      data.assign(buff, n);
      found = this->probeMeta(data, &_meta[A][HEAD]);
      if (found) {
        ptrdiff_t diff     = data.rebind<char>().data() - buff;
        _meta[A][FOOT]     = static_cast<StripeMeta *>(data.data())[0];
        _meta_pos[A][FOOT] = round_down(pos + Bytes(diff));