#define FORWARD(METHOD) \
template <typename... Args> \
auto METHOD(Args&&... args) const { \
- return tm.METHOD(std::forward<Args>(args)...); \
+ return tm->METHOD(std::forward<Args>(args)...); \
}
#define PARAM_FORWARD(METHOD) \
template <typename T, typename... Args> \
auto METHOD(Args&&... args) const { \
- return tm.METHOD<T>(std::forward<Args>(args)...); \
+ return tm->METHOD<T>(std::forward<Args>(args)...); \
}
#define INT_FORWARD(METHOD) \
return with_trans_intr( \
t, \
[this](auto&&... args) { \
- return tm.METHOD(std::forward<decltype(args)>(args)...); \
+ return tm->METHOD(std::forward<decltype(args)>(args)...); \
}, \
std::forward<Args>(args)...); \
}
return with_trans_intr( \
t, \
[this](auto&&... args) { \
- return tm.METHOD<T>(std::forward<decltype(args)>(args)...); \
+ return tm->METHOD<T>(std::forward<decltype(args)>(args)...); \
}, \
std::forward<Args>(args)...); \
}
/// Temporary translator to non-interruptible futures
class InterruptedTransactionManager {
- TransactionManager &tm;
+ TransactionManager *tm = nullptr;
public:
+ InterruptedTransactionManager() = default;
InterruptedTransactionManager(const InterruptedTransactionManager &) = default;
InterruptedTransactionManager(InterruptedTransactionManager &&) = default;
- InterruptedTransactionManager(TransactionManager &tm) : tm(tm) {}
+ InterruptedTransactionManager(TransactionManager &tm) : tm(&tm) {}
+
+ InterruptedTransactionManager &operator=(
+ const InterruptedTransactionManager &) = default;
+ InterruptedTransactionManager &operator=(
+ InterruptedTransactionManager &&) = default;
FORWARD(mkfs)
FORWARD(mount)
FORWARD(get_segment_cleaner)
FORWARD(get_lba_manager)
+
+ void reset() { tm = nullptr; }
};
class InterruptedTMRef {
virtual void _init() final {
TMTestState::_init();
- manager.reset(new FLTreeOnodeManager(*tm));
+ manager.reset(new FLTreeOnodeManager(itm));
}
virtual void _destroy() final {
[this](auto &t) {
return manager->mkfs(*t
).safe_then([this, &t] {
- return tm->submit_transaction(*t);
+ return submit_transaction_fut(*t);
});
});
}).safe_then([this] {
{8, 11, 64, 256, 301, 320},
{8, 16, 128, 512, 576, 640},
{0, 16}, {0, 10}, {0, 4});
- auto moved_nm = (TEST_SEASTORE ? NodeExtentManager::create_seastore(*tm)
+ auto moved_nm = (TEST_SEASTORE ? NodeExtentManager::create_seastore(itm)
: NodeExtentManager::create_dummy(IS_DUMMY_SYNC));
auto p_nm = moved_nm.get();
auto tree = std::make_unique<TreeBuilder<TRACK_CURSORS, BoundedValue>>(
if constexpr (TEST_SEASTORE) {
logger().info("seastore replay insert begin");
restart();
- tree->reload(NodeExtentManager::create_seastore(*tm));
+ tree->reload(NodeExtentManager::create_seastore(itm));
logger().info("seastore replay insert end");
}
{
if constexpr (TEST_SEASTORE) {
logger().info("seastore replay erase-1 begin");
restart();
- tree->reload(NodeExtentManager::create_seastore(*tm));
+ tree->reload(NodeExtentManager::create_seastore(itm));
logger().info("seastore replay erase-1 end");
}
{
if constexpr (TEST_SEASTORE) {
logger().info("seastore replay erase-2 begin");
restart();
- tree->reload(NodeExtentManager::create_seastore(*tm));
+ tree->reload(NodeExtentManager::create_seastore(itm));
logger().info("seastore replay erase-2 end");
}
{
{8, 16, 128, 576, 992, 1200},
{0, 8}, {0, 10}, {0, 4});
auto moved_nm = NodeExtentManager::create_seastore(
- *tm, L_ADDR_MIN, EAGAIN_PROBABILITY);
+ itm, L_ADDR_MIN, EAGAIN_PROBABILITY);
auto p_nm = static_cast<SeastoreNodeExtentManager<true>*>(moved_nm.get());
auto tree = std::make_unique<TreeBuilder<TRACK_CURSORS, ExtendedValue>>(
kvs, std::move(moved_nm));
[this, &tree](auto &t) {
return tree->bootstrap(*t
).safe_then([this, &t] {
- return tm->submit_transaction(*t);
+ return submit_transaction_fut(*t);
});
});
}).unsafe_get0();
return tree->insert_one(*t, iter
).safe_then([this, &t](auto cursor) {
cursor.invalidate();
- return tm->submit_transaction(*t);
+ return submit_transaction_fut(*t);
});
});
}).unsafe_get0();
[this, &tree, &iter](auto &t) {
return tree->erase_one(*t, iter
).safe_then([this, &t] () mutable {
- return tm->submit_transaction(*t);
+ return submit_transaction_fut(*t);
});
});
}).unsafe_get0();
object_data_handler_test_t() {}
- auto submit_transaction(TransactionRef &&t) {
- return tm->submit_transaction(*t
- ).safe_then([this] {
- return segment_cleaner->run_until_halt();
- });
- }
-
void write(Transaction &t, objaddr_t offset, extent_len_t len, char fill) {
ceph_assert(offset + len <= known_contents.length());
size = std::max<extent_len_t>(size, offset + len);
len));
return ObjectDataHandler().write(
ObjectDataHandler::context_t{
- *tm,
+ itm,
t,
*onode,
},
void write(objaddr_t offset, extent_len_t len, char fill) {
auto t = tm->create_transaction();
write(*t, offset, len, fill);
- return submit_transaction(std::move(t)).unsafe_get0();
+ return submit_transaction(std::move(t));
}
void truncate(Transaction &t, objaddr_t offset) {
size - offset);
ObjectDataHandler().truncate(
ObjectDataHandler::context_t{
- *tm,
+ itm,
t,
*onode
},
void truncate(objaddr_t offset) {
auto t = tm->create_transaction();
truncate(*t, offset);
- return submit_transaction(std::move(t)).unsafe_get0();
+ return submit_transaction(std::move(t));
}
void read(Transaction &t, objaddr_t offset, extent_len_t len) {
bufferlist bl = ObjectDataHandler().read(
ObjectDataHandler::context_t{
- *tm,
+ itm,
t,
*onode
},
seastar::future<> set_up_fut() final {
return tm_setup().then([this] {
- omap_manager = omap_manager::create_omap_manager(*tm);
+ omap_manager = omap_manager::create_omap_manager(itm);
return seastar::now();
});
}
void replay() {
logger().debug("{}: begin", __func__);
restart();
- omap_manager = omap_manager::create_omap_manager(*tm);
+ omap_manager = omap_manager::create_omap_manager(itm);
logger().debug("{}: end", __func__);
}
};
};
test_transaction_t create_transaction() {
- return { tm->create_transaction(), {} };
+ return { itm.create_transaction(), {} };
}
test_transaction_t create_weak_transaction() {
- return { tm->create_weak_transaction(), {} };
+ return { itm.create_weak_transaction(), {} };
}
TestBlockRef alloc_extent(
laddr_t hint,
extent_len_t len,
char contents) {
- auto extent = tm->alloc_extent<TestBlock>(
+ auto extent = itm.alloc_extent<TestBlock>(
*(t.t),
hint,
len).unsafe_get0();
ceph_assert(test_mappings.contains(addr, t.mapping_delta));
ceph_assert(test_mappings.get(addr, t.mapping_delta).desc.len == len);
- auto ext = tm->read_extent<TestBlock>(
+ auto ext = itm.read_extent<TestBlock>(
*t.t, addr, len
).unsafe_get0();
EXPECT_EQ(addr, ext->get_laddr());
using ertr = with_trans_ertr<TransactionManager::read_extent_iertr>;
using ret = ertr::future<TestBlockRef>;
- auto ext = tm->read_extent<TestBlock>(
+ auto ext = itm.read_extent<TestBlock>(
*t.t, addr, len
).safe_then([](auto ext) -> ret {
return ertr::make_ready_future<TestBlockRef>(ext);
test_mappings.get(ref->get_laddr(), t.mapping_delta).desc.len ==
ref->get_length());
- auto ext = tm->get_mutable_extent(*t.t, ref)->cast<TestBlock>();
+ auto ext = itm.get_mutable_extent(*t.t, ref)->cast<TestBlock>();
EXPECT_EQ(ext->get_laddr(), ref->get_laddr());
EXPECT_EQ(ext->get_desc(), ref->get_desc());
mutator.mutate(*ext, gen);
ceph_assert(test_mappings.contains(offset, t.mapping_delta));
ceph_assert(test_mappings.get(offset, t.mapping_delta).refcount > 0);
- auto refcnt = tm->inc_ref(*t.t, offset).unsafe_get0();
+ auto refcnt = itm.inc_ref(*t.t, offset).unsafe_get0();
auto check_refcnt = test_mappings.inc_ref(offset, t.mapping_delta);
EXPECT_EQ(refcnt, check_refcnt);
}
ceph_assert(test_mappings.contains(offset, t.mapping_delta));
ceph_assert(test_mappings.get(offset, t.mapping_delta).refcount > 0);
- auto refcnt = tm->dec_ref(*t.t, offset).unsafe_get0();
+ auto refcnt = itm.dec_ref(*t.t, offset).unsafe_get0();
auto check_refcnt = test_mappings.dec_ref(offset, t.mapping_delta);
EXPECT_EQ(refcnt, check_refcnt);
if (refcnt == 0)
bool try_submit_transaction(test_transaction_t t) {
using ertr = with_trans_ertr<TransactionManager::submit_transaction_iertr>;
using ret = ertr::future<bool>;
- bool success = tm->submit_transaction(*t.t
+ bool success = itm.submit_transaction(*t.t
).safe_then([]() -> ret {
return ertr::make_ready_future<bool>(true);
}).handle_error(
class TMTestState : public EphemeralTestState {
protected:
- InterruptedTMRef tm;
+ TransactionManagerRef tm;
+ InterruptedTransactionManager itm;
LBAManager *lba_manager;
SegmentCleaner *segment_cleaner;
virtual void _init() {
tm = get_transaction_manager(*segment_manager);
+ itm = InterruptedTransactionManager(*tm);
segment_cleaner = tm->get_segment_cleaner();
lba_manager = tm->get_lba_manager();
}
virtual void _destroy() {
segment_cleaner = nullptr;
lba_manager = nullptr;
+ itm.reset();
tm.reset();
}
);
}
+ auto submit_transaction_fut(Transaction &t) {
+ return with_trans_intr(
+ t,
+ [this](auto &t) {
+ return tm->submit_transaction(t);
+ });
+ }
+
void submit_transaction(TransactionRef t) {
- tm->submit_transaction(*t).unsafe_get0();
+ submit_transaction_fut(*t).unsafe_get0();
segment_cleaner->run_until_halt().get0();
}
};