To enable fine-grain logger control for easier bug triage.
See common/subsys.h for the new classifications.
Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>
SUBSYS(test, 0, 5)
SUBSYS(cephfs_mirror, 0, 5)
SUBSYS(cephsqlite, 0, 5)
-SUBSYS(seastore, 0, 5)
+SUBSYS(seastore, 0, 5) // logs above seastore tm
+SUBSYS(seastore_onode, 0, 5)
+SUBSYS(seastore_odata, 0, 5)
+SUBSYS(seastore_omap, 0, 5)
+SUBSYS(seastore_tm, 0, 5) // logs below seastore tm
+SUBSYS(seastore_cleaner, 0, 5)
+SUBSYS(seastore_lba, 0, 5)
+SUBSYS(seastore_cache, 0, 5)
+SUBSYS(seastore_journal, 0, 5)
+SUBSYS(seastore_device, 0, 5)
SUBSYS(alienstore, 0, 5)
using std::string_view;
+SET_SUBSYS(seastore_cache);
+
namespace crimson::os::seastore {
Cache::Cache(
return on_transaction_destruct(t);
}
);
- DEBUGT("created name={}, source={}, is_weak={}",
- *ret, name, src, is_weak);
+ SUBDEBUGT(seastore_cache, "created name={}, source={}, is_weak={}",
+ *ret, name, src, is_weak);
return ret;
}
++(get_by_src(stats.trans_created_by_src, t.get_src()));
}
t.reset_preserve_handle(last_commit);
- DEBUGT("reset", t);
+ SUBDEBUGT(seastore_cache, "reset", t);
}
/**
auto result = t.get_extent(offset, &ret);
if (result != Transaction::get_extent_ret::ABSENT) {
// including get_extent_ret::RETIRED
- DEBUGT(
+ SUBDEBUGT(seastore_cache,
"Found extent at offset {} on transaction: {}",
t, offset, *ret);
return get_extent_if_cached_iertr::make_ready_future<
if (!ret ||
// retired_placeholder is not really cached yet
ret->get_type() == extent_types_t::RETIRED_PLACEHOLDER) {
- DEBUGT(
+ SUBDEBUGT(seastore_cache,
"No extent at offset {}, retired_placeholder: {}",
t, offset, !!ret);
return get_extent_if_cached_iertr::make_ready_future<
}
// present in cache and is not a retired_placeholder
- DEBUGT(
+ SUBDEBUGT(seastore_cache,
"Found extent at offset {} in cache: {}",
t, offset, *ret);
t.add_to_read_set(ret);
auto result = t.get_extent(offset, &ret);
if (result != Transaction::get_extent_ret::ABSENT) {
assert(result != Transaction::get_extent_ret::RETIRED);
- DEBUGT(
+ SUBDEBUGT(seastore_cache,
"Found extent at offset {} on transaction: {}",
t, offset, *ret);
return seastar::make_ready_future<TCachedExtentRef<T>>(
).si_then([this, FNAME, offset, &t](auto ref) {
(void)this; // silence incorrect clang warning about capture
if (!ref->is_valid()) {
- DEBUGT("got invalid extent: {}", t, ref);
+ SUBDEBUGT(seastore_cache, "got invalid extent: {}", t, ref);
++(get_by_src(stats.trans_conflicts_by_unknown, t.get_src()));
mark_transaction_conflicted(t, *ref);
return get_extent_iertr::make_ready_future<TCachedExtentRef<T>>();
} else {
- DEBUGT(
+ SUBDEBUGT(seastore_cache,
"Read extent at offset {} in cache: {}",
t, offset, *ref);
t.add_to_read_set(ref);
).si_then([=, &t](CachedExtentRef ret) {
if (!ret->is_valid()) {
LOG_PREFIX(Cache::get_extent_by_type);
- DEBUGT("got invalid extent: {}", t, ret);
+ SUBDEBUGT(seastore_cache, "got invalid extent: {}", t, ret);
++(get_by_src(stats.trans_conflicts_by_unknown, t.get_src()));
mark_transaction_conflicted(t, *ret.get());
return get_extent_ertr::make_ready_future<CachedExtentRef>();
namespace {
[[maybe_unused]] seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_tm);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_tm);
}
}
+SET_SUBSYS(seastore_tm);
+
namespace crimson::os::seastore {
SegmentedAllocator::SegmentedAllocator(
Transaction& t,
std::list<LogicalCachedExtentRef>& extents) final {
LOG_PREFIX(SegmentedAllocator::alloc_ool_extents_paddr);
- DEBUGT("start", t);
+ SUBDEBUGT(seastore_tm, "start", t);
return seastar::do_with(
std::map<Writer*, std::list<LogicalCachedExtentRef>>(),
[this, extents=std::move(extents), &t](auto& alloc_map) {
alloc_paddr_iertr::future<> delayed_alloc_or_ool_write(
Transaction& t) {
LOG_PREFIX(ExtentPlacementManager::delayed_alloc_or_ool_write);
- DEBUGT("start", t);
+ SUBDEBUGT(seastore_tm, "start", t);
return seastar::do_with(
std::map<ExtentAllocator*, std::list<LogicalCachedExtentRef>>(),
[this, &t](auto& alloc_map) {
alloc_map[allocator_ptr.get()].emplace_back(extent);
num_ool_extents++;
}
- DEBUGT("{} ool extents", t, num_ool_extents);
+ SUBDEBUGT(seastore_tm, "{} ool extents", t, num_ool_extents);
return trans_intr::do_for_each(alloc_map, [&t](auto& p) {
auto allocator = p.first;
auto& extents = p.second;
void add_allocator(device_type_t type, ExtentAllocatorRef&& allocator) {
allocators[type].emplace_back(std::move(allocator));
LOG_PREFIX(ExtentPlacementManager::add_allocator);
- DEBUG("allocators for {}: {}",
+ SUBDEBUG(seastore_tm, "allocators for {}: {}",
device_type_to_string(type),
allocators[type].size());
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_tm);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_journal);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_lba);
}
}
+SET_SUBSYS(seastore_lba);
+
namespace crimson::os::seastore::lba_manager::btree {
BtreeLBAManager::mkfs_ret BtreeLBAManager::mkfs(
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_lba);
}
}
#include "crimson/os/seastore/lba_manager/btree/lba_btree.h"
+SET_SUBSYS(seastore_lba);
+
namespace crimson::os::seastore::lba_manager::btree {
LBABtree::mkfs_ret LBABtree::mkfs(op_context_t c)
mapped_space_visitor_t *visitor ///< [in] mapped space visitor
) {
LOG_PREFIX(LBATree::lookup_depth_range);
- DEBUGT("{} -> {}", c.trans, from, to);
+ SUBDEBUGT(seastore_lba, "{} -> {}", c.trans, from, to);
return seastar::do_with(
from,
[c, to, visitor, &iter, &li, &ll](auto &d) {
auto riter = ll(*(root_entry.node));
root_entry.pos = riter->get_offset();
}
- DEBUGT("got root, depth {}", c.trans, root.get_depth());
+ SUBDEBUGT(seastore_lba, "got root, depth {}", c.trans, root.get_depth());
return lookup_depth_range(
c,
iter,
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_lba);
}
}
#include "crimson/common/log.h"
-#define LOGGER crimson::get_logger(ceph_subsys_seastore)
+#define SET_SUBSYS(subname_) static constexpr auto SOURCE_SUBSYS = ceph_subsys_##subname_
+#define LOCAL_LOGGER crimson::get_logger(SOURCE_SUBSYS)
+#define LOGGER(subname_) crimson::get_logger(ceph_subsys_##subname_)
#define LOG_PREFIX(x) constexpr auto FNAME = #x
#ifdef NDEBUG
#define LOG(level_, MSG, ...) \
- LOGGER.log(level_, "{}: " MSG, FNAME , ##__VA_ARGS__)
+ LOCAL_LOGGER.log(level_, "{}: " MSG, FNAME , ##__VA_ARGS__)
#define LOGT(level_, MSG, t, ...) \
- LOGGER.log(level_, "{}({}): " MSG, FNAME, (void*)&t , ##__VA_ARGS__)
+ LOCAL_LOGGER.log(level_, "{}({}): " MSG, FNAME, (void*)&t , ##__VA_ARGS__)
+#define SUBLOG(subname_, level_, MSG, ...) \
+ LOGGER(subname_).log(level_, "{}: " MSG, FNAME , ##__VA_ARGS__)
+#define SUBLOGT(subname_, level_, MSG, t, ...) \
+ LOGGER(subname_).log(level_, "{}({}): " MSG, FNAME, (void*)&t , ##__VA_ARGS__)
#else
}
#define LOG(level_, MSG, ...) \
- _LOG<level_>(LOGGER, "{}: " MSG ## _format(FNAME , ##__VA_ARGS__))
+ _LOG<level_>(LOCAL_LOGGER, "{}: " MSG ## _format(FNAME , ##__VA_ARGS__))
#define LOGT(level_, MSG, t_, ...) \
- _LOG<level_>(LOGGER, "{}({}): " MSG ## _format(FNAME, (void*)&t_ , ##__VA_ARGS__))
+ _LOG<level_>(LOCAL_LOGGER, "{}({}): " MSG ## _format(FNAME, (void*)&t_ , ##__VA_ARGS__))
+#define SUBLOG(subname_, level_, MSG, ...) \
+ _LOG<level_>(LOGGER(subname_), "{}: " MSG ## _format(FNAME , ##__VA_ARGS__))
+#define SUBLOGT(subname_, level_, MSG, t_, ...) \
+ _LOG<level_>(LOGGER(subname_), "{}({}): " MSG ## _format(FNAME, (void*)&t_ , ##__VA_ARGS__))
#endif
#define TRACE(...) LOG(seastar::log_level::trace, __VA_ARGS__)
#define TRACET(...) LOGT(seastar::log_level::trace, __VA_ARGS__)
+#define SUBTRACE(subname_, ...) SUBLOG(subname_, seastar::log_level::trace, __VA_ARGS__)
+#define SUBTRACET(subname_, ...) SUBLOGT(subname_, seastar::log_level::trace, __VA_ARGS__)
#define DEBUG(...) LOG(seastar::log_level::debug, __VA_ARGS__)
#define DEBUGT(...) LOGT(seastar::log_level::debug, __VA_ARGS__)
+#define SUBDEBUG(subname_, ...) SUBLOG(subname_, seastar::log_level::debug, __VA_ARGS__)
+#define SUBDEBUGT(subname_, ...) SUBLOGT(subname_, seastar::log_level::debug, __VA_ARGS__)
#define INFO(...) LOG(seastar::log_level::info, __VA_ARGS__)
#define INFOT(...) LOGT(seastar::log_level::info, __VA_ARGS__)
+#define SUBINFO(subname_, ...) SUBLOG(subname_, seastar::log_level::info, __VA_ARGS__)
+#define SUBINFOT(subname_, ...) SUBLOGT(subname_, seastar::log_level::info, __VA_ARGS__)
#define WARN(...) LOG(seastar::log_level::warn, __VA_ARGS__)
#define WARNT(...) LOGT(seastar::log_level::warn, __VA_ARGS__)
+#define SUBWARN(subname_, ...) SUBLOG(subname_, seastar::log_level::warn, __VA_ARGS__)
+#define SUBWARNT(subname_, ...) SUBLOGT(subname_, seastar::log_level::warn, __VA_ARGS__)
#define ERROR(...) LOG(seastar::log_level::error, __VA_ARGS__)
#define ERRORT(...) LOGT(seastar::log_level::error, __VA_ARGS__)
+#define SUBERROR(subname_, ...) SUBLOG(subname_, seastar::log_level::error, __VA_ARGS__)
+#define SUBERRORT(subname_, ...) SUBLOGT(subname_, seastar::log_level::error, __VA_ARGS__)
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_odata);
}
}
+SET_SUBSYS(seastore_odata);
+
namespace crimson::os::seastore {
#define assert_aligned(x) ceph_assert(((x)%ctx.tm.get_block_size()) == 0)
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_omap);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_omap);
}
}
#include "crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.h"
+SET_SUBSYS(seastore_onode);
+
namespace crimson::os::seastore::onode {
FLTreeOnodeManager::contains_onode_ret FLTreeOnodeManager::contains_onode(
#include "node_impl.h"
#include "stages/node_stage_layout.h"
+SET_SUBSYS(seastore_onode);
+
namespace crimson::os::seastore::onode {
/*
* tree_cursor_t
ceph::decode(op, delta);
switch (op) {
case node_delta_op_t::INSERT: {
- DEBUG("decoding INSERT ...");
+ SUBDEBUG(seastore_onode, "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);
- DEBUG("apply {}, {}, insert_pos({}), insert_stage={}, "
- "insert_size={}B ...",
- key, value, insert_pos, insert_stage, insert_size);
+ SUBDEBUG(seastore_onode,
+ "apply {}, {}, insert_pos({}), insert_stage={}, "
+ "insert_size={}B ...",
+ key, value, insert_pos, insert_stage, insert_size);
layout_t::template insert<KeyT::HOBJ>(
mut, stage, key, value, insert_pos, insert_stage, insert_size);
break;
}
case node_delta_op_t::SPLIT: {
- DEBUG("decoding SPLIT ...");
+ SUBDEBUG(seastore_onode, "decoding SPLIT ...");
auto split_at = StagedIterator::decode(
mut.get_read(), mut.get_length(), delta);
- DEBUG("apply split_at={} ...", split_at);
+ SUBDEBUG(seastore_onode, "apply split_at={} ...", split_at);
layout_t::split(mut, stage, split_at);
break;
}
case node_delta_op_t::SPLIT_INSERT: {
- DEBUG("decoding SPLIT_INSERT ...");
+ SUBDEBUG(seastore_onode, "decoding SPLIT_INSERT ...");
auto split_at = StagedIterator::decode(
mut.get_read(), mut.get_length(), delta);
auto key = key_hobj_t::decode(delta);
ceph::decode(insert_stage, delta);
node_offset_t insert_size;
ceph::decode(insert_size, delta);
- DEBUG("apply split_at={}, {}, {}, insert_pos({}), insert_stage={}, "
- "insert_size={}B ...",
- split_at, key, value, insert_pos, insert_stage, insert_size);
+ SUBDEBUG(seastore_onode,
+ "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>(
mut, stage, split_at, key, value, insert_pos, insert_stage, insert_size);
break;
}
case node_delta_op_t::UPDATE_CHILD_ADDR: {
- DEBUG("decoding UPDATE_CHILD_ADDR ...");
+ SUBDEBUG(seastore_onode, "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*>(
mut.get_write() + update_offset);
- DEBUG("apply {:#x} to offset {:#x} ...",
- new_addr, update_offset);
+ SUBDEBUG(seastore_onode,
+ "apply {:#x} to offset {:#x} ...",
+ new_addr, update_offset);
layout_t::update_child_addr(mut, new_addr, p_addr);
break;
}
case node_delta_op_t::ERASE: {
- DEBUG("decoding ERASE ...");
+ SUBDEBUG(seastore_onode, "decoding ERASE ...");
auto erase_pos = position_t::decode(delta);
- DEBUG("apply erase_pos({}) ...", erase_pos);
+ SUBDEBUG(seastore_onode, "apply erase_pos({}) ...", erase_pos);
layout_t::erase(mut, stage, erase_pos);
break;
}
case node_delta_op_t::MAKE_TAIL: {
- DEBUG("decoded MAKE_TAIL, apply ...");
+ SUBDEBUG(seastore_onode, "decoded MAKE_TAIL, apply ...");
layout_t::make_tail(mut, stage);
break;
}
case node_delta_op_t::SUBOP_UPDATE_VALUE: {
- DEBUG("decoding SUBOP_UPDATE_VALUE ...");
+ SUBDEBUG(seastore_onode, "decoding SUBOP_UPDATE_VALUE ...");
node_offset_t value_header_offset;
ceph::decode(value_header_offset, delta);
auto p_header = mut.get_read() + value_header_offset;
auto p_header_ = reinterpret_cast<const value_header_t*>(p_header);
- DEBUG("update {} at {:#x} ...", *p_header_, value_header_offset);
+ SUBDEBUG(seastore_onode, "update {} at {:#x} ...", *p_header_, value_header_offset);
auto payload_mut = p_header_->get_payload_mutable(mut);
auto value_addr = node.get_laddr() + payload_mut.get_node_offset();
get_value_replayer(p_header_->magic)->apply_value_delta(
break;
}
default:
- ERROR("got unknown op {} when replay {}",
- op, node);
+ SUBERROR(seastore_onode,
+ "got unknown op {} when replay {}",
+ op, node);
ceph_abort("fatal error");
}
} catch (buffer::error& e) {
- ERROR("got decode error {} when replay {}",
- e, node);
+ SUBERROR(seastore_onode,
+ "got decode error {} when replay {}",
+ e, node);
ceph_abort("fatal error");
}
}
eagain_iertr::pass_further{},
crimson::ct_error::input_output_error::handle(
[FNAME, c, alloc_size, l_to_discard = extent->get_laddr()] {
- ERRORT("EIO during allocate -- node_size={}, to_discard={:x}",
- c.t, alloc_size, l_to_discard);
+ SUBERRORT(seastore_onode,
+ "EIO during allocate -- node_size={}, to_discard={:x}",
+ c.t, alloc_size, l_to_discard);
ceph_abort("fatal error");
})
).si_then([this, c, FNAME] (auto fresh_extent) {
- DEBUGT("update addr from {:#x} to {:#x} ...",
- c.t, extent->get_laddr(), fresh_extent->get_laddr());
+ SUBDEBUGT(seastore_onode,
+ "update addr from {:#x} to {:#x} ...",
+ c.t, extent->get_laddr(), fresh_extent->get_laddr());
assert(fresh_extent);
assert(fresh_extent->is_initial_pending());
assert(fresh_extent->get_recorder() == nullptr);
crimson::ct_error::input_output_error::handle(
[FNAME, c, l_to_discard = to_discard->get_laddr(),
l_fresh = fresh_extent->get_laddr()] {
- ERRORT("EIO during retire -- to_disgard={:x}, fresh={:x}",
- c.t, l_to_discard, l_fresh);
+ SUBERRORT(seastore_onode,
+ "EIO during retire -- to_disgard={:x}, fresh={:x}",
+ c.t, l_to_discard, l_fresh);
ceph_abort("fatal error");
}),
crimson::ct_error::enoent::handle(
[FNAME, c, l_to_discard = to_discard->get_laddr(),
l_fresh = fresh_extent->get_laddr()] {
- ERRORT("ENOENT during retire -- to_disgard={:x}, fresh={:x}",
- c.t, l_to_discard, l_fresh);
+ SUBERRORT(seastore_onode,
+ "ENOENT during retire -- to_disgard={:x}, fresh={:x}",
+ c.t, l_to_discard, l_fresh);
ceph_abort("fatal error");
})
);
eagain_iertr::pass_further{},
crimson::ct_error::input_output_error::handle(
[FNAME, c, addr] {
- ERRORT("EIO -- addr={:x}", c.t, addr);
+ SUBERRORT(seastore_onode, "EIO -- addr={:x}", c.t, addr);
ceph_abort("fatal error");
}),
crimson::ct_error::enoent::handle(
[FNAME, c, addr] {
- ERRORT("ENOENT -- addr={:x}", c.t, addr);
+ SUBERRORT(seastore_onode, "ENOENT -- addr={:x}", c.t, addr);
ceph_abort("fatal error");
})
#ifndef NDEBUG
laddr_t get_root_laddr() const override { return *p_root_laddr; }
void write_root_laddr(context_t c, laddr_t addr) override {
LOG_PREFIX(OTree::Dummy);
- DEBUGT("update root {:#x} ...", c.t, addr);
+ SUBDEBUGT(seastore_onode, "update root {:#x} ...", c.t, addr);
*p_root_laddr = addr;
}
private:
read_iertr::future<NodeExtentRef> read_extent(
Transaction& t, laddr_t addr) override {
- TRACET("reading at {:#x} ...", t, addr);
+ SUBTRACET(seastore_onode, "reading at {:#x} ...", t, addr);
if constexpr (SYNC) {
return read_extent_sync(t, addr);
} else {
alloc_iertr::future<NodeExtentRef> alloc_extent(
Transaction& t, laddr_t hint, extent_len_t len) override {
- TRACET("allocating {}B with hint {:#x} ...", t, len, hint);
+ SUBTRACET(seastore_onode, "allocating {}B with hint {:#x} ...", t, len, hint);
if constexpr (SYNC) {
return alloc_extent_sync(t, len);
} else {
retire_iertr::future<> retire_extent(
Transaction& t, NodeExtentRef extent) override {
- TRACET("retiring {}B at {:#x} -- {} ...",
- t, extent->get_length(), extent->get_laddr(), *extent);
+ SUBTRACET(seastore_onode,
+ "retiring {}B at {:#x} -- {} ...",
+ t, extent->get_length(), extent->get_laddr(), *extent);
if constexpr (SYNC) {
return retire_extent_sync(t, extent);
} else {
getsuper_iertr::future<Super::URef> get_super(
Transaction& t, RootNodeTracker& tracker) override {
- TRACET("get root ...", t);
+ SUBTRACET(seastore_onode, "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;
- TRACET("read {}B at {:#x} -- {}",
- t, extent->get_length(), extent->get_laddr(), *extent);
+ SUBTRACET(seastore_onode,
+ "read {}B at {:#x} -- {}",
+ t, extent->get_length(), extent->get_laddr(), *extent);
assert(extent->get_laddr() == addr);
return read_iertr::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});
- DEBUGT("allocated {}B at {:#x} -- {}",
- t, extent->get_length(), extent->get_laddr(), *extent);
+ SUBDEBUGT(seastore_onode,
+ "allocated {}B at {:#x} -- {}",
+ t, extent->get_length(), extent->get_laddr(), *extent);
assert(extent->get_length() == len);
return alloc_iertr::make_ready_future<NodeExtentRef>(extent);
}
auto iter = allocate_map.find(addr);
assert(iter != allocate_map.end());
allocate_map.erase(iter);
- DEBUGT("retired {}B at {:#x}", t, len, addr);
+ SUBDEBUGT(seastore_onode, "retired {}B at {:#x}", t, len, addr);
return retire_iertr::now();
}
getsuper_iertr::future<Super::URef> get_super_sync(
Transaction& t, RootNodeTracker& tracker) {
- TRACET("got root {:#x}", t, root_laddr);
+ SUBTRACET(seastore_onode, "got root {:#x}", t, root_laddr);
return getsuper_iertr::make_ready_future<Super::URef>(
Super::URef(new DummySuper(t, tracker, &root_laddr)));
}
LOG_PREFIX(OTree::Seastore);
}
+SET_SUBSYS(seastore_onode);
+
namespace crimson::os::seastore::onode {
static DeltaRecorderURef create_replay_recorder(
}
void write_root_laddr(context_t c, laddr_t addr) override {
LOG_PREFIX(OTree::Seastore);
- DEBUGT("update root {:#x} ...", c.t, addr);
+ SUBDEBUGT(seastore_onode, "update root {:#x} ...", c.t, addr);
root_addr = addr;
tm.write_onode_root(c.t, addr);
}
read_iertr::future<NodeExtentRef> read_extent(
Transaction& t, laddr_t addr) override {
- TRACET("reading at {:#x} ...", t, addr);
+ SUBTRACET(seastore_onode, "reading at {:#x} ...", t, addr);
if constexpr (INJECT_EAGAIN) {
if (trigger_eagain()) {
- DEBUGT("reading at {:#x}: trigger eagain", t, addr);
+ SUBDEBUGT(seastore_onode, "reading at {:#x}: trigger eagain", t, addr);
t.test_set_conflict();
return read_iertr::make_ready_future<NodeExtentRef>();
}
}
return tm.read_extent<SeastoreNodeExtent>(t, addr
).si_then([addr, &t](auto&& e) -> read_iertr::future<NodeExtentRef> {
- TRACET("read {}B at {:#x} -- {}",
- t, e->get_length(), e->get_laddr(), *e);
+ SUBTRACET(seastore_onode,
+ "read {}B at {:#x} -- {}",
+ t, e->get_length(), e->get_laddr(), *e);
assert(e->get_laddr() == addr);
std::ignore = addr;
return read_iertr::make_ready_future<NodeExtentRef>(e);
alloc_iertr::future<NodeExtentRef> alloc_extent(
Transaction& t, laddr_t hint, extent_len_t len) override {
- TRACET("allocating {}B with hint {:#x} ...", t, len, hint);
+ SUBTRACET(seastore_onode, "allocating {}B with hint {:#x} ...", t, len, hint);
if constexpr (INJECT_EAGAIN) {
if (trigger_eagain()) {
- DEBUGT("allocating {}B: trigger eagain", t, len);
+ SUBDEBUGT(seastore_onode, "allocating {}B: trigger eagain", t, len);
t.test_set_conflict();
return alloc_iertr::make_ready_future<NodeExtentRef>();
}
}
return tm.alloc_extent<SeastoreNodeExtent>(t, hint, len
).si_then([len, &t](auto extent) {
- DEBUGT("allocated {}B at {:#x} -- {}",
- t, extent->get_length(), extent->get_laddr(), *extent);
+ SUBDEBUGT(seastore_onode,
+ "allocated {}B at {:#x} -- {}",
+ t, extent->get_length(), extent->get_laddr(), *extent);
if (!extent->is_initial_pending()) {
- ERRORT("allocated {}B but got invalid extent: {}",
- t, len, *extent);
+ SUBERRORT(seastore_onode,
+ "allocated {}B but got invalid extent: {}",
+ t, len, *extent);
ceph_abort("fatal error");
}
assert(extent->get_length() == len);
LogicalCachedExtentRef extent = _extent;
auto addr = extent->get_laddr();
auto len = extent->get_length();
- DEBUGT("retiring {}B at {:#x} -- {} ...",
- t, len, addr, *extent);
+ SUBDEBUGT(seastore_onode,
+ "retiring {}B at {:#x} -- {} ...",
+ t, len, addr, *extent);
if constexpr (INJECT_EAGAIN) {
if (trigger_eagain()) {
- DEBUGT("retiring {}B at {:#x} -- {} : trigger eagain",
- t, len, addr, *extent);
+ SUBDEBUGT(seastore_onode,
+ "retiring {}B at {:#x} -- {} : trigger eagain",
+ t, len, addr, *extent);
t.test_set_conflict();
return retire_iertr::now();
}
}
return tm.dec_ref(t, extent).si_then([addr, len, &t] (unsigned cnt) {
assert(cnt == 0);
- TRACET("retired {}B at {:#x} ...", t, len, addr);
+ SUBTRACET(seastore_onode, "retired {}B at {:#x} ...", t, len, addr);
});
}
getsuper_iertr::future<Super::URef> get_super(
Transaction& t, RootNodeTracker& tracker) override {
- TRACET("get root ...", t);
+ SUBTRACET(seastore_onode, "get root ...", t);
if constexpr (INJECT_EAGAIN) {
if (trigger_eagain()) {
- DEBUGT("get root: trigger eagain", t);
+ SUBDEBUGT(seastore_onode, "get root: trigger eagain", t);
t.test_set_conflict();
return getsuper_iertr::make_ready_future<Super::URef>();
}
}
return tm.read_onode_root(t).si_then([this, &t, &tracker](auto root_addr) {
- TRACET("got root {:#x}", t, root_addr);
+ SUBTRACET(seastore_onode, "got root {:#x}", t, root_addr);
return Super::URef(new SeastoreSuper(t, tracker, root_addr, tm));
});
}
eagain_iertr::pass_further{},
crimson::ct_error::input_output_error::handle(
[FNAME, c, extent_size, is_level_tail, level] {
- ERRORT("EIO -- extent_size={}, is_level_tail={}, level={}",
- c.t, extent_size, is_level_tail, level);
+ SUBERRORT(seastore_onode,
+ "EIO -- extent_size={}, is_level_tail={}, level={}",
+ c.t, extent_size, is_level_tail, level);
ceph_abort("fatal error");
})
).si_then([is_level_tail, level](auto extent) {
std::tuple<match_stage_t, search_position_t>
erase(const search_position_t& pos) override {
LOG_PREFIX(OTree::Layout::erase);
- DEBUG("begin at erase_pos({}) ...", pos);
- if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
+ SUBDEBUG(seastore_onode, "begin at erase_pos({}) ...", pos);
+ if (unlikely(LOGGER(seastore_onode).is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- TRACE("-- dump\n{}", sos.str());
+ SUBTRACE(seastore_onode, "-- dump\n{}", sos.str());
}
auto [stage, next_or_last_pos] = extent.erase_replayable(cast_down<STAGE>(pos));
- DEBUG("done at erase_stage={}, n/l_pos({})", stage, next_or_last_pos);
- if (unlikely(LOGGER.is_enabled(seastar::log_level::trace))) {
+ SUBDEBUG(seastore_onode, "done at erase_stage={}, n/l_pos({})", stage, next_or_last_pos);
+ if (unlikely(LOGGER(seastore_onode).is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- TRACE("-- dump\n{}", sos.str());
+ SUBTRACE(seastore_onode, "-- dump\n{}", sos.str());
}
#ifndef NDEBUG
if (!is_keys_empty()) {
auto& left_node_stage = extent.read();
auto& right_node = dynamic_cast<NodeLayoutT&>(_right_node);
auto& right_node_stage = right_node.extent.read();
- if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
+ if (unlikely(LOGGER(seastore_onode).is_enabled(seastar::log_level::debug))) {
{
std::ostringstream sos;
dump(sos);
- DEBUG("-- left node dump\n{}", sos.str());
+ SUBDEBUG(seastore_onode, "-- left node dump\n{}", sos.str());
}
{
std::ostringstream sos;
right_node.dump(sos);
- DEBUG("-- right node dump\n{}", sos.str());
+ SUBDEBUG(seastore_onode, "-- right node dump\n{}", sos.str());
}
}
left_appender.wrap();
}
- if (unlikely(LOGGER.is_enabled(seastar::log_level::debug))) {
+ if (unlikely(LOGGER(seastore_onode).is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
dump(sos);
- DEBUG("-- merged node dump\n{}", sos.str());
+ SUBDEBUG(seastore_onode, "-- merged node dump\n{}", sos.str());
}
assert(merge_size == filled_size());
return normalize(std::move(left_last_pos));
search_position_t& insert_pos, match_stage_t& insert_stage,
node_offset_t& insert_size) override {
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))) {
+ SUBDEBUG(seastore_onode,
+ "begin at insert_pos({}), insert_stage={}, insert_size={}B ...",
+ insert_pos, insert_stage, insert_size);
+ if (unlikely(LOGGER(seastore_onode).is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- TRACE("-- dump\n{}", sos.str());
+ SUBTRACE(seastore_onode, "-- dump\n{}", sos.str());
}
auto ret = extent.template insert_replayable<KEY_TYPE>(
key, value, cast_down<STAGE>(insert_pos), insert_stage, insert_size);
- 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))) {
+ SUBDEBUG(seastore_onode,
+ "done at insert_pos({}), insert_stage={}, insert_size={}B",
+ insert_pos, insert_stage, insert_size);
+ if (unlikely(LOGGER(seastore_onode).is_enabled(seastar::log_level::trace))) {
std::ostringstream sos;
dump(sos);
- TRACE("-- dump\n{}", sos.str());
+ SUBTRACE(seastore_onode, "-- dump\n{}", sos.str());
}
validate_layout();
#ifndef NDEBUG
assert(_right_impl.node_type() == NODE_TYPE);
assert(_right_impl.field_type() == FIELD_TYPE);
auto& right_impl = dynamic_cast<NodeLayoutT&>(_right_impl);
- 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))) {
+ SUBINFO(seastore_onode,
+ "begin at insert_pos({}), insert_stage={}, insert_size={}B ...",
+ _insert_pos, insert_stage, insert_size);
+ if (unlikely(LOGGER(seastore_onode).is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
dump(sos);
- DEBUG("-- dump\n{}", sos.str());
+ SUBDEBUG(seastore_onode, "-- 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;
- 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());
+ SUBDEBUG(seastore_onode,
+ "-- 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);
- DEBUG("-- right appended until "
- "insert_pos({}), insert_stage={}, insert/append the rest ...",
- insert_pos, insert_stage);
+ SUBDEBUG(seastore_onode,
+ "-- 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 {
- DEBUG("-- right appending ...");
+ SUBDEBUG(seastore_onode, "-- 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(seastore_onode).is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
right_impl.dump(sos);
- DEBUG("-- right node dump\n{}", sos.str());
+ SUBDEBUG(seastore_onode, "-- right node dump\n{}", sos.str());
}
right_impl.validate_layout();
// mutate left node
if (is_insert_left) {
- DEBUG("-- left trim/insert at insert_pos({}), insert_stage={} ...",
- insert_pos, insert_stage);
+ SUBDEBUG(seastore_onode,
+ "-- 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 {
- DEBUG("-- left trim ...");
+ SUBDEBUG(seastore_onode, "-- 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(seastore_onode).is_enabled(seastar::log_level::debug))) {
std::ostringstream sos;
dump(sos);
- DEBUG("-- left node dump\n{}", sos.str());
+ SUBDEBUG(seastore_onode, "-- left node dump\n{}", sos.str());
}
validate_layout();
assert(p_value);
auto split_pos = normalize(split_at.get_pos());
- 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);
+ SUBINFO(seastore_onode,
+ "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
const search_position_t& pos, laddr_t dst, laddr_t src) override {
if constexpr (NODE_TYPE == node_type_t::INTERNAL) {
LOG_PREFIX(OTree::Layout::replace_child_addr);
- DEBUG("update from {:#x} to {:#x} at pos({}) ...", src, dst, pos);
+ SUBDEBUG(seastore_onode, "update from {:#x} to {:#x} at pos({}) ...", src, dst, pos);
const laddr_packed_t* p_value;
if (pos.is_end()) {
assert(is_level_tail());
insert(Transaction& t, const ghobject_t& obj, tree_value_config_t _vconf) {
LOG_PREFIX(OTree::insert);
if (_vconf.payload_size > value_builder.get_max_value_payload_size()) {
- ERRORT("value payload size {} too large to insert {}",
- t, _vconf.payload_size, key_hobj_t{obj});
+ SUBERRORT(seastore_onode, "value payload size {} too large to insert {}",
+ t, _vconf.payload_size, key_hobj_t{obj});
return crimson::ct_error::value_too_large::make();
}
if (obj.hobj.nspace.size() > value_builder.get_max_ns_size()) {
- ERRORT("namespace size {} too large to insert {}",
- t, obj.hobj.nspace.size(), key_hobj_t{obj});
+ SUBERRORT(seastore_onode, "namespace size {} too large to insert {}",
+ t, obj.hobj.nspace.size(), key_hobj_t{obj});
return crimson::ct_error::value_too_large::make();
}
if (obj.hobj.oid.name.size() > value_builder.get_max_oid_size()) {
- ERRORT("oid size {} too large to insert {}",
- t, obj.hobj.oid.name.size(), key_hobj_t{obj});
+ SUBERRORT(seastore_onode, "oid size {} too large to insert {}",
+ t, obj.hobj.oid.name.size(), key_hobj_t{obj});
return crimson::ct_error::value_too_large::make();
}
value_config_t vconf{value_builder.get_header_magic(), _vconf.payload_size};
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
+ return crimson::get_logger(ceph_subsys_seastore_tm);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_filestore);
+ return crimson::get_logger(ceph_subsys_seastore_tm);
}
}
using std::string;
using crimson::common::local_conf;
+SET_SUBSYS(seastore);
+
namespace crimson::os::seastore {
class FileMDStore final : public SeaStore::MDStore {
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_tm);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_cleaner);
}
}
+SET_SUBSYS(seastore_cleaner);
+
namespace crimson::os::seastore {
void segment_info_set_t::segment_info_t::set_open() {
auto& sm_info = sm_infos[segment_id.device_id()];
auto iter = sm_info->open_segment_avails.find(segment_id);
if (iter == sm_info->open_segment_avails.end()) {
- crimson::get_logger(ceph_subsys_seastore).error(
+ crimson::get_logger(ceph_subsys_seastore_cleaner).error(
"SegmentCleaner::update_segment_avail_bytes:"
":segment closed {}, not updating",
offset);
}
auto new_avail_bytes = sm_info->segment_size - offset.as_seg_paddr().get_segment_off();
if (iter->second < new_avail_bytes) {
- crimson::get_logger(ceph_subsys_seastore).error(
+ crimson::get_logger(ceph_subsys_seastore_cleaner).error(
"SegmentCleaner::update_segment_avail_bytes:"
" avail_bytes increased? , {}, {}",
iter->second,
bool detailed = false);
void mount(device_id_t pdevice_id, std::vector<SegmentManager*>& sms) {
- crimson::get_logger(ceph_subsys_seastore).debug(
+ crimson::get_logger(ceph_subsys_seastore_cleaner).debug(
"SegmentCleaner::mount: {} segment managers", sms.size());
init_complete = false;
stats = {};
segment_seq_t seq,
bool out_of_line) final
{
- crimson::get_logger(ceph_subsys_seastore).debug(
+ crimson::get_logger(ceph_subsys_seastore_cleaner).debug(
"SegmentCleaner::init_mark_segment_closed: segment {}, seq {}",
segment,
seq);
}
}
if (id != NULL_SEG_ID) {
- crimson::get_logger(ceph_subsys_seastore).debug(
+ crimson::get_logger(ceph_subsys_seastore_cleaner).debug(
"SegmentCleaner::get_next_gc_target: segment {} seq {}",
id,
seq);
}
void log_gc_state(const char *caller) const {
- auto &logger = crimson::get_logger(ceph_subsys_seastore);
+ auto &logger = crimson::get_logger(ceph_subsys_seastore_cleaner);
if (logger.is_enabled(seastar::log_level::debug)) {
logger.debug(
"SegmentCleaner::log_gc_state({}): "
stats.empty_segments--;
}
segments.segment_closed(segment);
- crimson::get_logger(ceph_subsys_seastore).info(
+ crimson::get_logger(ceph_subsys_seastore_cleaner).info(
"mark closed: {} empty_segments: {}"
", opened_segments {}, should_block_on_gc {}"
", projected_avail_ratio {}, projected_reclaim_ratio {}",
}
segment_info.set_empty();
stats.empty_segments++;
- crimson::get_logger(ceph_subsys_seastore
+ crimson::get_logger(ceph_subsys_seastore_cleaner
).info("mark empty: {}, empty_segments {}"
", opened_segments {}, should_block_on_gc {}"
", projected_avail_ratio {}, projected_reclaim_ratio {}",
segments[segment].set_open();
assert(stats.empty_segments > 0);
stats.empty_segments--;
- crimson::get_logger(ceph_subsys_seastore
+ crimson::get_logger(ceph_subsys_seastore_cleaner
).info("mark open: {}, empty_segments {}"
", opened_segments {}, should_block_on_gc {}"
", projected_avail_ratio {}, projected_reclaim_ratio {}",
namespace{
seastar::logger &logger(){
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_device);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_device);
}
}
namespace {
seastar::logger& logger() {
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_device);
}
}
namespace {
seastar::logger &logger(){
- return crimson::get_logger(ceph_subsys_seastore);
+ return crimson::get_logger(ceph_subsys_seastore_device);
}
}
iter != write_set.end()) {
if (out)
*out = CachedExtentRef(&*iter);
- TRACET("Found offset {} in write_set: {}", *this, addr, *iter);
+ SUBTRACET(seastore_tm, "Found offset {} in write_set: {}", *this, addr, *iter);
return get_extent_ret::PRESENT;
} else if (
auto iter = read_set.find(addr);
assert(iter->ref->get_type() != extent_types_t::RETIRED_PLACEHOLDER);
if (out)
*out = iter->ref;
- TRACET("Found offset {} in read_set: {}", *this, addr, *(iter->ref));
+ SUBTRACET(seastore_tm, "Found offset {} in read_set: {}", *this, addr, *(iter->ref));
return get_extent_ret::PRESENT;
} else {
return get_extent_ret::ABSENT;
}
++fresh_block_stats.num;
fresh_block_stats.bytes += ref->get_length();
- TRACET("adding {} to write_set", *this, *ref);
+ SUBTRACET(seastore_tm, "adding {} to write_set", *this, *ref);
write_set.insert(*ref);
}
void mark_delayed_extent_inline(LogicalCachedExtentRef& ref) {
LOG_PREFIX(Transaction::mark_delayed_extent_inline);
- TRACET("removing {} from write_set", *this, *ref);
+ SUBTRACET(seastore_tm, "removing {} from write_set", *this, *ref);
write_set.erase(*ref);
ref->set_paddr(make_record_relative_paddr(offset));
offset += ref->get_length();
inline_block_list.push_back(ref);
- TRACET("adding {} to write_set", *this, *ref);
+ SUBTRACET(seastore_tm, "adding {} to write_set", *this, *ref);
write_set.insert(*ref);
}
void mark_delayed_extent_ool(LogicalCachedExtentRef& ref, paddr_t final_addr) {
LOG_PREFIX(Transaction::mark_delayed_extent_ool);
- TRACET("removing {} from write_set", *this, *ref);
+ SUBTRACET(seastore_tm, "removing {} from write_set", *this, *ref);
write_set.erase(*ref);
ref->set_paddr(final_addr);
assert(!ref->get_paddr().is_null());
assert(!ref->is_inline());
ool_block_list.push_back(ref);
- TRACET("adding {} to write_set", *this, *ref);
+ SUBTRACET(seastore_tm, "adding {} to write_set", *this, *ref);
write_set.insert(*ref);
}
ceph_assert(!is_weak());
assert(read_set.count(ref->prior_instance->get_paddr()));
mutated_block_list.push_back(ref);
- TRACET("adding {} to write_set", *this, *ref);
+ SUBTRACET(seastore_tm, "adding {} to write_set", *this, *ref);
write_set.insert(*ref);
}
#include "crimson/os/seastore/segment_manager.h"
#include "crimson/os/seastore/journal.h"
+SET_SUBSYS(seastore_tm);
+
namespace crimson::os::seastore {
TransactionManager::TransactionManager(
return seastar::stop_iteration::yes;
}).handle_error(
[FNAME](const crimson::ct_error::eagain &e) {
- DEBUG("hit eagain, restarting");
+ SUBDEBUG(seastore_tm, "hit eagain, restarting");
return seastar::stop_iteration::no;
},
crimson::ct_error::pass_further_all{}
LBAPinRef pin) {
LOG_PREFIX(TransactionManager::pin_to_extent);
using ret = pin_to_extent_ret<T>;
- DEBUGT("getting extent {}", t, *pin);
+ SUBDEBUGT(seastore_tm, "getting extent {}", t, *pin);
auto &pref = *pin;
return cache->get_extent<T>(
t,
lba_manager->add_pin(extent.get_pin());
}
).si_then([FNAME, &t](auto ref) mutable -> ret {
- DEBUGT("got extent {}", t, *ref);
+ SUBDEBUGT(seastore_tm, "got extent {}", t, *ref);
return pin_to_extent_ret<T>(
interruptible::ready_future_marker{},
std::move(ref));
t, offset
).si_then([this, FNAME, &t, offset, length] (auto pin) {
if (length != pin->get_length() || !pin->get_paddr().is_real()) {
- ERRORT("offset {} len {} got wrong pin {}",
- t, offset, length, *pin);
+ SUBERRORT(seastore_tm,
+ "offset {} len {} got wrong pin {}",
+ t, offset, length, *pin);
ceph_assert(0 == "Should be impossible");
}
return this->pin_to_extent<T>(t, std::move(pin));
t, offset
).si_then([this, FNAME, &t, offset] (auto pin) {
if (!pin->get_paddr().is_real()) {
- ERRORT("offset {} got wrong pin {}",
- t, offset, *pin);
+ SUBERRORT(seastore_tm,
+ "offset {} got wrong pin {}",
+ t, offset, *pin);
ceph_assert(0 == "Should be impossible");
}
return this->pin_to_extent<T>(t, std::move(pin));
stats.extents_mutated_total++;
stats.extents_mutated_bytes += ret->get_length();
if (!ret->has_pin()) {
- DEBUGT(
+ SUBDEBUGT(seastore_tm,
"duplicating {} for write: {}",
t,
*ref,
*ret);
ret->set_pin(ref->get_pin().duplicate());
} else {
- DEBUGT(
+ SUBDEBUGT(seastore_tm,
"{} already pending",
t,
*ref);
ext->set_pin(std::move(ref));
stats.extents_allocated_total++;
stats.extents_allocated_bytes += len;
- DEBUGT("new extent: {}, laddr_hint: {}", t, *ext, laddr_hint);
+ SUBDEBUGT(seastore_tm, "new extent: {}, laddr_hint: {}", t, *ext, laddr_hint);
return alloc_extent_iertr::make_ready_future<TCachedExtentRef<T>>(
std::move(ext));
});
void add_segment_manager(SegmentManager* sm) {
LOG_PREFIX(TransactionManager::add_segment_manager);
- DEBUG("adding segment manager {}", sm->get_device_id());
+ SUBDEBUG(seastore_tm, "adding segment manager {}", sm->get_device_id());
scanner.add_segment_manager(sm);
epm->add_allocator(
device_type_t::SEGMENTED,
projects / ceph.git / commitdiff