From b635eb03b0eb14919f0eda7b31f1ac291c325203 Mon Sep 17 00:00:00 2001 From: Yingxin Cheng Date: Tue, 15 Mar 2022 09:26:50 +0800 Subject: [PATCH] crimson/os/seastore/../segment_allocator: improve log name with device-id, cleanup Also clean up segment type related special handling. Signed-off-by: Yingxin Cheng --- .../os/seastore/journal/segment_allocator.cc | 71 +++++++------------ .../os/seastore/journal/segment_allocator.h | 50 ++++++++++--- 2 files changed, 69 insertions(+), 52 deletions(-) diff --git a/src/crimson/os/seastore/journal/segment_allocator.cc b/src/crimson/os/seastore/journal/segment_allocator.cc index 01ac3e01c93..cf932e554cd 100644 --- a/src/crimson/os/seastore/journal/segment_allocator.cc +++ b/src/crimson/os/seastore/journal/segment_allocator.cc @@ -3,6 +3,8 @@ #include "segment_allocator.h" +#include + #include "crimson/os/seastore/logging.h" #include "crimson/os/seastore/segment_cleaner.h" @@ -10,16 +12,6 @@ SET_SUBSYS(seastore_journal); namespace crimson::os::seastore::journal { -static segment_nonce_t generate_nonce( - segment_seq_t seq, - const seastore_meta_t &meta) -{ - return ceph_crc32c( - seq, - reinterpret_cast(meta.seastore_id.bytes()), - sizeof(meta.seastore_id.uuid)); -} - SegmentAllocator::SegmentAllocator( std::string name, segment_type_t type, @@ -31,14 +23,17 @@ SegmentAllocator::SegmentAllocator( segment_manager{sm} { ceph_assert(type != segment_type_t::NULL_SEG); + std::ostringstream oss; + oss << "D?_" << name; + print_name = oss.str(); reset(); } void SegmentAllocator::set_next_segment_seq(segment_seq_t seq) { LOG_PREFIX(SegmentAllocator::set_next_segment_seq); - INFO("{} {} next_segment_seq={}", - name, get_device_id(), segment_seq_printer_t{seq}); + INFO("{} next_segment_seq={}", + print_name, segment_seq_printer_t{seq}); assert(type == segment_seq_to_type(seq)); next_segment_seq = seq; } @@ -48,14 +43,10 @@ SegmentAllocator::open() { LOG_PREFIX(SegmentAllocator::open); ceph_assert(!current_segment); - segment_seq_t new_segment_seq; - if (type == segment_type_t::JOURNAL) { - new_segment_seq = next_segment_seq++; - } else { // OOL - new_segment_seq = next_segment_seq; - } - assert(new_segment_seq == get_current_segment_seq()); - ceph_assert(segment_seq_to_type(new_segment_seq) == type); + std::ostringstream oss; + oss << "D" << device_id_printer_t{get_device_id()} << "_" << name; + print_name = oss.str(); + segment_seq_t new_segment_seq = get_new_segment_seq_and_increment(); auto new_segment_id = segment_provider.get_segment( get_device_id(), new_segment_seq); return segment_manager.open(new_segment_id @@ -69,11 +60,8 @@ SegmentAllocator::open() journal_seq_t new_journal_tail; if (type == segment_type_t::JOURNAL) { new_journal_tail = segment_provider.get_journal_tail_target(); - current_segment_nonce = generate_nonce( - new_segment_seq, segment_manager.get_meta()); } else { // OOL new_journal_tail = NO_DELTAS; - assert(current_segment_nonce == 0); } segment_id_t segment_id = sref->get_segment_id(); auto header = segment_header_t{ @@ -81,8 +69,8 @@ SegmentAllocator::open() segment_id, new_journal_tail, current_segment_nonce}; - INFO("{} {} writing header to new segment ... -- {}", - name, get_device_id(), header); + INFO("{} writing header to new segment ... -- {}", + print_name, header); auto header_length = segment_manager.get_block_size(); bufferlist bl; @@ -121,8 +109,8 @@ SegmentAllocator::open() if (type == segment_type_t::JOURNAL) { segment_provider.update_journal_tail_committed(new_journal_tail); } - DEBUG("{} {} rolled new segment id={}", - name, get_device_id(), current_segment->get_segment_id()); + DEBUG("{} rolled new segment id={}", + print_name, current_segment->get_segment_id()); ceph_assert(new_journal_seq.segment_seq == get_current_segment_seq()); return new_journal_seq; }); @@ -150,7 +138,7 @@ SegmentAllocator::write(ceph::bufferlist to_write) paddr_t::make_seg_paddr( current_segment->get_segment_id(), write_start_offset) }; - TRACE("{} {} {}~{}", name, get_device_id(), write_start_seq, write_length); + TRACE("{} {}~{}", print_name, write_start_seq, write_length); assert(write_length > 0); assert((write_length % segment_manager.get_block_size()) == 0); assert(!needs_roll(write_length)); @@ -187,7 +175,7 @@ SegmentAllocator::close() if (current_segment) { return close_segment(false); } else { - INFO("{} {} no current segment", name, get_device_id()); + INFO("{} no current segment", print_name); return close_segment_ertr::now(); } }().finally([this] { @@ -200,9 +188,11 @@ SegmentAllocator::close_segment(bool is_rolling) { LOG_PREFIX(SegmentAllocator::close_segment); assert(can_write()); - auto close_segment_id = current_segment->get_segment_id(); - INFO("{} {} close segment id={}, seq={}, written_to={}, nonce={}", - name, get_device_id(), + // Note: make sure no one can access the current segment once closing + auto seg_to_close = std::move(current_segment); + auto close_segment_id = seg_to_close->get_segment_id(); + INFO("{} close segment id={}, seq={}, written_to={}, nonce={}", + print_name, close_segment_id, segment_seq_printer_t{get_current_segment_seq()}, written_to, @@ -210,12 +200,6 @@ SegmentAllocator::close_segment(bool is_rolling) if (is_rolling) { segment_provider.close_segment(close_segment_id); } - segment_seq_t cur_segment_seq; - if (type == segment_type_t::JOURNAL) { - cur_segment_seq = next_segment_seq - 1; - } else { // OOL - cur_segment_seq = next_segment_seq; - } journal_seq_t cur_journal_tail; if (type == segment_type_t::JOURNAL) { cur_journal_tail = segment_provider.get_journal_tail_target(); @@ -223,7 +207,7 @@ SegmentAllocator::close_segment(bool is_rolling) cur_journal_tail = NO_DELTAS; } auto tail = segment_tail_t{ - cur_segment_seq, + get_current_segment_seq(), close_segment_id, cur_journal_tail, current_segment_nonce, @@ -245,13 +229,12 @@ SegmentAllocator::close_segment(bool is_rolling) assert(bl.length() == (size_t)segment_manager.get_rounded_tail_length()); - return current_segment->write( + return seg_to_close->write( segment_manager.get_segment_size() - segment_manager.get_rounded_tail_length(), - bl).safe_then([this] { - return current_segment->close(); - }).safe_then([this] { - current_segment.reset(); + bl + ).safe_then([seg_to_close=std::move(seg_to_close)] { + return seg_to_close->close(); }).handle_error( close_segment_ertr::pass_further{}, crimson::ct_error::assert_all{ diff --git a/src/crimson/os/seastore/journal/segment_allocator.h b/src/crimson/os/seastore/journal/segment_allocator.h index a09c1667b56..c96ebbf4443 100644 --- a/src/crimson/os/seastore/journal/segment_allocator.h +++ b/src/crimson/os/seastore/journal/segment_allocator.h @@ -34,7 +34,7 @@ class SegmentAllocator { SegmentManager &sm); const std::string& get_name() const { - return name; + return print_name; } device_id_t get_device_id() const { @@ -107,19 +107,29 @@ class SegmentAllocator { private: void reset() { current_segment.reset(); - if (type == segment_type_t::JOURNAL) { - next_segment_seq = 0; - } else { // OOL - next_segment_seq = OOL_SEG_SEQ; - } - current_segment_nonce = 0; written_to = 0; + + // segment type related special handling + reset_segment_seq(); + current_segment_nonce = 0; } // FIXME: remove the unnecessary is_rolling using close_segment_ertr = base_ertr; close_segment_ertr::future<> close_segment(bool is_rolling); + /* + * segment type related special handling + */ + + void reset_segment_seq() { + if (type == segment_type_t::JOURNAL) { + next_segment_seq = 0; + } else { // OOL + next_segment_seq = OOL_SEG_SEQ; + } + } + segment_seq_t get_current_segment_seq() const { segment_seq_t ret; if (type == segment_type_t::JOURNAL) { @@ -132,14 +142,38 @@ class SegmentAllocator { return ret; } + segment_seq_t get_new_segment_seq_and_increment() { + segment_seq_t new_segment_seq; + if (type == segment_type_t::JOURNAL) { + new_segment_seq = next_segment_seq++; + auto meta = segment_manager.get_meta(); + current_segment_nonce = ceph_crc32c( + new_segment_seq, + reinterpret_cast(meta.seastore_id.bytes()), + sizeof(meta.seastore_id.uuid)); + } else { // OOL + new_segment_seq = next_segment_seq; + assert(current_segment_nonce == 0); + } + assert(new_segment_seq == get_current_segment_seq()); + ceph_assert(segment_seq_to_type(new_segment_seq) == type); + return new_segment_seq; + } + const std::string name; + // device id is not available during construction, + // so generate the print_name later. + std::string print_name; const segment_type_t type; // JOURNAL or OOL SegmentProvider &segment_provider; SegmentManager &segment_manager; SegmentRef current_segment; + seastore_off_t written_to; + + // segment type related special handling segment_seq_t next_segment_seq; segment_nonce_t current_segment_nonce; - seastore_off_t written_to; + //3. journal tail written to both segment_header_t and segment_tail_t }; /** -- 2.39.5