return sm_group->read_segment_header(
segment_id
).safe_then([segment_id, this, FNAME](auto header) {
- INFO("segment_id={} -- {}", segment_id, header);
+ DEBUG("segment_id={} -- {}", segment_id, header);
auto s_type = header.get_type();
if (s_type == segment_type_t::NULL_SEG) {
ERROR("got null segment, segment_id={} -- {}", segment_id, header);
const segment_header_t &segment_header,
segment_id_t segment_id)
{
+ LOG_PREFIX(AsyncCleaner::scan_no_tail_segment);
+ INFO("scan {} {}", segment_id, segment_header);
return seastar::do_with(
scan_valid_records_cursor({
segments[segment_id].seq,
paddr_t::make_seg_paddr(segment_id, 0)
}),
SegmentManagerGroup::found_record_handler_t(
- [this, segment_id, segment_header](
+ [this, segment_id, segment_header, FNAME](
record_locator_t locator,
const record_group_header_t &record_group_header,
const bufferlist& mdbuf
) mutable -> SegmentManagerGroup::scan_valid_records_ertr::future<>
{
- LOG_PREFIX(AsyncCleaner::scan_no_tail_segment);
DEBUG("{} {}, decoding {} records",
segment_id, segment_header.get_type(), record_group_header.records);
root = nullptr;
}
root = new RootBlock();
- root->state = CachedExtent::extent_state_t::CLEAN;
+ root->init(CachedExtent::extent_state_t::CLEAN,
+ P_ADDR_NULL,
+ PLACEMENT_HINT_NULL,
+ NULL_GENERATION);
INFO("init root -- {}", *root);
extents.insert(*root);
}
<< ", last_committed_crc=" << last_committed_crc
<< ", refcount=" << use_count()
<< ", user_hint=" << user_hint
- << ", reclaim_gen=" << reclaim_generation;
+ << ", reclaim_gen=" << reclaim_gen_printer_t{reclaim_generation};
if (state != extent_state_t::INVALID &&
state != extent_state_t::CLEAN_PENDING) {
print_detail(out);
type,
category,
gen};
- INFO("{} writing header to new segment ... -- {}",
- print_name, header);
+ INFO("{} writing header {}", print_name, header);
auto header_length = get_block_size();
bufferlist bl;
oss << fmt::format("{}_G{}", category, gen);
print_name = oss.str();
- INFO("{}", print_name);
+ DEBUG("{}", print_name);
return do_open(is_mkfs);
}
return [this] {
LOG_PREFIX(SegmentAllocator::close);
if (current_segment) {
- INFO("{} close current segment", print_name);
+ DEBUG("{} close current segment", print_name);
return close_segment();
} else {
INFO("{} no current segment", print_name);
close_seg_info.num_extents};
ceph::bufferlist bl;
encode(tail, bl);
- INFO("{} close segment id={}, seq={}, written_to={}, nonce={}",
+ INFO("{} close segment {}, written_to={}",
print_name,
- close_segment_id,
- close_seg_info.seq,
- written_to,
- current_segment_nonce);
+ tail,
+ written_to);
bufferptr bp(ceph::buffer::create_page_aligned(get_block_size()));
bp.zero();
auto last_header = segments.rbegin()->second;
return scan_last_segment(last_segment_id, last_header
).safe_then([this, FNAME, segments=std::move(segments)] {
+ INFO("dirty_tail={}, alloc_tail={}",
+ segment_provider.get_dirty_tail(),
+ segment_provider.get_alloc_tail());
auto journal_tail = segment_provider.get_journal_tail();
auto journal_tail_paddr = journal_tail.offset;
ceph_assert(journal_tail != JOURNAL_SEQ_NULL);
}
auto num_segments = segments.end() - from;
- INFO("{} segments to replay from {}",
- num_segments, journal_tail);
+ INFO("{} segments to replay", num_segments);
auto ret = replay_segments_t(num_segments);
std::transform(
from, segments.end(), ret.begin(),
segment_header.segment_seq,
paddr_t::make_seg_paddr(segment_id, 0)
};
- INFO("scanning {} for journal tail deltas", seq);
+ INFO("scanning journal tail deltas -- {}", segment_header);
return seastar::do_with(
scan_valid_records_cursor(seq),
SegmentManagerGroup::found_record_handler_t(
journal_tail_delta_t tail_delta;
decode(tail_delta, delta.bl);
auto start_seq = locator.write_result.start_seq;
- INFO("got {}, at seq {}", tail_delta, start_seq);
+ DEBUG("got {}, at {}", tail_delta, start_seq);
ceph_assert(tail_delta.dirty_tail != JOURNAL_SEQ_NULL);
ceph_assert(tail_delta.alloc_tail != JOURNAL_SEQ_NULL);
segment_provider.update_journal_tails(
LOG_PREFIX(SegmentManagerGroup::find_journal_segment_headers);
auto device_id = sm->get_device_id();
auto num_segments = sm->get_num_segments();
- INFO("processing {} with {} segments",
- device_id_printer_t{device_id}, num_segments);
+ DEBUG("processing {} with {} segments",
+ device_id_printer_t{device_id}, num_segments);
return crimson::do_for_each(
boost::counting_iterator<device_segment_id_t>(0),
boost::counting_iterator<device_segment_id_t>(num_segments),
private:
void set_next_segment_seq(segment_seq_t seq) {
LOG_PREFIX(SegmentSeqAllocator::set_next_segment_seq);
- SUBINFO(
+ SUBDEBUG(
seastore_journal,
- "type {}, next_segment_seq={}, cur_segment_seq={}",
+ "{}, next={}, cur={}",
type,
segment_seq_printer_t{seq},
segment_seq_printer_t{next_segment_seq});