src/storage/f2fs/writeback.h

// 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.

#ifndef SRC_STORAGE_F2FS_WRITEBACK_H_
#define SRC_STORAGE_F2FS_WRITEBACK_H_

#include <lib/fpromise/sequencer.h>

#include "src/storage/f2fs/common.h"
#include "src/storage/f2fs/file_cache.h"
#include "src/storage/lib/vfs/cpp/journal/background_executor.h"
#include "src/storage/lib/vfs/cpp/transaction/buffered_operations_builder.h"

namespace f2fs {

class StorageBufferPool;
class OwnedStorageBuffer;
class BcacheMapper;

// F2fs flushes dirty pages when the number of dirty pages >= |kMaxDirtyDataPages| if memorypressure
// is unavailable.
constexpr int kMaxDirtyDataPages = 51200;

// This class is final because there might be background threads running when its destructor runs
// and that would be unsafe if this class had overridden virtual methods that might get called from
// those background threads.
class Writer final {
 public:
  Writer(std::unique_ptr<StorageBufferPool>);
  Writer() = delete;
  Writer(const Writer &) = delete;
  Writer &operator=(const Writer &) = delete;
  Writer(Writer &&) = delete;
  Writer &operator=(Writer &&) = delete;
  ~Writer();

  // It schedules |task| on |writeback_executor_|.
  void ScheduleWriteback(fpromise::promise<> task);

  // It inserts |pages| to |pages_|, and calls GetTaskForWriteIO() that makes a task to write
  // pages out to backing storage. Then, it schedules the task on |executor_|. All tasks execute
  // in order they are scheduled by |sequencer_|.
  void ScheduleWriteBlocks(sync_completion_t *completion = nullptr, PageList pages = {},
                           bool flush = true) __TA_EXCLUDES(mutex_);

  // It returns after waiting for the storage operation for all pending pages to complete.
  void Sync();

 private:
  // It returns a task where it builds storage operations from pages and requests the operations to
  // the storage driver server to write the storage operations out to backing storage. On the
  // completion of the storage operations, the task notifies the waiters for writeback pages, and
  // signals |completion| if it is not null. See below for the semantics of |needs_preflush|.
  fpromise::promise<> GetTaskForWriteIO(PageList to_submit, sync_completion_t *completion);
  std::vector<storage::BufferedOperation> BuildBufferedOperation(OwnedStorageBuffer &buffer,
                                                                 PageList &pages,
                                                                 PageList &to_submit,
                                                                 bool &needs_preflush);

  // If the operation requires a pre-flush, |needs_preflush| will be set to true. The caller should
  // initialise `needs_preflush` to false.
  zx::result<storage::Operation> PageToOperation(OwnedStorageBuffer &buffer, Page &page,
                                                 bool &needs_preflush);

  const size_t max_block_address_;
  std::mutex mutex_;
  PageList pages_ __TA_GUARDED(mutex_);
  std::unique_ptr<StorageBufferPool> pool_;
  BcacheMapper *const bcache_mapper_ = nullptr;
  fpromise::sequencer sequencer_;
  fpromise::sequencer writeback_sequencer_;
  // An executor for tasks that write writeback pages to backing storage.
  fs::BackgroundExecutor executor_;
  // An executor for tasks that allocate blocks for dirty pages.
  fs::BackgroundExecutor writeback_executor_;
};

// A helper class to mitigate notification costs
class NotifyWriteback {
 public:
  ~NotifyWriteback() { Notify(1); }
  // It tries to group notification to writeback waiters for the same file.
  // If a new waiter of |page| doesn't belong to the same file as that of |waiters_|, it immediately
  // notifies |waiters_|.
  void ReserveNotify(fbl::RefPtr<Page> page);

 private:
  // It wakes |waiters| up when the number of waiters more than |kNotifyInterval| by default.
  void Notify(size_t interval = kNotifyInterval);
  static constexpr size_t kNotifyInterval = 8;
  PageList waiters_ = {};
};

}  // namespace f2fs

#endif  // SRC_STORAGE_F2FS_WRITEBACK_H_