#define DEBUG(...) LOG(debug, __VA_ARGS__)
#define DEBUGT(...) LOGT(debug, __VA_ARGS__)
+#define INFO(...) LOG(info, __VA_ARGS__)
+#define INFOT(...) LOGT(info, __VA_ARGS__)
+
#define WARN(...) LOG(warn, __VA_ARGS__)
#define WARNT(...) LOGT(warn, __VA_ARGS__)
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
// vim: ts=8 sw=2 smarttab
+#include "crimson/os/seastore/logging.h"
+
#include "crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.h"
#include "crimson/os/seastore/onode_manager/staged-fltree/stages/key_layout.h"
-namespace {
-[[maybe_unused]] seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_test);
-}
-}
-
namespace crimson::os::seastore::onode {
FLTreeOnodeManager::contains_onode_ret FLTreeOnodeManager::contains_onode(
Transaction &trans,
const ghobject_t &hoid)
{
+ LOG_PREFIX(FLTreeOnodeManager::get_onode);
return tree.find(
trans, hoid
- ).safe_then([this, &hoid](auto cursor)
+ ).safe_then([this, &hoid, &trans, FNAME](auto cursor)
-> get_onode_ret {
if (cursor == tree.end()) {
- logger().debug(
- "FLTreeOnodeManager::{}: no entry for {}",
- __func__,
- hoid);
+ DEBUGT("no entry for {}", trans, hoid);
return crimson::ct_error::enoent::make();
}
auto val = OnodeRef(new FLTreeOnode(cursor.value()));
Transaction &trans,
const ghobject_t &hoid)
{
+ LOG_PREFIX(FLTreeOnodeManager::get_or_create_onode);
if (hoid.hobj.oid.name.length() + hoid.hobj.nspace.length()
> key_view_t::MAX_NS_OID_LENGTH) {
return crimson::ct_error::value_too_large::make();
return tree.insert(
trans, hoid,
OnodeTree::tree_value_config_t{sizeof(onode_layout_t)}
- ).safe_then([&trans, &hoid](auto p)
+ ).safe_then([&trans, &hoid, FNAME](auto p)
-> get_or_create_onode_ret {
auto [cursor, created] = std::move(p);
auto val = OnodeRef(new FLTreeOnode(cursor.value()));
if (created) {
- logger().debug(
- "FLTreeOnodeManager::{}: created onode for entry for {}",
- __func__,
- hoid);
+ DEBUGT("created onode for entry for {}", trans, hoid);
val->get_mutable_layout(trans) = onode_layout_t{};
}
return seastar::make_ready_future<OnodeRef>(
#include <sstream>
#include "common/likely.h"
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
#include "node_extent_manager.h"
#include "node_impl.h"
#include "stages/node_stage_layout.h"
-namespace {
-
-seastar::logger& logger()
-{
- return crimson::get_logger(ceph_subsys_filestore);
-}
-
-}
-
namespace crimson::os::seastore::onode {
using node_ertr = Node::node_ertr;
node_future<> Node::mkfs(context_t c, RootNodeTracker& root_tracker)
{
+ LOG_PREFIX(OTree::Node::mkfs);
return LeafNode::allocate_root(c, root_tracker
- ).safe_then([](auto ret) {
- logger().info("OTree::Node::Mkfs: allocated root {}",
- ret->get_name());
+ ).safe_then([c, FNAME](auto ret) {
+ INFOT("allocated root {}", c.t, ret->get_name());
});
}
node_future<Ref<Node>> Node::load_root(context_t c, RootNodeTracker& root_tracker)
{
+ LOG_PREFIX(OTree::Node::load_root);
return c.nm.get_super(c.t, root_tracker
- ).safe_then([c, &root_tracker](auto&& _super) {
+ ).safe_then([c, &root_tracker, FNAME](auto&& _super) {
auto root_addr = _super->get_root_laddr();
assert(root_addr != L_ADDR_NULL);
return Node::load(c, root_addr, true
).safe_then([c, _super = std::move(_super),
- &root_tracker](auto root) mutable {
- logger().trace("OTree::Node::LoadRoot: loaded {}",
- root->get_name());
+ &root_tracker, FNAME](auto root) mutable {
+ TRACET("loaded {}", c.t, root->get_name());
assert(root->impl->field_type() == field_type_t::N0);
root->as_root(std::move(_super));
std::ignore = c; // as only used in an assert
node_future<> Node::upgrade_root(context_t c)
{
+ LOG_PREFIX(OTree::Node::upgrade_root);
assert(is_root());
assert(impl->is_level_tail());
assert(impl->field_type() == field_type_t::N0);
super->do_untrack_root(*this);
return InternalNode::allocate_root(c, impl->level(), impl->laddr(), std::move(super)
- ).safe_then([this](auto new_root) {
+ ).safe_then([this, c, FNAME](auto new_root) {
as_child(search_position_t::end(), new_root);
- logger().info("OTree::Node::UpgradeRoot: upgraded from {} to {}",
- get_name(), new_root->get_name());
+ INFOT("upgraded from {} to {}",
+ c.t, get_name(), new_root->get_name());
});
}
Node::try_merge_adjacent(
context_t c, bool update_parent_index, Ref<Node>&& this_ref)
{
+ LOG_PREFIX(OTree::Node::try_merge_adjacent);
assert(this == this_ref.get());
impl->validate_non_empty();
assert(!is_root());
}
return parent_info().ptr->get_child_peers(c, parent_info().position
- ).safe_then([c, this_ref = std::move(this_ref), this,
+ ).safe_then([c, this_ref = std::move(this_ref), this, FNAME,
update_parent_index] (auto lr_nodes) mutable -> node_future<> {
auto& [lnode, rnode] = lr_nodes;
Ref<Node> left_for_merge;
} else {
update_index_after_merge = update_parent_index;
}
- logger().info("OTree::Node::MergeAdjacent: merge {} and {} "
- "at merge_stage={}, merge_size={}B, update_index={}, is_left={} ...",
- left_for_merge->get_name(), right_for_merge->get_name(),
- merge_stage, merge_size, update_index_after_merge, is_left);
+ INFOT("merge {} and {} at merge_stage={}, merge_size={}B, "
+ "update_index={}, is_left={} ...",
+ c.t, left_for_merge->get_name(), right_for_merge->get_name(),
+ merge_stage, merge_size, update_index_after_merge, is_left);
// we currently cannot generate delta depends on another extent content,
// so use rebuild_extent() as a workaround to rebuild the node from a
// fresh extent, thus no need to generate delta.
node_future<NodeExtentMutable> Node::rebuild_extent(context_t c)
{
- logger().debug("OTree::Node::Rebuild: {} ...", get_name());
+ LOG_PREFIX(OTree::Node::rebuild_extent);
+ DEBUGT("{} ...", c.t, get_name());
assert(!is_root());
// assume I'm already ref counted by caller
node_future<> Node::retire(context_t c, Ref<Node>&& this_ref)
{
- logger().debug("OTree::Node::Retire: {} ...", get_name());
+ LOG_PREFIX(OTree::Node::retire);
+ DEBUGT("{} ...", c.t, get_name());
assert(this_ref.get() == this);
assert(!is_tracking());
assert(!super);
void Node::make_tail(context_t c)
{
+ LOG_PREFIX(OTree::Node::make_tail);
assert(!impl->is_level_tail());
assert(!impl->is_keys_empty());
- logger().debug("OTree::Node::MakeTail: {} ...", get_name());
+ DEBUGT("{} ...", c.t, get_name());
impl->prepare_mutate(c);
auto tail_pos = impl->make_tail();
if (impl->node_type() == node_type_t::INTERNAL) {
context_t c, Ref<Node>&& left_child, Ref<Node>&& right_child,
bool update_right_index)
{
+ LOG_PREFIX(OTree::InternalNode::apply_child_split);
auto& left_pos = left_child->parent_info().position;
#ifndef NDEBUG
impl->prepare_mutate(c);
- logger().debug("OTree::Internal::ApplyChildSplit: apply {}'s child "
- "{} to split to {}, update_index={} ...",
- get_name(), left_child->get_name(),
- right_child->get_name(), update_right_index);
+ DEBUGT("apply {}'s child {} to split to {}, update_index={} ...",
+ c.t, get_name(), left_child->get_name(),
+ right_child->get_name(), update_right_index);
// update layout from left_pos => left_child_addr to right_child_addr
auto left_child_addr = left_child->impl->laddr();
node_future<> InternalNode::erase_child(context_t c, Ref<Node>&& child_ref)
{
+ LOG_PREFIX(OTree::InternalNode::erase_child);
// this is a special version of recursive merge
impl->validate_non_empty();
assert(child_ref->use_count() == 1);
} else {
return node_ertr::make_ready_future<Ref<Node>>();
}
- }).safe_then([c, this, child_ref = std::move(child_ref)]
+ }).safe_then([c, this, child_ref = std::move(child_ref), FNAME]
(auto&& new_tail_child) mutable {
auto child_pos = child_ref->parent_info().position;
if (new_tail_child) {
- logger().info("OTree::Internal::EraseChild: erase {}'s child {} at pos({}), "
- "and fix new child tail {} at pos({}) ...",
- get_name(), child_ref->get_name(), child_pos,
- new_tail_child->get_name(),
- new_tail_child->parent_info().position);
+ INFOT("erase {}'s child {} at pos({}), "
+ "and fix new child tail {} at pos({}) ...",
+ c.t, get_name(), child_ref->get_name(), child_pos,
+ new_tail_child->get_name(), new_tail_child->parent_info().position);
assert(!new_tail_child->impl->is_level_tail());
new_tail_child->make_tail(c);
assert(new_tail_child->impl->is_level_tail());
new_tail_child.reset();
}
} else {
- logger().info("OTree::Internal::EraseChild: erase {}'s child {} at pos({}) ...",
- get_name(), child_ref->get_name(), child_pos);
+ INFOT("erase {}'s child {} at pos({}) ...",
+ c.t, get_name(), child_ref->get_name(), child_pos);
}
do_untrack_child(*child_ref);
Ref<Node> this_ref = this;
child_ref->_parent_info.reset();
return child_ref->retire(c, std::move(child_ref)
- ).safe_then([c, this, child_pos, this_ref = std::move(this_ref)] () mutable {
+ ).safe_then([c, this, child_pos, FNAME,
+ this_ref = std::move(this_ref)] () mutable {
if ((impl->is_level_tail() && impl->is_keys_empty()) ||
(!impl->is_level_tail() && impl->is_keys_one())) {
// there is only one value left
// fast path without mutating the extent
- logger().debug("OTree::Internal::EraseChild: {} has one value left, erase ...",
- get_name());
+ DEBUGT("{} has one value left, erase ...", c.t, get_name());
#ifndef NDEBUG
if (impl->is_level_tail()) {
assert(child_pos.is_end());
node_future<> InternalNode::fix_index(
context_t c, Ref<Node>&& child, bool check_downgrade)
{
+ LOG_PREFIX(OTree::InternalNode::fix_index);
impl->validate_non_empty();
auto& child_pos = child->parent_info().position;
impl->prepare_mutate(c);
key_view_t new_key = *child->impl->get_pivot_index();
- logger().debug("OTree::Internal::FixIndex: fix {}'s index of child {} at pos({}), "
- "new_key={} ...",
- get_name(), child->get_name(), child_pos, new_key);
+ DEBUGT("fix {}'s index of child {} at pos({}), new_key={} ...",
+ c.t, get_name(), child->get_name(), child_pos, new_key);
// erase the incorrect item
auto [erase_stage, next_pos] = impl->erase(child_pos);
context_t c, Ref<Node>&& left_child, laddr_t origin_left_addr,
Ref<Node>&& right_child, bool update_index)
{
+ LOG_PREFIX(OTree::InternalNode::apply_children_merge);
auto left_pos = left_child->parent_info().position;
auto left_addr = left_child->impl->laddr();
auto& right_pos = right_child->parent_info().position;
auto right_addr = right_child->impl->laddr();
- logger().debug("OTree::Internal::ApplyChildMerge: apply {}'s child {} (was {:#x}) "
- "at pos({}), to merge with {} at pos({}), update_index={} ...",
- get_name(), left_child->get_name(), origin_left_addr, left_pos,
- right_child->get_name(), right_pos, update_index);
+ DEBUGT("apply {}'s child {} (was {:#x}) at pos({}), "
+ "to merge with {} at pos({}), update_index={} ...",
+ c.t, get_name(), left_child->get_name(), origin_left_addr, left_pos,
+ right_child->get_name(), right_pos, update_index);
#ifndef NDEBUG
assert(left_child->parent_info().ptr == this);
node_future<> InternalNode::try_downgrade_root(
context_t c, Ref<Node>&& this_ref)
{
+ LOG_PREFIX(OTree::InternalNode::try_downgrade_root);
assert(this_ref.get() == this);
assert(is_root());
assert(impl->is_level_tail());
// proceed downgrade root to the only child
laddr_t child_addr = impl->get_tail_value()->value;
return get_or_track_child(c, search_position_t::end(), child_addr
- ).safe_then([c, this, this_ref = std::move(this_ref)] (auto child) mutable {
- logger().info("OTree::Internal::DownGradeRoot: downgrade {} to new root {}",
- get_name(), child->get_name());
+ ).safe_then([c, this, FNAME,
+ this_ref = std::move(this_ref)] (auto child) mutable {
+ INFOT("downgrade {} to new root {}",
+ c.t, get_name(), child->get_name());
// Invariant, see InternalNode::erase_child()
// the new internal root should have at least 2 children.
assert(child->impl->is_level_tail());
Ref<Node> insert_child,
Ref<Node> outdated_child)
{
+ LOG_PREFIX(OTree::InternalNode::insert_or_split);
// XXX: check the insert_child is unlinked from this node
#ifndef NDEBUG
auto _insert_key = *insert_child->impl->get_pivot_index();
#endif
auto insert_value = insert_child->impl->laddr();
auto insert_pos = pos;
- logger().debug("OTree::Internal::InsertSplit: insert {} "
- "with insert_key={}, insert_child={}, insert_pos({}), "
- "outdated_child={} ...",
- get_name(), insert_key, insert_child->get_name(),
- insert_pos, (outdated_child ? "True" : "False"));
+ DEBUGT("insert {} with insert_key={}, insert_child={}, insert_pos({}), "
+ "outdated_child={} ...",
+ c.t, get_name(), insert_key, insert_child->get_name(),
+ insert_pos, (outdated_child ? "True" : "False"));
auto [insert_stage, insert_size] = impl->evaluate_insert(
insert_key, insert_value, insert_pos);
auto free_size = impl->free_size();
c, impl->field_type(), impl->is_level_tail(), impl->level());
}).safe_then([this, insert_key, insert_child, insert_pos,
insert_stage=insert_stage, insert_size=insert_size,
- outdated_child](auto fresh_right) mutable {
+ outdated_child, c, FNAME](auto fresh_right) mutable {
// I'm the left_node and need to split into the right_node
auto right_node = fresh_right.node;
- logger().info("OTree::Internal::InsertSplit: proceed split {} to fresh {} "
- "with insert_child={}, outdated_child={} ...",
- get_name(), right_node->get_name(),
- insert_child->get_name(),
- (outdated_child ? outdated_child->get_name() : "N/A"));
+ INFOT("proceed split {} to fresh {} with insert_child={},"
+ " outdated_child={} ...",
+ c.t, get_name(), right_node->get_name(),
+ insert_child->get_name(),
+ (outdated_child ? outdated_child->get_name() : "N/A"));
auto insert_value = insert_child->impl->laddr();
auto [split_pos, is_insert_left, p_value] = impl->split_insert(
fresh_right.mut, *right_node->impl, insert_key, insert_value,
node_future<Ref<Node>> InternalNode::get_or_track_child(
context_t c, const search_position_t& position, laddr_t child_addr)
{
+ LOG_PREFIX(OTree::InternalNode::get_or_track_child);
bool level_tail = position.is_end();
Ref<Node> child;
auto found = tracked_child_nodes.find(position);
Ref<Node> this_ref = this;
return (found == tracked_child_nodes.end()
? (Node::load(c, child_addr, level_tail
- ).safe_then([this, position] (auto child) {
+ ).safe_then([this, position, c, FNAME] (auto child) {
child->as_child(position, this);
- logger().trace("OTree::Internal::GetTrackChild: loaded child untracked {} at pos({})",
- child->get_name(), position);
+ TRACET("loaded child untracked {} at pos({})",
+ c.t, child->get_name(), position);
return child;
}))
- : (logger().trace("OTree::Internal::GetTrackChild: loaded child tracked {} at pos({})",
- found->second->get_name(), position),
+ : (TRACET("loaded child tracked {} at pos({})",
+ c.t, found->second->get_name(), position),
node_ertr::make_ready_future<Ref<Node>>(found->second))
).safe_then([this_ref, this, position, child_addr] (auto child) {
assert(child_addr == child->impl->laddr());
node_future<Ref<tree_cursor_t>>
LeafNode::erase(context_t c, const search_position_t& pos, bool get_next)
{
+ LOG_PREFIX(OTree::LeafNode::erase);
assert(!pos.is_end());
assert(!impl->is_keys_empty());
Ref<Node> this_ref = this;
- logger().debug("OTree::Leaf::Erase: erase {}'s pos({}), get_next={} ...",
- get_name(), pos, get_next);
+ DEBUGT("erase {}'s pos({}), get_next={} ...",
+ c.t, get_name(), pos, get_next);
// get the next cursor
return node_ertr::now().safe_then([c, &pos, get_next, this] {
return node_ertr::make_ready_future<Ref<tree_cursor_t>>();
}
}).safe_then([c, &pos, this_ref = std::move(this_ref),
- this] (Ref<tree_cursor_t> next_cursor) {
+ this, FNAME] (Ref<tree_cursor_t> next_cursor) {
if (next_cursor && next_cursor->is_end()) {
// reset the node reference from the end cursor
next_cursor.reset();
}
return node_ertr::now(
- ).safe_then([c, &pos, this_ref = std::move(this_ref), this] () mutable {
+ ).safe_then([c, &pos, this_ref = std::move(this_ref),
+ this, FNAME] () mutable {
#ifndef NDEBUG
assert(!impl->is_keys_empty());
if (impl->is_keys_one()) {
// we need to keep the root as an empty leaf node
// fast path without mutating the extent
// track_erase
- logger().debug("OTree::Leaf::Erase: {} has one value left, erase ...",
- get_name());
+ DEBUGT("{} has one value left, erase ...", c.t, get_name());
assert(tracked_cursors.size() == 1);
auto iter = tracked_cursors.begin();
assert(iter->first == pos);
const search_position_t& pos, const MatchHistory& history,
match_stat_t mstat)
{
+ LOG_PREFIX(OTree::LeafNode::insert_value);
#ifndef NDEBUG
if (pos.is_end()) {
assert(impl->is_level_tail());
}
#endif
- logger().debug("OTree::Leaf::InsertValue: insert {} "
- "with insert_key={}, insert_value={}, insert_pos({}), "
- "history={}, mstat({}) ...",
- get_name(), key, vconf, pos, history, mstat);
+ DEBUGT("insert {} with insert_key={}, insert_value={}, insert_pos({}), "
+ "history={}, mstat({}) ...",
+ c.t, get_name(), key, vconf, pos, history, mstat);
search_position_t insert_pos = pos;
auto [insert_stage, insert_size] = impl->evaluate_insert(
key, vconf, history, mstat, insert_pos);
return (is_root() ? upgrade_root(c) : node_ertr::now()
).safe_then([this, c] {
return LeafNode::allocate(c, impl->field_type(), impl->is_level_tail());
- }).safe_then([this_ref = std::move(this_ref), this, c, &key, vconf,
+ }).safe_then([this_ref = std::move(this_ref), this, c, &key, vconf, FNAME,
insert_pos, insert_stage=insert_stage, insert_size=insert_size](auto fresh_right) mutable {
auto right_node = fresh_right.node;
- logger().info("OTree::Leaf::InsertValue: proceed split {} to fresh {} ...",
- get_name(), right_node->get_name());
+ INFOT("proceed split {} to fresh {} ...",
+ c.t, get_name(), right_node->get_name());
// no need to bump version for right node, as it is fresh
on_layout_change();
impl->prepare_mutate(c);
#pragma once
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
#include "node_extent_manager.h"
#include "node_delta_recorder.h"
#include "node_layout_replayable.h"
void apply_delta(ceph::bufferlist::const_iterator& delta,
NodeExtentMutable& node,
laddr_t node_laddr) override {
+ LOG_PREFIX(OTree::Extent::Replay);
assert(is_empty());
node_stage_t stage(reinterpret_cast<const FieldType*>(node.get_read()));
node_delta_op_t op;
ceph::decode(op, delta);
switch (op) {
case node_delta_op_t::INSERT: {
- logger().debug("OTree::Extent::Replay: decoding INSERT ...");
+ DEBUG("decoding INSERT ...");
auto key = key_hobj_t::decode(delta);
auto value = decode_value(delta);
auto insert_pos = position_t::decode(delta);
ceph::decode(insert_stage, delta);
node_offset_t insert_size;
ceph::decode(insert_size, delta);
- logger().debug("OTree::Extent::Replay: apply {}, {}, "
- "insert_pos({}), insert_stage={}, insert_size={}B ...",
- key, value, insert_pos, insert_stage, insert_size);
+ DEBUG("apply {}, {}, insert_pos({}), insert_stage={}, "
+ "insert_size={}B ...",
+ key, value, insert_pos, insert_stage, insert_size);
layout_t::template insert<KeyT::HOBJ>(
node, stage, key, value, insert_pos, insert_stage, insert_size);
break;
}
case node_delta_op_t::SPLIT: {
- logger().debug("OTree::Extent::Replay: decoding SPLIT ...");
+ DEBUG("decoding SPLIT ...");
auto split_at = StagedIterator::decode(stage.p_start(), delta);
- logger().debug("OTree::Extent::Replay: apply split_at={} ...", split_at);
+ DEBUG("apply split_at={} ...", split_at);
layout_t::split(node, stage, split_at);
break;
}
case node_delta_op_t::SPLIT_INSERT: {
- logger().debug("OTree::Extent::Replay: decoding SPLIT_INSERT ...");
+ DEBUG("decoding SPLIT_INSERT ...");
auto split_at = StagedIterator::decode(stage.p_start(), delta);
auto key = key_hobj_t::decode(delta);
auto value = decode_value(delta);
ceph::decode(insert_stage, delta);
node_offset_t insert_size;
ceph::decode(insert_size, delta);
- logger().debug("OTree::Extent::Replay: apply split_at={}, {}, {}, "
- "insert_pos({}), insert_stage={}, insert_size={}B ...",
- split_at, key, value, insert_pos, insert_stage, insert_size);
+ DEBUG("apply split_at={}, {}, {}, insert_pos({}), insert_stage={}, "
+ "insert_size={}B ...",
+ split_at, key, value, insert_pos, insert_stage, insert_size);
layout_t::template split_insert<KeyT::HOBJ>(
node, stage, split_at, key, value, insert_pos, insert_stage, insert_size);
break;
}
case node_delta_op_t::UPDATE_CHILD_ADDR: {
- logger().debug("OTree::Extent::Replay: decoding UPDATE_CHILD_ADDR ...");
+ DEBUG("decoding UPDATE_CHILD_ADDR ...");
laddr_t new_addr;
ceph::decode(new_addr, delta);
node_offset_t update_offset;
ceph::decode(update_offset, delta);
auto p_addr = reinterpret_cast<laddr_packed_t*>(
node.get_write() + update_offset);
- logger().debug("OTree::Extent::Replay: apply {:#x} to offset {:#x} ...",
- new_addr, update_offset);
+ DEBUG("apply {:#x} to offset {:#x} ...",
+ new_addr, update_offset);
layout_t::update_child_addr(node, new_addr, p_addr);
break;
}
case node_delta_op_t::ERASE: {
- logger().debug("OTree::Extent::Replay: decoding ERASE ...");
+ DEBUG("decoding ERASE ...");
auto erase_pos = position_t::decode(delta);
- logger().debug("OTree::Extent::Replay: apply erase_pos({}) ...",
- erase_pos);
+ DEBUG("apply erase_pos({}) ...", erase_pos);
layout_t::erase(node, stage, erase_pos);
break;
}
case node_delta_op_t::MAKE_TAIL: {
- logger().debug("OTree::Extent::Replay: decoded MAKE_TAIL, apply ...");
+ DEBUG("decoded MAKE_TAIL, apply ...");
layout_t::make_tail(node, stage);
break;
}
case node_delta_op_t::SUBOP_UPDATE_VALUE: {
- logger().debug("OTree::Extent::Replay: decoding SUBOP_UPDATE_VALUE ...");
+ DEBUG("decoding SUBOP_UPDATE_VALUE ...");
node_offset_t value_header_offset;
ceph::decode(value_header_offset, delta);
auto p_header = node.get_read() + value_header_offset;
auto p_header_ = reinterpret_cast<const value_header_t*>(p_header);
- logger().debug("OTree::Extent::Replay: update {} at {:#x} ...",
- *p_header_, value_header_offset);
+ DEBUG("update {} at {:#x} ...", *p_header_, value_header_offset);
auto payload_mut = p_header_->get_payload_mutable(node);
auto value_addr = node_laddr + payload_mut.get_node_offset();
get_value_replayer(p_header_->magic)->apply_value_delta(
break;
}
default:
- logger().error("OTree::Extent::Replay: got unknown op {} when replay {:#x}",
- op, node_laddr);
+ ERROR("got unknown op {} when replay {:#x}",
+ op, node_laddr);
ceph_abort();
}
} catch (buffer::error& e) {
- logger().error("OTree::Extent::Replay: got decode error {} when replay {:#x}",
- e, node_laddr);
+ ERROR("got decode error {} when replay {:#x}",
+ e, node_laddr);
ceph_abort();
}
}
}
}
- static seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
- }
-
std::unique_ptr<ValueDeltaRecorder> value_replayer;
};
using ertr = NodeExtentManager::tm_ertr;
ertr::future<NodeExtentMutable> rebuild(context_t c) {
+ LOG_PREFIX(OTree::Extent::rebuild);
assert(extent->is_valid());
if (state == nextent_state_t::FRESH) {
assert(extent->is_initial_pending());
}
assert(!extent->is_initial_pending());
return c.nm.alloc_extent(c.t, node_stage_t::EXTENT_SIZE
- ).safe_then([this, c] (auto fresh_extent) {
- logger().debug("OTree::Extent::Rebuild: update addr from {:#x} to {:#x} ...",
- extent->get_laddr(), fresh_extent->get_laddr());
+ ).safe_then([this, c, FNAME] (auto fresh_extent) {
+ DEBUGT("update addr from {:#x} to {:#x} ...",
+ c.t, extent->get_laddr(), fresh_extent->get_laddr());
assert(fresh_extent->is_initial_pending());
assert(fresh_extent->get_recorder() == nullptr);
assert(extent->get_length() == fresh_extent->get_length());
}
private:
- static seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
- }
-
NodeExtentRef extent;
node_stage_t node_stage;
nextent_state_t state;
#include <seastar/core/sleep.hh>
#include "include/buffer_raw.h"
+#include "crimson/os/seastore/logging.h"
-#include "crimson/common/log.h"
#include "crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h"
/**
~DummySuper() override = default;
protected:
laddr_t get_root_laddr() const override { return *p_root_laddr; }
- void write_root_laddr(context_t, laddr_t addr) override {
- logger().debug("OTree::Dummy: update root {:#x} ...", addr);
+ void write_root_laddr(context_t c, laddr_t addr) override {
+ LOG_PREFIX(OTree::Dummy);
+ DEBUGT("update root {:#x} ...", c.t, addr);
*p_root_laddr = addr;
}
private:
- static seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
- }
laddr_t* p_root_laddr;
};
tm_future<NodeExtentRef> read_extent(
Transaction& t, laddr_t addr, extent_len_t len) override {
- logger().trace("OTree::Dummy: reading {}B at {:#x} ...", len, addr);
+ TRACET("reading {}B at {:#x} ...", t, len, addr);
if constexpr (SYNC) {
return read_extent_sync(t, addr, len);
} else {
tm_future<NodeExtentRef> alloc_extent(
Transaction& t, extent_len_t len) override {
- logger().trace("OTree::Dummy: allocating {}B ...", len);
+ TRACET("allocating {}B ...", t, len);
if constexpr (SYNC) {
return alloc_extent_sync(t, len);
} else {
tm_future<> retire_extent(
Transaction& t, NodeExtentRef extent) override {
- logger().trace("OTree::Dummy: retiring {}B at {:#x} ...",
- extent->get_length(), extent->get_laddr());
+ TRACET("retiring {}B at {:#x} ...",
+ t, extent->get_length(), extent->get_laddr());
if constexpr (SYNC) {
return retire_extent_sync(t, extent);
} else {
tm_future<Super::URef> get_super(
Transaction& t, RootNodeTracker& tracker) override {
- logger().trace("OTree::Dummy: get root ...");
+ TRACET("get root ...", t);
if constexpr (SYNC) {
return get_super_sync(t, tracker);
} else {
auto iter = allocate_map.find(addr);
assert(iter != allocate_map.end());
auto extent = iter->second;
- logger().trace("OTree::Dummy: read {}B at {:#x}",
- extent->get_length(), extent->get_laddr());
+ TRACET("read {}B at {:#x}", t, extent->get_length(), extent->get_laddr());
assert(extent->get_laddr() == addr);
assert(extent->get_length() == len);
return tm_ertr::make_ready_future<NodeExtentRef>(extent);
extent->set_laddr(addr);
assert(allocate_map.find(extent->get_laddr()) == allocate_map.end());
allocate_map.insert({extent->get_laddr(), extent});
- logger().debug("OTree::Dummy: allocated {}B at {:#x}",
- extent->get_length(), extent->get_laddr());
+ DEBUGT("allocated {}B at {:#x}", t, extent->get_length(), extent->get_laddr());
assert(extent->get_length() == len);
return tm_ertr::make_ready_future<NodeExtentRef>(extent);
}
auto iter = allocate_map.find(addr);
assert(iter != allocate_map.end());
allocate_map.erase(iter);
- logger().debug("OTree::Dummy: retired {}B at {:#x}", len, addr);
+ DEBUGT("retired {}B at {:#x}", t, len, addr);
return tm_ertr::now();
}
tm_future<Super::URef> get_super_sync(
Transaction& t, RootNodeTracker& tracker) {
- logger().trace("OTree::Dummy: got root {:#x}", root_laddr);
+ TRACET("got root {:#x}", t, root_laddr);
return tm_ertr::make_ready_future<Super::URef>(
Super::URef(new DummySuper(t, tracker, &root_laddr)));
}
- static seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
- }
+ static LOG_PREFIX(OTree::Dummy);
std::map<laddr_t, Ref<DummyNodeExtent>> allocate_map;
laddr_t root_laddr = L_ADDR_NULL;
#include "crimson/os/seastore/onode_manager/staged-fltree/stages/node_stage_layout.h"
namespace {
-
-seastar::logger& logger()
-{
- return crimson::get_logger(ceph_subsys_filestore);
-}
-
+LOG_PREFIX(OTree::Seastore);
}
namespace crimson::os::seastore::onode {
void SeastoreSuper::write_root_laddr(context_t c, laddr_t addr)
{
- logger().debug("OTree::Seastore: update root {:#x} ...", addr);
+ DEBUGT("update root {:#x} ...", c.t, addr);
root_addr = addr;
auto nm = static_cast<SeastoreNodeExtentManager*>(&c.nm);
nm->get_tm().write_onode_root(c.t, addr);
NodeExtentRef SeastoreNodeExtent::mutate(
context_t c, DeltaRecorderURef&& _recorder)
{
- logger().debug("OTree::Seastore: mutate {:#x} ...", get_laddr());
+ DEBUGT("mutate {:#x} ...", c.t, get_laddr());
auto nm = static_cast<SeastoreNodeExtentManager*>(&c.nm);
auto extent = nm->get_tm().get_mutable_extent(c.t, this);
auto ret = extent->cast<SeastoreNodeExtent>();
void SeastoreNodeExtent::apply_delta(const ceph::bufferlist& bl)
{
- logger().debug("OTree::Seastore: replay {:#x} ...", get_laddr());
+ DEBUG("replay {:#x} ...", get_laddr());
if (!recorder) {
auto [node_type, field_type] = get_types();
recorder = create_replay_recorder(node_type, field_type);
#pragma once
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
#include "crimson/os/seastore/onode_manager/staged-fltree/node_extent_manager.h"
#include "crimson/os/seastore/onode_manager/staged-fltree/node_delta_recorder.h"
}
void write_root_laddr(context_t c, laddr_t addr) override;
private:
- static seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
- }
laddr_t root_addr;
TransactionManager& tm;
};
tm_future<NodeExtentRef> read_extent(
Transaction& t, laddr_t addr, extent_len_t len) override {
- logger().trace("OTree::Seastore: reading {}B at {:#x} ...", len, addr);
+ TRACET("reading {}B at {:#x} ...", t, len, addr);
return tm.read_extent<SeastoreNodeExtent>(t, addr, len
- ).safe_then([addr, len](auto&& e) {
- logger().trace("OTree::Seastore: read {}B at {:#x}",
- e->get_length(), e->get_laddr());
+ ).safe_then([addr, len, this, &t](auto&& e) {
+ TRACET("read {}B at {:#x}", t, e->get_length(), e->get_laddr());
assert(e->get_laddr() == addr);
assert(e->get_length() == len);
std::ignore = addr;
tm_future<NodeExtentRef> alloc_extent(
Transaction& t, extent_len_t len) override {
- logger().trace("OTree::Seastore: allocating {}B ...", len);
+ TRACET("allocating {}B ...", t, len);
return tm.alloc_extent<SeastoreNodeExtent>(t, addr_min, len
- ).safe_then([len](auto extent) {
- logger().debug("OTree::Seastore: allocated {}B at {:#x}",
- extent->get_length(), extent->get_laddr());
+ ).safe_then([len, this, &t](auto extent) {
+ DEBUGT("allocated {}B at {:#x}",
+ t, extent->get_length(), extent->get_laddr());
assert(extent->get_length() == len);
std::ignore = len;
return NodeExtentRef(extent);
LogicalCachedExtentRef extent = _extent;
auto addr = extent->get_laddr();
auto len = extent->get_length();
- logger().debug("OTree::Seastore: retiring {}B at {:#x} ...", len, addr);
- return tm.dec_ref(t, extent).safe_then([addr, len] (unsigned cnt) {
+ DEBUGT("retiring {}B at {:#x} ...", t, len, addr);
+ return tm.dec_ref(t, extent).safe_then([addr, len, this, &t] (unsigned cnt) {
assert(cnt == 0);
- logger().trace("OTree::Seastore: retired {}B at {:#x} ...", len, addr);
+ TRACET("retired {}B at {:#x} ...", t, len, addr);
});
}
tm_future<Super::URef> get_super(
Transaction& t, RootNodeTracker& tracker) override {
- logger().trace("OTree::Seastore: get root ...");
+ TRACET("get root ...", t);
return tm.read_onode_root(t).safe_then([this, &t, &tracker](auto root_addr) {
- logger().trace("OTree::Seastore: got root {:#x}", root_addr);
+ TRACET("got root {:#x}", t, root_addr);
return Super::URef(new SeastoreSuper(t, tracker, root_addr, tm));
});
}
}
private:
- static seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
- }
+ static LOG_PREFIX(OTree::Seastore);
+
TransactionManager& tm;
const laddr_t addr_min;
};
#include <sstream>
#include "common/likely.h"
-#include "crimson/common/log.h"
+#include "crimson/os/seastore/logging.h"
+
#include "node_extent_accessor.h"
#include "node_impl.h"
#include "stages/node_stage_layout.h"
std::tuple<match_stage_t, search_position_t>
erase(const search_position_t& pos) override {
- logger().debug("OTree::Layout::Erase: begin at erase_pos({}) ...", pos);
- if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+ LOG_PREFIX(OTree::Layout::erase);
+ DEBUG("begin at erase_pos({}) ...", pos);
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- logger().trace("OTree::Layout::Erase: -- dump\n{}", sos.str());
+ TRACE("-- dump\n{}", sos.str());
}
auto [stage, next_or_last_pos] = extent.erase_replayable(cast_down<STAGE>(pos));
- logger().debug("OTree::Layout::Erase: done at erase_stage={}, n/l_pos({})",
- stage, next_or_last_pos);
- if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+ DEBUG("done at erase_stage={}, n/l_pos({})", stage, next_or_last_pos);
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- logger().trace("OTree::Layout::Erase: -- dump\n{}", sos.str());
+ TRACE("-- dump\n{}", sos.str());
}
#ifndef NDEBUG
if (!is_keys_empty()) {
search_position_t merge(NodeExtentMutable& mut, NodeImpl& _right_node,
match_stage_t merge_stage, node_offset_t merge_size) override {
+ LOG_PREFIX(OTree::Layout::merge);
assert(NODE_TYPE == _right_node.node_type());
assert(FIELD_TYPE == _right_node.field_type());
auto& right_node = dynamic_cast<NodeLayoutT&>(_right_node);
- if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
{
std::ostringstream sos;
dump(sos);
- logger().debug("OTree::Layout::Merge: -- left node dump\n{}", sos.str());
+ DEBUG("-- left node dump\n{}", sos.str());
}
{
std::ostringstream sos;
right_node.dump(sos);
- logger().debug("OTree::Layout::Merge: -- right node dump\n{}", sos.str());
+ DEBUG("-- right node dump\n{}", sos.str());
}
}
build_name();
}
- if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
dump(sos);
- logger().debug("OTree::Layout::Merge: -- merged node dump\n{}", sos.str());
+ DEBUG("-- merged node dump\n{}", sos.str());
}
assert(merge_size == filled_size());
return normalize(std::move(left_last_pos));
const full_key_t<KEY_TYPE>& key, const value_input_t& value,
search_position_t& insert_pos, match_stage_t& insert_stage,
node_offset_t& insert_size) override {
- logger().debug("OTree::Layout::Insert: begin at "
- "insert_pos({}), insert_stage={}, insert_size={}B ...",
- insert_pos, insert_stage, insert_size);
- if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+ LOG_PREFIX(OTree::Layout::insert);
+ DEBUG("begin at insert_pos({}), insert_stage={}, insert_size={}B ...",
+ insert_pos, insert_stage, insert_size);
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- logger().trace("OTree::Layout::Insert: -- dump\n{}", sos.str());
+ TRACE("-- dump\n{}", sos.str());
}
auto ret = extent.template insert_replayable<KEY_TYPE>(
key, value, cast_down<STAGE>(insert_pos), insert_stage, insert_size);
- logger().debug("OTree::Layout::Insert: done at "
- "insert_pos({}), insert_stage={}, insert_size={}B",
- insert_pos, insert_stage, insert_size);
- if (unlikely(logger().is_enabled(seastar::log_level::trace))) {
+ DEBUG("done at insert_pos({}), insert_stage={}, insert_size={}B",
+ insert_pos, insert_stage, insert_size);
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- logger().trace("OTree::Layout::Insert: -- dump\n{}", sos.str());
+ TRACE("-- dump\n{}", sos.str());
}
validate_layout();
#ifndef NDEBUG
const full_key_t<KEY_TYPE>& key, const value_input_t& value,
search_position_t& _insert_pos, match_stage_t& insert_stage,
node_offset_t& insert_size) override {
+ LOG_PREFIX(OTree::Layout::split_insert);
assert(_right_impl.node_type() == NODE_TYPE);
assert(_right_impl.field_type() == FIELD_TYPE);
auto& right_impl = dynamic_cast<NodeLayoutT&>(_right_impl);
- logger().info("OTree::Layout::Split: begin at "
- "insert_pos({}), insert_stage={}, insert_size={}B ...",
- _insert_pos, insert_stage, insert_size);
- if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+ INFO("begin at insert_pos({}), insert_stage={}, insert_size={}B ...",
+ _insert_pos, insert_stage, insert_size);
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
dump(sos);
- logger().debug("OTree::Layout::Split: -- dump\n{}", sos.str());
+ DEBUG("-- dump\n{}", sos.str());
}
#ifdef UNIT_TESTS_BUILT
auto insert_stage_pre = insert_stage;
split_size, 0, target_split_size, insert_pos,
insert_stage, insert_size, _is_insert_left, split_at);
is_insert_left = *_is_insert_left;
- logger().debug("OTree::Layout::Split: -- located "
- "split_at({}), insert_pos({}), is_insert_left={}, "
- "split_size={}B(target={}B, current={}B)",
- split_at, insert_pos, is_insert_left,
- split_size, target_split_size, filled_size());
+ DEBUG("-- located split_at({}), insert_pos({}), is_insert_left={}, "
+ "split_size={}B(target={}B, current={}B)",
+ split_at, insert_pos, is_insert_left,
+ split_size, target_split_size, filled_size());
// split_size can be larger than target_split_size in strategy B
// assert(split_size <= target_split_size);
if (locate_nxt) {
// right node: append [start(append_at), insert_pos)
STAGE_T::template append_until<KEY_TYPE>(
append_at, right_appender, insert_pos, insert_stage);
- logger().debug("OTree::Layout::Split: -- right appended until "
- "insert_pos({}), insert_stage={}, insert/append the rest ...",
- insert_pos, insert_stage);
+ DEBUG("-- right appended until "
+ "insert_pos({}), insert_stage={}, insert/append the rest ...",
+ insert_pos, insert_stage);
// right node: append [insert_pos(key, value)]
bool is_front_insert = (insert_pos == position_t::begin());
[[maybe_unused]] bool is_end = STAGE_T::template append_insert<KEY_TYPE>(
is_front_insert, insert_stage, p_value);
assert(append_at.is_end() == is_end);
} else {
- logger().debug("OTree::Layout::Split: -- right appending ...");
+ DEBUG("-- right appending ...");
}
// right node: append (insert_pos, end)
append_at, right_appender, pos_end, STAGE);
assert(append_at.is_end());
right_appender.wrap();
- if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
right_impl.dump(sos);
- logger().debug("OTree::Layout::Split: -- right node dump\n{}", sos.str());
+ DEBUG("-- right node dump\n{}", sos.str());
}
right_impl.validate_layout();
// mutate left node
if (is_insert_left) {
- logger().debug("OTree::Layout::Split: -- left trim/insert at "
- "insert_pos({}), insert_stage={} ...",
- insert_pos, insert_stage);
+ DEBUG("-- left trim/insert at insert_pos({}), insert_stage={} ...",
+ insert_pos, insert_stage);
p_value = extent.template split_insert_replayable<KEY_TYPE>(
split_at, key, value, insert_pos, insert_stage, insert_size);
#ifndef NDEBUG
assert(index.compare_to(key) == MatchKindCMP::EQ);
#endif
} else {
- logger().debug("OTree::Layout::Split: -- left trim ...");
+ DEBUG("-- left trim ...");
#ifndef NDEBUG
full_key_t<KeyT::VIEW> index;
right_impl.get_slot(_insert_pos, &index, nullptr);
// is_level_tail of left is changed by split/split_insert
build_name();
}
- if (unlikely(logger().is_enabled(seastar::log_level::debug))) {
+ if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
dump(sos);
- logger().debug("OTree::Layout::Split: -- left node dump\n{}", sos.str());
+ DEBUG("-- left node dump\n{}", sos.str());
}
validate_layout();
assert(p_value);
auto split_pos = normalize(split_at.get_pos());
- logger().info("OTree::Layout::Split: done at "
- "insert_pos({}), insert_stage={}, insert_size={}B, split_at({}), "
- "is_insert_left={}, split_size={}B(target={}B)",
- _insert_pos, insert_stage, insert_size, split_pos,
- is_insert_left, split_size, target_split_size);
+ INFO("done at insert_pos({}), insert_stage={}, insert_size={}B, "
+ "split_at({}), is_insert_left={}, split_size={}B(target={}B)",
+ _insert_pos, insert_stage, insert_size, split_pos,
+ is_insert_left, split_size, target_split_size);
assert(split_size == filled_size());
#ifdef UNIT_TESTS_BUILT
void replace_child_addr(
const search_position_t& pos, laddr_t dst, laddr_t src) override {
if constexpr (NODE_TYPE == node_type_t::INTERNAL) {
- logger().debug("OTree::Layout::ReplaceChildAddr: "
- "update from {:#x} to {:#x} at pos({}) ...",
- src, dst, pos);
+ LOG_PREFIX(OTree::Layout::replace_child_addr);
+ DEBUG("update from {:#x} to {:#x} at pos({}) ...", src, dst, pos);
const laddr_packed_t* p_value;
if (pos.is_end()) {
assert(is_level_tail());
name = sos.str();
}
- static seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
- }
-
extent_t extent;
std::string name = "Node-N/A";
};
projects / ceph-ci.git / commitdiff