using mkfs_ret = mkfs_ertr::future<>;
virtual mkfs_ret mkfs(Transaction &t) = 0;
+ using contains_onode_ertr = base_ertr;
+ using contains_onode_ret = contains_onode_ertr::future<bool>;
+ virtual contains_onode_ret contains_onode(
+ Transaction &trans,
+ const ghobject_t &hoid) = 0;
+
using get_onode_ertr = base_ertr::extend<
crimson::ct_error::enoent>;
using get_onode_ret = get_onode_ertr::future<
Transaction &trans,
const std::vector<OnodeRef> &onodes) = 0;
+ using erase_onode_ertr = base_ertr;
+ using erase_onode_ret = erase_onode_ertr::future<>;
+ virtual erase_onode_ret erase_onode(
+ Transaction &trans,
+ OnodeRef &onode) = 0;
+
virtual ~OnodeManager() {}
};
using OnodeManagerRef = std::unique_ptr<OnodeManager>;
namespace crimson::os::seastore::onode {
+FLTreeOnodeManager::contains_onode_ret FLTreeOnodeManager::contains_onode(
+ Transaction &trans,
+ const ghobject_t &hoid)
+{
+ return tree.contains(
+ trans, hoid
+ ).handle_error(
+ contains_onode_ertr::pass_further{},
+ crimson::ct_error::assert_all{
+ "Invalid error in FLTreeOnodeManager::contains_onode"
+ }
+ );
+}
+
FLTreeOnodeManager::get_onode_ret FLTreeOnodeManager::get_onode(
Transaction &trans,
const ghobject_t &hoid)
);
}
+FLTreeOnodeManager::erase_onode_ret FLTreeOnodeManager::erase_onode(
+ Transaction &trans,
+ OnodeRef &onode)
+{
+ auto &flonode = static_cast<FLTreeOnode&>(*onode);
+ flonode.mark_delete();
+ return erase_onode_ertr::now();
+}
+
FLTreeOnodeManager::~FLTreeOnodeManager() {}
}
};
const onode_layout_t &get_layout() const final {
+ assert(status != status_t::DELETED);
return *read_payload<onode_layout_t>();
}
onode_layout_t &get_mutable_layout(Transaction &t) final {
+ assert(status != status_t::DELETED);
auto p = prepare_mutate_payload<
onode_layout_t,
Recorder>(t);
};
void populate_recorder(Transaction &t) {
+ assert(status == status_t::MUTATED);
auto p = prepare_mutate_payload<
onode_layout_t,
Recorder>(t);
status = status_t::STABLE;
}
+ void mark_delete() {
+ assert(status != status_t::DELETED);
+ status = status_t::DELETED;
+ }
+
~FLTreeOnode() final {}
};
);
}
+ contains_onode_ret contains_onode(
+ Transaction &trans,
+ const ghobject_t &hoid) final;
+
get_onode_ret get_onode(
Transaction &trans,
const ghobject_t &hoid) final;
Transaction &trans,
const std::vector<OnodeRef> &onodes) final;
+ erase_onode_ret erase_onode(
+ Transaction &trans,
+ OnodeRef &onode) final;
+
~FLTreeOnodeManager();
};
using FLTreeOnodeManagerRef = std::unique_ptr<FLTreeOnodeManager>;
});
}
+ void validate_erased(iterator_t& it) {
+ with_transaction([this, &it] (auto& t) {
+ auto p_kv = *it;
+ auto exist = manager->contains_onode(
+ t, p_kv->key).unsafe_get0();
+ ceph_assert(exist == false);
+ });
+ }
+
template <typename F>
void with_onodes_process(
iterator_t& start, iterator_t& end, F&& f) {
});
}
+ void validate_erased(
+ iterator_t& start, iterator_t& end) {
+ with_onodes_process(start, end,
+ [this] (auto& t, auto& oids, auto& items) {
+ for (auto& oid : oids) {
+ auto exist = manager->contains_onode(
+ t, oid).unsafe_get0();
+ ceph_assert(exist == false);
+ }
+ });
+ }
+
fltree_onode_manager_test_t() {}
};
item.modify(t, onode);
});
validate_onode(iter);
+
+ with_onode_write(iter, [this](auto& t, auto& onode, auto& item) {
+ OnodeRef onode_ref = &onode;
+ manager->erase_onode(t, onode_ref).unsafe_get0();
+ });
+ validate_erased(iter);
});
}
item.modify(t, onode);
});
validate_onodes(start, end);
+
+ pool.shuffle();
+ rd_start = pool.random_begin();
+ rd_end = rd_start + 50;
+ with_onodes_write(rd_start, rd_end,
+ [this](auto& t, auto& onode, auto& item) {
+ OnodeRef onode_ref = &onode;
+ manager->erase_onode(t, onode_ref).unsafe_get0();
+ });
+ validate_erased(rd_start, rd_end);
+ pool.erase_from_random(rd_start, rd_end);
+ start = pool.begin();
+ end = pool.end();
+ validate_onodes(start, end);
});
}