Cache(SegmentManager &segment_manager);
~Cache();
+ /// Creates empty transaction
+ TransactionRef create_transaction() {
+ return std::make_unique<Transaction>(
+ get_dummy_ordering_handle(),
+ false
+ );
+ }
+
+ /// Creates empty weak transaction
+ TransactionRef create_weak_transaction() {
+ return std::make_unique<Transaction>(
+ get_dummy_ordering_handle(),
+ true
+ );
+ }
+
/**
* drop_from_cache
*
using crimson::os::seastore::Transaction;
using crimson::os::seastore::TransactionRef;
-using crimson::os::seastore::make_transaction;
using crimson::os::seastore::laddr_t;
using crimson::os::seastore::L_ADDR_MIN;
using crimson::os::seastore::L_ADDR_NULL;
return transaction_manager->mkfs(
).safe_then([this] {
return seastar::do_with(
- make_transaction(),
+ transaction_manager->create_transaction(),
[this](auto &t) {
return onode_manager->mkfs(*t
).safe_then([this, &t] {
return repeat_eagain([this, &ret] {
return seastar::do_with(
- make_transaction(),
+ transaction_manager->create_transaction(),
[this, &ret](auto &t) {
return transaction_manager->read_collection_root(*t
).safe_then([this, &ret, &t](auto coll_root) {
return seastar::do_with(
internal_context_t{ ch, std::move(t) },
std::forward<F>(f),
- [](auto &ctx, auto &f) {
+ [this](auto &ctx, auto &f) {
return repeat_eagain([&]() {
- ctx.reset(make_transaction());
+ ctx.reset(transaction_manager->create_transaction());
return std::invoke(f, ctx);
}).handle_error(
crimson::ct_error::eagain::pass_further{},
std::forward<F>(f),
[=](auto &oid, auto &ret, auto &t, auto &onode, auto &f) {
return repeat_eagain([&, this] {
- t = make_transaction();
+ t = transaction_manager->create_transaction();
return onode_manager->get_onode(
*t, oid
).safe_then([&, this](auto onode_ret) {
};
WRITE_CMP_OPERATORS_2(journal_seq_t, segment_seq, offset)
WRITE_EQ_OPERATORS_2(journal_seq_t, segment_seq, offset)
+constexpr journal_seq_t JOURNAL_SEQ_MIN{
+ 0,
+ paddr_t{0, 0}
+};
std::ostream &operator<<(std::ostream &out, const journal_seq_t &seq);
return repeat_eagain(
[this] {
return seastar::do_with(
- make_transaction(),
+ ecb->create_transaction(),
[this](auto &t) {
return rewrite_dirty(*t, get_dirty_tail()
).safe_then([this, &t] {
"SegmentCleaner::gc_reclaim_space: processing {} extents",
extents.size());
return seastar::do_with(
- make_transaction(),
+ ecb->create_transaction(),
[this, &extents](auto &t) mutable {
return crimson::do_for_each(
extents,
class ExtentCallbackInterface {
public:
virtual ~ExtentCallbackInterface() = default;
+
+ virtual TransactionRef create_transaction() = 0;
+
/**
* get_next_dirty_extent
*
private:
friend class Cache;
- friend Ref make_transaction();
- friend Ref make_weak_transaction();
+ friend Ref make_test_transaction();
/**
* If set, *this may not be used to perform writes and will not provide
};
using TransactionRef = Transaction::Ref;
-inline TransactionRef make_transaction() {
+/// Should only be used with dummy staged-fltree node extent manager
+inline TransactionRef make_test_transaction() {
return std::make_unique<Transaction>(
get_dummy_ordering_handle(),
false
);
}
-inline TransactionRef make_weak_transaction() {
- return std::make_unique<Transaction>(
- get_dummy_ordering_handle(),
- true);
-}
-
}
}).safe_then([this](auto addr) {
segment_cleaner->set_journal_head(addr);
return seastar::do_with(
- make_weak_transaction(),
+ create_weak_transaction(),
[this](auto &t) {
return cache->init_cached_extents(*t, [this](auto &t, auto &e) {
return lba_manager->init_cached_extent(t, e);
close_ertr::future<> close();
/// Creates empty transaction
- TransactionRef create_transaction() {
- return make_transaction();
+ TransactionRef create_transaction() final {
+ return cache->create_transaction();
}
- /// Creates weak transaction
+ /// Creates empty weak transaction
TransactionRef create_weak_transaction() {
- return make_weak_transaction();
+ return cache->create_weak_transaction();
}
/**
{
run_async([this] {
auto nm = NodeExtentManager::create_dummy(IS_DUMMY_SYNC);
- auto t = make_transaction();
+ auto t = make_test_transaction();
ValueBuilderImpl<TestValue> vb;
context_t c{*nm, vb, *t};
std::array<std::pair<NodeImplURef, NodeExtentMutable>, 16> nodes = {
b_dummy_tree_test_t()
: moved_nm{NodeExtentManager::create_dummy(IS_DUMMY_SYNC)},
- ref_t{make_transaction()},
+ ref_t{make_test_transaction()},
t{*ref_t},
c{*moved_nm, vb, t},
tree{std::move(moved_nm)} {}
public:
TestTree()
: moved_nm{NodeExtentManager::create_dummy(IS_DUMMY_SYNC)},
- ref_t{make_transaction()},
+ ref_t{make_test_transaction()},
t{*ref_t},
c{*moved_nm, vb, t},
tree{std::move(moved_nm)},
const split_expectation_t& expected) {
return seastar::async([this, key, value, expected] {
TestBtree tree_clone(NodeExtentManager::create_dummy(IS_DUMMY_SYNC));
- auto ref_t_clone = make_transaction();
+ auto ref_t_clone = make_test_transaction();
Transaction& t_clone = *ref_t_clone;
tree_clone.test_clone_from(t_clone, t, tree).unsafe_get0();
std::optional<TestBtree> p_btree;
NodeExtentManager* p_nm = nullptr;
ValueBuilderImpl<TestValue> vb;
- TransactionRef ref_t = make_transaction();
+ TransactionRef ref_t = make_test_transaction();
std::random_device rd;
std::set<Ref<DummyChild>> splitable_nodes;
return journal.open_for_write();
}).safe_then([this](auto addr) {
return seastar::do_with(
- make_transaction(),
+ cache.create_transaction(),
[this](auto &transaction) {
cache.init();
return cache.mkfs(*transaction
auto create_transaction() {
auto t = test_transaction_t{
- make_transaction(),
+ cache.create_transaction(),
test_lba_mappings
};
cache.alloc_new_extent<TestBlockPhysical>(*t.t, TestBlockPhysical::SIZE);
auto create_weak_transaction() {
auto t = test_transaction_t{
- make_weak_transaction(),
+ cache.create_weak_transaction(),
test_lba_mappings
};
return t;
}
auto get_transaction() {
- return make_transaction();
+ return cache.create_transaction();
}
seastar::future<> set_up_fut() final {
).safe_then(
[this] {
return seastar::do_with(
- make_transaction(),
+ cache.create_transaction(),
[this](auto &transaction) {
cache.init();
return cache.mkfs(*transaction).safe_then(