src/storage/f2fs/storage_buffer.cc

// Copyright 2022 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/storage_buffer.h"

#include "src/storage/f2fs/bcache.h"
#include "src/storage/f2fs/file_cache.h"

namespace f2fs {

StorageBuffer::StorageBuffer(BcacheMapper *bc, size_t num_blocks, std::string_view label)
    : allocated_blocks_(num_blocks) {
  ZX_ASSERT(num_blocks >= 1);
  ZX_ASSERT(buffer_.Initialize(bc, num_blocks, Page::Size(), label.data()) == ZX_OK);
}

zx::result<size_t> StorageBuffer::Reserve(size_t num_blocks) {
  if (current_index_ + num_blocks > allocated_blocks_) {
    return zx::error(ZX_ERR_UNAVAILABLE);
  }
  size_t ret = current_index_;
  current_index_ += num_blocks;
  return zx::ok(ret);
}

void *StorageBuffer::Data(const size_t offset) {
  ZX_ASSERT(offset < buffer_.capacity());
  return buffer_.Data(offset);
}

StorageBufferPool::StorageBufferPool(BcacheMapper *bcache_mapper, size_t default_size,
                                     size_t large_size, int num_pager_threads)
    : buffer_size_(default_size),
      large_buffer_size_(large_size),
      num_buffers_(num_pager_threads),
      bcache_mapper_(bcache_mapper) {
  ZX_ASSERT(num_pager_threads > 0);
  for (size_t i = 0; i < num_buffers_; ++i) {
    std::string str = "StorageBuffer_" + std::to_string(buffer_size_) + "_" + std::to_string(i);
    buffers(buffer_size_)
        .push_back(std::make_unique<StorageBuffer>(bcache_mapper, buffer_size_, str));
    str = "StorageBuffer_" + std::to_string(large_buffer_size_) + "_" + std::to_string(i);
    buffers(large_buffer_size_)
        .push_back(std::make_unique<StorageBuffer>(bcache_mapper, large_buffer_size_, str));
  }
}

StorageBufferPool::~StorageBufferPool() {
  for (size_t i = 0; i < num_buffers_; ++i) {
    auto buffer = Retrieve(buffer_size_);
    auto large_buffer = Retrieve(large_buffer_size_);
  }
}

std::unique_ptr<StorageBuffer> StorageBufferPool::Retrieve(size_t size) {
  ZX_ASSERT(var_.wait_for(mutex_, std::chrono::seconds(kWriteTimeOut),
                          [this, &size]()
                              TA_NO_THREAD_SAFETY_ANALYSIS { return !buffers(size).empty(); }));
  auto owned_buffer = std::move(buffers(size).back());
  buffers(size).pop_back();
  return owned_buffer;
}

OwnedStorageBuffer StorageBufferPool::Get(size_t size) {
  std::lock_guard lock(mutex_);
  ZX_ASSERT(var_.wait_for(mutex_, std::chrono::seconds(kWriteTimeOut),
                          [this, &size]()
                              TA_NO_THREAD_SAFETY_ANALYSIS { return !buffers(size).empty(); }));

  auto owned_buffer = std::move(buffers(size).back());
  buffers(size).pop_back();
  return OwnedStorageBuffer(std::move(owned_buffer),
                            [this](std::unique_ptr<StorageBuffer> buffer)
                                __TA_EXCLUDES(mutex_) { Return(std::move(buffer)); });
}

void StorageBufferPool::Return(std::unique_ptr<StorageBuffer> buffer) {
  if (buffer) {
    std::lock_guard lock(mutex_);
    buffers(buffer->Capacity()).push_back(std::move(buffer));
    var_.notify_one();
  }
}

}  // namespace f2fs