#include "crimson/os/seastore/onode_manager.h"
#include "crimson/os/seastore/object_data_handler.h"
-
-using std::string;
using crimson::common::local_conf;
template <> struct fmt::formatter<crimson::os::seastore::op_type_t>
return set_secondaries();
});
});
- }).safe_then([this] {
- return shard_stores.invoke_on_all([](auto &local_store) {
- return local_store.mount_managers();
- });
+ });
+ }).safe_then([this] {
+ return shard_stores.invoke_on_all([](auto &local_store) {
+ return local_store.mount_managers();
});
}).handle_error(
crimson::ct_error::assert_all{
auto [ret, fsid] = tuple;
std::string str_fsid = stringify(new_osd_fsid);
if (ret == -1) {
- return write_meta("fsid", stringify(new_osd_fsid));
+ return write_meta("fsid", stringify(new_osd_fsid));
} else if (ret == 0 && fsid != str_fsid) {
- ERROR("on-disk fsid {} != provided {}",
- fsid, stringify(new_osd_fsid));
- throw std::runtime_error("store fsid error");
- } else {
+ ERROR("on-disk fsid {} != provided {}",
+ fsid, stringify(new_osd_fsid));
+ throw std::runtime_error("store fsid error");
+ } else {
return seastar::now();
- }
- });
+ }
+ });
}
seastar::future<>
SeaStore::mkfs_ertr::future<> SeaStore::test_mkfs(uuid_d new_osd_fsid)
{
ceph_assert(seastar::this_shard_id() == primary_core);
- return read_meta("mkfs_done").then([this, new_osd_fsid] (auto tuple) {
+ return read_meta("mkfs_done"
+ ).then([this, new_osd_fsid](auto tuple) {
auto [done, value] = tuple;
if (done == 0) {
return seastar::now();
SeaStore::mkfs_ertr::future<> SeaStore::mkfs(uuid_d new_osd_fsid)
{
ceph_assert(seastar::this_shard_id() == primary_core);
- return read_meta("mkfs_done").then([this, new_osd_fsid] (auto tuple) {
+ return read_meta("mkfs_done"
+ ).then([this, new_osd_fsid](auto tuple) {
auto [done, value] = tuple;
if (done == 0) {
return seastar::now();
});
}
-using coll_core_t = FuturizedStore::coll_core_t;
+using coll_core_t = SeaStore::coll_core_t;
seastar::future<std::vector<coll_core_t>>
SeaStore::list_collections()
{
seastar::future<store_statfs_t> SeaStore::stat() const
{
- ceph_assert(seastar::this_shard_id() == primary_core);
LOG_PREFIX(SeaStore::stat);
DEBUG("");
+
+ ceph_assert(seastar::this_shard_id() == primary_core);
return shard_stores.map_reduce0(
[](const SeaStore::Shard &local_store) {
return local_store.stat();
seastar::stop_iteration
>(seastar::stop_iteration::no);
});
- }).si_then([&ret] {
- return list_iertr::make_ready_future<
- OnodeManager::list_onodes_bare_ret>(std::move(ret));
- });
+ }
+ ).si_then([&ret] {
+ return list_iertr::make_ready_future<
+ OnodeManager::list_onodes_bare_ret>(std::move(ret));
+ });
}
});
}).safe_then([&ret](auto&& _ret) {
{
LOG_PREFIX(SeaStore::open_collection);
DEBUG("{}", cid);
- return list_collections().then([cid, this] (auto colls_cores) {
+ return list_collections(
+ ).then([cid, this] (auto colls_cores) {
if (auto found = std::find(colls_cores.begin(),
colls_cores.end(),
std::make_pair(cid, seastar::this_shard_id()));
Transaction::src_t::READ,
"read_obj",
op_type_t::READ,
- [=, this](auto &t, auto &onode) -> ObjectDataHandler::read_ret {
+ [this, offset, len, op_flags](auto &t, auto &onode) -> ObjectDataHandler::read_ret {
size_t size = onode.get_layout().size;
if (offset >= size) {
return seastar::do_with(
_oid,
ceph::bufferlist{},
- [=, this, &m](auto &oid, auto &ret) {
+ [ch, op_flags, this, &m](auto &oid, auto &ret) {
return crimson::do_for_each(
m,
- [=, this, &oid, &ret](auto &p) {
+ [ch, op_flags, this, &oid, &ret](auto &p) {
return read(
ch, oid, p.first, p.second, op_flags
).safe_then([&ret](auto bl) {
(std::move(ret));
});
});
- return read_errorator::make_ready_future<ceph::bufferlist>();
}
using crimson::os::seastore::omap_manager::BtreeOMapManager;
const ghobject_t& oid,
std::string_view name) const
{
- auto c = static_cast<SeastoreCollection*>(ch.get());
LOG_PREFIX(SeaStore::get_attr);
- DEBUG("{} {}", c->get_cid(), oid);
+ DEBUG("{} {}", ch->get_cid(), oid);
++(shard_stats.read_num);
++(shard_stats.pending_read_num);
return repeat_with_onode<ceph::bufferlist>(
- c,
+ ch,
oid,
Transaction::src_t::READ,
"get_attr",
op_type_t::GET_ATTR,
- [=, this](auto &t, auto& onode) -> _omap_get_value_ret {
+ [this, name](auto &t, auto& onode) -> _omap_get_value_ret {
auto& layout = onode.get_layout();
if (name == OI_ATTR && layout.oi_size) {
ceph::bufferlist bl;
const ghobject_t& oid)
{
LOG_PREFIX(SeaStore::get_attrs);
- auto c = static_cast<SeastoreCollection*>(ch.get());
- DEBUG("{} {}", c->get_cid(), oid);
+ DEBUG("{} {}", ch->get_cid(), oid);
++(shard_stats.read_num);
++(shard_stats.pending_read_num);
return repeat_with_onode<attrs_t>(
- c,
+ ch,
oid,
Transaction::src_t::READ,
"get_addrs",
op_type_t::GET_ATTRS,
- [=, this](auto &t, auto& onode) {
+ [this](auto &t, auto& onode) {
auto& layout = onode.get_layout();
return omap_list(onode, layout.xattr_root, t, std::nullopt,
OMapManager::omap_list_config_t()
attrs.emplace(SS_ATTR, std::move(bl));
DEBUGT("set ss from onode layout", t);
}
- return seastar::make_ready_future<omap_values_t>(std::move(attrs));
+ return seastar::make_ready_future<attrs_t>(std::move(attrs));
});
}
).handle_error(
Transaction::src_t::READ,
"stat",
op_type_t::STAT,
- [=, this](auto &t, auto &onode) {
+ [this, oid](auto &t, auto &onode) {
struct stat st;
auto &olayout = onode.get_layout();
st.st_size = olayout.size;
++(shard_stats.read_num);
++(shard_stats.pending_read_num);
- auto c = static_cast<SeastoreCollection*>(ch.get());
return repeat_with_onode<omap_values_t>(
- c,
+ ch,
oid,
Transaction::src_t::READ,
"omap_get_values",
std::move(root),
std::string(key),
[&t](auto &manager, auto& root, auto& key) -> _omap_get_value_ret {
- if (root.is_null()) {
+ if (root.is_null()) {
+ return crimson::ct_error::enodata::make();
+ }
+ return manager.omap_get_value(root, t, key
+ ).si_then([](auto opt) -> _omap_get_value_ret {
+ if (!opt) {
return crimson::ct_error::enodata::make();
}
- return manager.omap_get_value(root, t, key
- ).si_then([](auto opt) -> _omap_get_value_ret {
- if (!opt) {
- return crimson::ct_error::enodata::make();
- }
- return seastar::make_ready_future<ceph::bufferlist>(std::move(*opt));
- });
- }
- );
+ return seastar::make_ready_future<ceph::bufferlist>(std::move(*opt));
+ });
+ });
}
-SeaStore::Shard::_omap_get_values_ret
+SeaStore::base_iertr::future<SeaStore::Shard::omap_values_t>
SeaStore::Shard::_omap_get_values(
Transaction &t,
omap_root_t &&omap_root,
BtreeOMapManager(*transaction_manager),
std::move(omap_root),
omap_values_t(),
- [&](auto &manager, auto &root, auto &ret) {
- return trans_intr::do_for_each(
- keys.begin(),
- keys.end(),
- [&](auto &key) {
- return manager.omap_get_value(
- root,
- t,
- key
- ).si_then([&ret, &key](auto &&p) {
- if (p) {
- bufferlist bl;
- bl.append(*p);
- ret.emplace(
- std::move(key),
- std::move(bl));
- }
- return seastar::now();
- });
+ [&t, &keys](auto &manager, auto &root, auto &ret) {
+ return trans_intr::do_for_each(
+ keys.begin(),
+ keys.end(),
+ [&t, &manager, &root, &ret](auto &key) {
+ return manager.omap_get_value(
+ root,
+ t,
+ key
+ ).si_then([&ret, &key](auto &&p) {
+ if (p) {
+ bufferlist bl;
+ bl.append(*p);
+ ret.emplace(
+ std::move(key),
+ std::move(bl));
}
- ).si_then([&ret] {
- return std::move(ret);
+ return seastar::now();
});
- }
- );
+ }).si_then([&ret] {
+ return std::move(ret);
+ });
+ });
}
SeaStore::Shard::omap_list_ret
});
}
-SeaStore::Shard::omap_get_values_ret_t
+SeaStore::Shard::read_errorator::future<SeaStore::Shard::omap_values_paged_t>
SeaStore::Shard::omap_get_values(
CollectionRef ch,
const ghobject_t &oid,
- const std::optional<string> &start)
+ const std::optional<std::string> &start)
{
- auto c = static_cast<SeastoreCollection*>(ch.get());
LOG_PREFIX(SeaStore::omap_get_values);
- DEBUG("{} {}", c->get_cid(), oid);
+ DEBUG("{} {}", ch->get_cid(), oid);
++(shard_stats.read_num);
++(shard_stats.pending_read_num);
- using ret_bare_t = std::tuple<bool, SeaStore::Shard::omap_values_t>;
- return repeat_with_onode<ret_bare_t>(
- c,
+ return repeat_with_onode<omap_values_paged_t>(
+ ch,
oid,
Transaction::src_t::READ,
"omap_list",
});
}
-SeaStore::Shard::_fiemap_ret SeaStore::Shard::_fiemap(
+SeaStore::base_iertr::future<SeaStore::Shard::fiemap_ret_t>
+SeaStore::Shard::_fiemap(
Transaction &t,
Onode &onode,
uint64_t off,
{
return seastar::do_with(
ObjectDataHandler(max_object_size),
- [=, this, &t, &onode] (auto &objhandler) {
+ [this, off, len, &t, &onode](auto &objhandler) {
return objhandler.fiemap(
ObjectDataHandler::context_t{
*transaction_manager,
});
}
-SeaStore::Shard::read_errorator::future<std::map<uint64_t, uint64_t>>
+SeaStore::Shard::read_errorator::future<SeaStore::Shard::fiemap_ret_t>
SeaStore::Shard::fiemap(
CollectionRef ch,
const ghobject_t& oid,
++(shard_stats.read_num);
++(shard_stats.pending_read_num);
- return repeat_with_onode<std::map<uint64_t, uint64_t>>(
+ return repeat_with_onode<fiemap_ret_t>(
ch,
oid,
Transaction::src_t::READ,
"fiemap_read",
op_type_t::READ,
- [=, this](auto &t, auto &onode) -> _fiemap_ret {
+ [this, off, len](auto &t, auto &onode) -> base_iertr::future<fiemap_ret_t> {
size_t size = onode.get_layout().size;
if (off >= size) {
INFOT("fiemap offset is over onode size!", t);
"do_transaction",
op_type_t::TRANSACTION,
[this](auto &ctx) {
- return with_trans_intr(*ctx.transaction, [&, this](auto &t) {
+ return with_trans_intr(*ctx.transaction, [&ctx, this](auto &t) {
LOG_PREFIX(SeaStore::Shard::do_transaction_no_callbacks);
SUBDEBUGT(seastore_t, "start with {} objects",
t, ctx.iter.objects.size());
SUBTRACET(seastore_t, "got op {}", *ctx.transaction, (uint32_t)op->op);
using ceph::os::Transaction;
- if (op->op == Transaction::OP_NOP)
+ if (op->op == Transaction::OP_NOP) {
return tm_iertr::now();
+ }
switch (op->op) {
case Transaction::OP_RMCOLL:
create = true;
}
if (!onodes[op->oid]) {
+ const ghobject_t& oid = i.get_oid(op->oid);
if (!create) {
- fut = onode_manager->get_onode(*ctx.transaction, i.get_oid(op->oid));
+ fut = onode_manager->get_onode(*ctx.transaction, oid);
} else {
- fut = onode_manager->get_or_create_onode(
- *ctx.transaction, i.get_oid(op->oid));
+ fut = onode_manager->get_or_create_onode(*ctx.transaction, oid);
}
}
- return fut.si_then([&, op](auto get_onode) {
+ return fut.si_then([&, op, this](auto get_onode) {
OnodeRef &o = onodes[op->oid];
if (!o) {
assert(get_onode);
// support parallel extents loading
return onode_manager->get_or_create_onode(
*ctx.transaction, i.get_oid(op->dest_oid)
- ).si_then([&, op](auto dest_onode) {
+ ).si_then([&onodes, &d_onodes, op](auto dest_onode) {
assert(dest_onode);
auto &d_o = onodes[op->dest_oid];
assert(!d_o);
} else {
return OnodeManager::get_or_create_onode_iertr::now();
}
- }).si_then([&, op, this]() -> tm_ret {
+ }).si_then([&ctx, &i, &onodes, &d_onodes, op, this, FNAME]() -> tm_ret {
LOG_PREFIX(SeaStore::_do_transaction_step);
try {
switch (op->op) {
{
LOG_PREFIX(SeaStore::_omap_clear);
DEBUGT("{} {} keys", *ctx.transaction, *onode);
- return _xattr_rmattr(ctx, onode, std::string(OMAP_HEADER_XATTR_KEY))
- .si_then([this, &ctx, &onode]() -> tm_ret {
+ return _xattr_rmattr(ctx, onode, std::string(OMAP_HEADER_XATTR_KEY)
+ ).si_then([this, &ctx, &onode]() -> tm_ret {
if (auto omap_root = onode->get_layout().omap_root.get(
onode->get_metadata_hint(device->get_block_size()));
omap_root.is_null()) {
auto &omap_root) {
return omap_manager.omap_clear(
omap_root,
- *ctx.transaction)
- .si_then([&] {
+ *ctx.transaction
+ ).si_then([&] {
if (omap_root.must_update()) {
onode->update_omap_root(*ctx.transaction, omap_root);
}
return new SeastoreCollection{cid};
}
+seastar::future<> SeaStore::write_meta(
+ const std::string& key,
+ const std::string& value) {
+ ceph_assert(seastar::this_shard_id() == primary_core);
+ return seastar::do_with(key, value,
+ [this](auto& key, auto& value) {
+ return shard_stores.local().write_meta(key, value
+ ).then([this, &key, &value] {
+ return mdstore->write_meta(key, value);
+ }).handle_error(
+ crimson::ct_error::assert_all{"Invalid error in SeaStore::write_meta"}
+ );
+ });
+}
+
seastar::future<> SeaStore::Shard::write_meta(
const std::string& key,
const std::string& value)
// For TM::submit_transaction()
++(shard_stats.processing_inlock_io_num);
- return seastar::do_with(
- key, value,
- [this, FNAME](auto& key, auto& value) {
- return repeat_eagain([this, FNAME, &key, &value] {
- ++(shard_stats.repeat_io_num);
-
- return transaction_manager->with_transaction_intr(
- Transaction::src_t::MUTATE,
- "write_meta",
- [this, FNAME, &key, &value](auto& t)
- {
- DEBUGT("Have transaction, key: {}; value: {}", t, key, value);
- return transaction_manager->update_root_meta(
- t, key, value
- ).si_then([this, &t] {
- return transaction_manager->submit_transaction(t);
- });
- });
- });
- }
- ).handle_error(
+ return repeat_eagain([this, FNAME, &key, &value] {
+ ++(shard_stats.repeat_io_num);
+
+ return transaction_manager->with_transaction_intr(
+ Transaction::src_t::MUTATE,
+ "write_meta",
+ [this, FNAME, &key, &value](auto& t)
+ {
+ DEBUGT("Have transaction, key: {}; value: {}", t, key, value);
+ return transaction_manager->update_root_meta(
+ t, key, value
+ ).si_then([this, &t] {
+ return transaction_manager->submit_transaction(t);
+ });
+ });
+ }).handle_error(
crimson::ct_error::assert_all{"Invalid error in SeaStore::write_meta"}
).finally([this] {
assert(shard_stats.pending_io_num);
seastar::future<std::tuple<int, std::string>>
SeaStore::read_meta(const std::string& key)
{
- ceph_assert(seastar::this_shard_id() == primary_core);
LOG_PREFIX(SeaStore::read_meta);
DEBUG("key: {}", key);
- return mdstore->read_meta(key).safe_then([](auto v) {
+ ceph_assert(seastar::this_shard_id() == primary_core);
+ return mdstore->read_meta(key
+ ).safe_then([](auto v) {
if (v) {
return std::make_tuple(0, std::move(*v));
} else {
class SeaStore final : public FuturizedStore {
public:
+ using base_ertr = TransactionManager::base_ertr;
+ using base_iertr = TransactionManager::base_iertr;
+
class MDStore {
public:
- using base_iertr = crimson::errorator<
- crimson::ct_error::input_output_error
- >;
-
- using write_meta_ertr = base_iertr;
+ using write_meta_ertr = base_ertr;
using write_meta_ret = write_meta_ertr::future<>;
virtual write_meta_ret write_meta(
const std::string &key,
const std::string &val
) = 0;
- using read_meta_ertr = base_iertr;
+ using read_meta_ertr = base_ertr;
using read_meta_ret = write_meta_ertr::future<std::optional<std::string>>;
virtual read_meta_ret read_meta(const std::string &key) = 0;
const omap_keys_t& keys) final;
/// Retrieves paged set of values > start (if present)
- using omap_get_values_ret_bare_t = std::tuple<bool, omap_values_t>;
- using omap_get_values_ret_t = read_errorator::future<
- omap_get_values_ret_bare_t>;
- omap_get_values_ret_t omap_get_values(
+ read_errorator::future<omap_values_paged_t> omap_get_values(
CollectionRef c, ///< [in] collection
const ghobject_t &oid, ///< [in] oid
const std::optional<std::string> &start ///< [in] start, empty for begin
* stages and locks as do_transaction. */
seastar::future<> flush(CollectionRef ch) final;
- read_errorator::future<std::map<uint64_t, uint64_t>> fiemap(
+ read_errorator::future<fiemap_ret_t> fiemap(
CollectionRef ch,
const ghobject_t& oid,
uint64_t off,
secondaries.emplace_back(&sec_dev);
}
- using coll_core_t = FuturizedStore::coll_core_t;
seastar::future<std::vector<coll_core_t>> list_collections();
seastar::future<> write_meta(const std::string& key,
});
}
- using _fiemap_ret = ObjectDataHandler::fiemap_ret;
- _fiemap_ret _fiemap(
- Transaction &t,
- Onode &onode,
- uint64_t off,
- uint64_t len) const;
+ using omap_list_bare_ret = OMapManager::omap_list_bare_ret;
+ using omap_list_ret = OMapManager::omap_list_ret;
+ omap_list_ret omap_list(
+ Onode& onode,
+ const omap_root_le_t& omap_root,
+ Transaction& t,
+ const std::optional<std::string>& start,
+ OMapManager::omap_list_config_t config) const;
- using _omap_get_value_iertr = OMapManager::base_iertr::extend<
+ using _omap_get_value_iertr = base_iertr::extend<
crimson::ct_error::enodata
>;
using _omap_get_value_ret = _omap_get_value_iertr::future<ceph::bufferlist>;
omap_root_t &&root,
std::string_view key) const;
- using _omap_get_values_iertr = OMapManager::base_iertr;
- using _omap_get_values_ret = _omap_get_values_iertr::future<omap_values_t>;
- _omap_get_values_ret _omap_get_values(
+ base_iertr::future<omap_values_t> _omap_get_values(
Transaction &t,
omap_root_t &&root,
const omap_keys_t &keys) const;
friend class SeaStoreOmapIterator;
- using omap_list_bare_ret = OMapManager::omap_list_bare_ret;
- using omap_list_ret = OMapManager::omap_list_ret;
- omap_list_ret omap_list(
+ base_iertr::future<fiemap_ret_t> _fiemap(
+ Transaction &t,
Onode &onode,
- const omap_root_le_t& omap_root,
- Transaction& t,
- const std::optional<std::string>& start,
- OMapManager::omap_list_config_t config) const;
+ uint64_t off,
+ uint64_t len) const;
- using tm_iertr = TransactionManager::base_iertr;
+ using tm_iertr = base_iertr;
using tm_ret = tm_iertr::future<>;
tm_ret _do_transaction_step(
internal_context_t &ctx,
return shard_stores.local().get_fsid();
}
- seastar::future<> write_meta(
- const std::string& key,
- const std::string& value) final {
- ceph_assert(seastar::this_shard_id() == primary_core);
- return shard_stores.local().write_meta(
- key, value).then([this, key, value] {
- return mdstore->write_meta(key, value);
- }).handle_error(
- crimson::ct_error::assert_all{"Invalid error in SeaStore::write_meta"}
- );
- }
+ seastar::future<> write_meta(const std::string& key, const std::string& value) final;
seastar::future<std::tuple<int, std::string>> read_meta(const std::string& key) final;
projects / ceph.git / commitdiff