src/storage/f2fs/vnode_cache.cc

// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/storage/f2fs/vnode_cache.h"

#include "src/storage/f2fs/vnode.h"
#include "src/storage/lib/vfs/cpp/shared_mutex.h"

namespace f2fs {

VnodeCache::VnodeCache() = default;

VnodeCache::~VnodeCache() { Reset(); }

void VnodeCache::Reset() {
  {
    fs::SharedLock list_lock(list_lock_);
    if (ndirty_ || ndirty_dir_) {
      FX_LOGS(WARNING) << "VnodeCache is being reset while it still contains dirty vnodes. "
                       << ndirty_ << "/" << ndirty_dir_;
    }
  }
  ForDirtyVnodesIf([this](fbl::RefPtr<VnodeF2fs>& vnode) { return RemoveDirty(vnode.get()); });
  ForAllVnodes([this](fbl::RefPtr<VnodeF2fs>& vnode) { return Evict(vnode.get()); });
}

zx_status_t VnodeCache::ForAllVnodes(VnodeCallback callback) {
  ino_t next = 0;
  while (true) {
    fbl::RefPtr<VnodeF2fs> vnode;
    {
      fs::SharedLock lock(table_lock_);
      if (vnode_table_.is_empty()) {
        return ZX_OK;
      }
      // ... Acquire all subsequent nodes by iterating from the lower bound of the current node.
      auto current = vnode_table_.lower_bound(next);
      if (current == vnode_table_.end()) {
        return ZX_OK;
      }
      next = current->GetKey();
      zx::result ref = current->GetRefPtr();
      if (ref.is_ok()) {
        vnode = std::move(*ref);
      } else if (ref.error_value() == ZX_ERR_SHOULD_WAIT) {
        continue;
      }
    }
    ++next;
    if (!callback || !vnode) {
      continue;
    }
    zx_status_t status = callback(vnode);
    if (status == ZX_ERR_STOP) {
      break;
    }
    if (status != ZX_ERR_NEXT && status != ZX_OK) {
      return status;
    }
  }
  return ZX_OK;
}

zx_status_t VnodeCache::ForDirtyVnodesIf(VnodeCallback cb, VnodeCallback cb_if) {
  std::vector<fbl::RefPtr<VnodeF2fs>> dirty_vnodes;
  {
    fs::SharedLock lock(list_lock_);
    for (auto iter = dirty_list_.begin(); iter != dirty_list_.end(); ++iter) {
      fbl::RefPtr<VnodeF2fs> vnode = iter.CopyPointer();
      if (cb_if == nullptr || cb_if(vnode) == ZX_OK) {
        dirty_vnodes.push_back(std::move(vnode));
      }
    }
  }

  if (dirty_vnodes.empty()) {
    return ZX_OK;
  }

  for (auto& vnode : dirty_vnodes) {
    if (zx_status_t status = cb(vnode); status == ZX_ERR_STOP) {
      break;
    } else if (status != ZX_ERR_NEXT && status != ZX_OK) {
      return status;
    }
  }

  return ZX_OK;
}

zx_status_t VnodeCache::Lookup(const ino_t& ino, fbl::RefPtr<VnodeF2fs>* out) {
  while (true) {
    fs::SharedLock lock(table_lock_);
    auto raw_ptr = vnode_table_.find(ino).CopyPointer();
    if (!raw_ptr) {
      break;
    }
    zx::result vnode = raw_ptr->GetRefPtr();
    if (vnode.is_error()) {
      if (vnode.status_value() == ZX_ERR_SHOULD_WAIT) {
        continue;
      }
      return vnode.status_value();
    }
    *out = std::move(*vnode);
    return ZX_OK;
  }
  return ZX_ERR_NOT_FOUND;
}

zx_status_t VnodeCache::Evict(VnodeF2fs* vnode) {
  ZX_ASSERT(!(*vnode).fbl::DoublyLinkedListable<fbl::RefPtr<VnodeF2fs>>::InContainer());
  std::lock_guard lock(table_lock_);
  return EvictUnsafe(vnode);
}

zx_status_t VnodeCache::EvictUnsafe(VnodeF2fs* vnode) {
  if (!(*vnode).fbl::WAVLTreeContainable<VnodeF2fs*>::InContainer()) {
    FX_LOGS(INFO) << "EvictUnsafe: " << vnode->GetNameView() << "(" << vnode->GetKey()
                  << ") cannot be found in vnode table";
    return ZX_ERR_NOT_FOUND;
  }
  ZX_ASSERT_MSG(vnode_table_.erase(*vnode) != nullptr, "Cannot find vnode (%u)", vnode->GetKey());
  return ZX_OK;
}

zx_status_t VnodeCache::Add(VnodeF2fs* vnode) {
  std::lock_guard lock(table_lock_);
  if ((*vnode).fbl::WAVLTreeContainable<VnodeF2fs*>::InContainer()) {
    return ZX_ERR_ALREADY_EXISTS;
  }
  vnode_table_.insert(vnode);
  return ZX_OK;
}

zx_status_t VnodeCache::AddDirty(VnodeF2fs& vnode) {
  std::lock_guard lock(list_lock_);
  if (vnode.fbl::DoublyLinkedListable<fbl::RefPtr<VnodeF2fs>>::InContainer()) {
    return ZX_ERR_ALREADY_EXISTS;
  }
  fbl::RefPtr<VnodeF2fs> vnode_refptr = fbl::MakeRefPtrUpgradeFromRaw(&vnode, list_lock_);
  dirty_list_.push_back(std::move(vnode_refptr));
  if (vnode.IsDir()) {
    ++ndirty_dir_;
  }
  ++ndirty_;
  return ZX_OK;
}

bool VnodeCache::IsDirty(VnodeF2fs& vnode) {
  fs::SharedLock lock(list_lock_);
  if (vnode.fbl::DoublyLinkedListable<fbl::RefPtr<VnodeF2fs>>::InContainer()) {
    return true;
  }
  return false;
}

zx_status_t VnodeCache::RemoveDirty(VnodeF2fs* vnode) {
  std::lock_guard lock(list_lock_);
  return RemoveDirtyUnsafe(vnode);
}

zx_status_t VnodeCache::RemoveDirtyUnsafe(VnodeF2fs* vnode) {
  if (!(*vnode).fbl::DoublyLinkedListable<fbl::RefPtr<VnodeF2fs>>::InContainer()) {
    return ZX_ERR_NOT_FOUND;
  }
  auto vnode_refptr = dirty_list_.erase(*vnode);
  if (vnode_refptr->IsDir()) {
    --ndirty_dir_;
  }
  --ndirty_;
  return ZX_OK;
}

void VnodeCache::Shrink() {
  ForAllVnodes([](fbl::RefPtr<VnodeF2fs>& vnode) {
    vnode->CleanupCache();
    return ZX_OK;
  });
  ino_t next = 0;
  // All vnodes in |evicted| are deleted on return via fbl_recycle(), where Vnode::mutex_ is held.
  // To avoid introducing lock-order dependencies between vnodes and the vnode cache,
  // declare |evicted| before |table_lock_| and |list_lock_|.
  std::vector<fbl::RefPtr<VnodeF2fs>> evicted;
  std::lock_guard table_lock(table_lock_);
  std::lock_guard list_lock(list_lock_);
  while (++next) {
    auto current = vnode_table_.lower_bound(next);
    if (current == vnode_table_.end()) {
      break;
    }
    next = current->GetKey();
    if (current->IsActive()) {
      continue;
    }
    zx::result ref = current->GetRefPtr();
    ZX_ASSERT(ref.is_ok());
    if (ref->fbl::DoublyLinkedListable<fbl::RefPtr<VnodeF2fs>>::InContainer()) {
      continue;
    }
    EvictUnsafe((*ref).get());
    evicted.push_back(std::move(*ref));
  }
}

}  // namespace f2fs