From 1daf02b583e49eb7203931309c5384da9bf3b044 Mon Sep 17 00:00:00 2001 From: Yingxin Cheng Date: Thu, 24 Mar 2022 14:31:03 +0800 Subject: [PATCH] crimson/os/seastore: rename ExtentReader to SegmentManagerGroup Signed-off-by: Yingxin Cheng --- src/crimson/os/seastore/CMakeLists.txt | 2 +- src/crimson/os/seastore/journal.cc | 4 +- src/crimson/os/seastore/journal.h | 4 +- .../os/seastore/journal/segmented_journal.cc | 12 ++--- .../os/seastore/journal/segmented_journal.h | 8 ++-- src/crimson/os/seastore/segment_cleaner.cc | 32 ++++++------- src/crimson/os/seastore/segment_cleaner.h | 14 +++--- ...ent_reader.cc => segment_manager_group.cc} | 48 ++++++++++--------- ...xtent_reader.h => segment_manager_group.h} | 10 ++-- .../os/seastore/transaction_manager.cc | 16 +++---- src/crimson/os/seastore/transaction_manager.h | 7 +-- .../seastore/test_btree_lba_manager.cc | 12 ++--- .../crimson/seastore/test_seastore_journal.cc | 12 ++--- 13 files changed, 90 insertions(+), 91 deletions(-) rename src/crimson/os/seastore/{extent_reader.cc => segment_manager_group.cc} (90%) rename src/crimson/os/seastore/{extent_reader.h => segment_manager_group.h} (95%) diff --git a/src/crimson/os/seastore/CMakeLists.txt b/src/crimson/os/seastore/CMakeLists.txt index a10d1c677d8db..2e3ec4a5fe036 100644 --- a/src/crimson/os/seastore/CMakeLists.txt +++ b/src/crimson/os/seastore/CMakeLists.txt @@ -7,7 +7,6 @@ set(crimson_seastore_srcs transaction_manager.cc transaction.cc cache.cc - extent_reader.cc lba_manager.cc segment_cleaner.cc lba_manager/btree/btree_lba_manager.cc @@ -40,6 +39,7 @@ set(crimson_seastore_srcs journal/segment_allocator.cc journal.cc device.cc + segment_manager_group.cc ../../../test/crimson/seastore/test_block.cc ${PROJECT_SOURCE_DIR}/src/os/Transaction.cc ) diff --git a/src/crimson/os/seastore/journal.cc b/src/crimson/os/seastore/journal.cc index 56e582390dc27..2ed4d49739a72 100644 --- a/src/crimson/os/seastore/journal.cc +++ b/src/crimson/os/seastore/journal.cc @@ -8,10 +8,10 @@ namespace crimson::os::seastore::journal { JournalRef make_segmented( SegmentManager &sm, - ExtentReader &reader, + SegmentManagerGroup &sms, SegmentProvider &provider) { - return std::make_unique(sm, reader, provider); + return std::make_unique(sm, sms, provider); } } diff --git a/src/crimson/os/seastore/journal.h b/src/crimson/os/seastore/journal.h index 77ecc34df93b7..b0448d7e9508f 100644 --- a/src/crimson/os/seastore/journal.h +++ b/src/crimson/os/seastore/journal.h @@ -16,7 +16,7 @@ class NVMeBlockDevice; } class SegmentManager; -class ExtentReader; +class SegmentManagerGroup; class SegmentProvider; class Journal { @@ -93,7 +93,7 @@ namespace journal { JournalRef make_segmented( SegmentManager &sm, - ExtentReader &reader, + SegmentManagerGroup &sms, SegmentProvider &provider); } diff --git a/src/crimson/os/seastore/journal/segmented_journal.cc b/src/crimson/os/seastore/journal/segmented_journal.cc index e4a29d795ef6a..18b29e50fab1e 100644 --- a/src/crimson/os/seastore/journal/segmented_journal.cc +++ b/src/crimson/os/seastore/journal/segmented_journal.cc @@ -28,7 +28,7 @@ namespace crimson::os::seastore::journal { SegmentedJournal::SegmentedJournal( SegmentManager &segment_manager, - ExtentReader &scanner, + SegmentManagerGroup &sms, SegmentProvider &segment_provider) : segment_provider(segment_provider), segment_seq_allocator( @@ -47,7 +47,7 @@ SegmentedJournal::SegmentedJournal( crimson::common::get_conf( "seastore_journal_batch_preferred_fullness"), journal_segment_allocator), - scanner(scanner) + sms(sms) { } @@ -150,12 +150,12 @@ SegmentedJournal::replay_segment( INFO("starting at {} -- {}", seq, header); return seastar::do_with( scan_valid_records_cursor(seq), - ExtentReader::found_record_handler_t( + SegmentManagerGroup::found_record_handler_t( [s_type=header.type, &handler, this]( record_locator_t locator, const record_group_header_t& header, const bufferlist& mdbuf) - -> ExtentReader::scan_valid_records_ertr::future<> + -> SegmentManagerGroup::scan_valid_records_ertr::future<> { LOG_PREFIX(Journal::replay_segment); auto maybe_record_deltas_list = try_decode_deltas( @@ -233,7 +233,7 @@ SegmentedJournal::replay_segment( }); }), [=](auto &cursor, auto &dhandler) { - return scanner.scan_valid_records( + return sms.scan_valid_records( cursor, header.segment_nonce, std::numeric_limits::max(), @@ -262,7 +262,7 @@ SegmentedJournal::find_journal_segments() segment_id_t segment_id{ journal_segment_allocator.get_device_id(), d_segment_id}; - return scanner.read_segment_header( + return sms.read_segment_header( segment_id ).safe_then([segment_id, &ret](auto &&header) { if (header.get_type() == segment_type_t::JOURNAL) { diff --git a/src/crimson/os/seastore/journal/segmented_journal.h b/src/crimson/os/seastore/journal/segmented_journal.h index e571583bcb99f..973d04fd6f1ec 100644 --- a/src/crimson/os/seastore/journal/segmented_journal.h +++ b/src/crimson/os/seastore/journal/segmented_journal.h @@ -11,7 +11,7 @@ #include "crimson/os/seastore/segment_cleaner.h" #include "crimson/os/seastore/journal.h" -#include "crimson/os/seastore/extent_reader.h" +#include "crimson/os/seastore/segment_manager_group.h" #include "crimson/os/seastore/ordering_handle.h" #include "crimson/os/seastore/seastore_types.h" #include "crimson/osd/exceptions.h" @@ -26,7 +26,7 @@ class SegmentedJournal : public Journal { public: SegmentedJournal( SegmentManager &segment_manager, - ExtentReader& scanner, + SegmentManagerGroup& sms, SegmentProvider& cleaner); ~SegmentedJournal() {} @@ -56,10 +56,10 @@ private: SegmentSeqAllocatorRef segment_seq_allocator; SegmentAllocator journal_segment_allocator; RecordSubmitter record_submitter; - ExtentReader& scanner; + SegmentManagerGroup& sms; WritePipeline* write_pipeline = nullptr; - /// read journal segment headers from scanner + /// read journal segment headers from sms using find_journal_segments_ertr = crimson::errorator< crimson::ct_error::input_output_error>; using find_journal_segments_ret_bare = std::vector< diff --git a/src/crimson/os/seastore/segment_cleaner.cc b/src/crimson/os/seastore/segment_cleaner.cc index f629f7e818108..085fe74994ffe 100644 --- a/src/crimson/os/seastore/segment_cleaner.cc +++ b/src/crimson/os/seastore/segment_cleaner.cc @@ -178,11 +178,11 @@ void SpaceTrackerSimple::dump_usage(segment_id_t id) const SegmentCleaner::SegmentCleaner( config_t config, - ExtentReaderRef&& scr, + SegmentManagerGroupRef&& sm_group, bool detailed) : detailed(detailed), config(config), - scanner(std::move(scr)), + sm_group(std::move(sm_group)), ool_segment_seq_allocator( new SegmentSeqAllocator(segment_type_t::OOL)), gc_process(*this) @@ -391,7 +391,7 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() return seastar::now(); } scan_cursor = - std::make_unique( + std::make_unique( next); logger().debug( "SegmentCleaner::do_gc: starting gc on segment {}", @@ -400,7 +400,7 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() ceph_assert(!scan_cursor->is_complete()); } - return scanner->scan_extents( + return sm_group->scan_extents( *scan_cursor, config.reclaim_bytes_stride ).safe_then([this](auto &&_extents) { @@ -505,7 +505,7 @@ SegmentCleaner::gc_reclaim_space_ret SegmentCleaner::gc_reclaim_space() SegmentCleaner::mount_ret SegmentCleaner::mount( device_id_t pdevice_id) { - auto& sms = scanner->get_segment_managers(); + auto& sms = sm_group->get_segment_managers(); logger().debug( "SegmentCleaner::mount: {} segment managers", sms.size()); init_complete = false; @@ -545,20 +545,20 @@ SegmentCleaner::mount_ret SegmentCleaner::mount( segments.end(), [this, &segment_set](auto& it) { auto segment_id = it.first; - return scanner->read_segment_header( + return sm_group->read_segment_header( segment_id ).safe_then([segment_id, this, &segment_set](auto header) { logger().debug( - "ExtentReader::mount: segment_id={} -- {}", + "SegmentCleaner::mount: segment_id={} -- {}", segment_id, header); auto s_type = header.get_type(); if (s_type == segment_type_t::NULL_SEG) { logger().error( - "ExtentReader::mount: got null segment, segment_id={} -- {}", + "SegmentCleaner::mount: got null segment, segment_id={} -- {}", segment_id, header); ceph_abort(); } - return scanner->read_segment_tail( + return sm_group->read_segment_tail( segment_id ).safe_then([this, segment_id, &segment_set, header](auto tail) -> scan_extents_ertr::future<> { @@ -608,7 +608,7 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( { if (header.get_type() == segment_type_t::OOL) { logger().info( - "ExtentReader::init_segments: out-of-line segment {}", + "SegmentCleaner::scan_nonfull_segment: out-of-line segment {}", segment_id); return seastar::do_with( scan_valid_records_cursor({ @@ -616,11 +616,11 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( paddr_t::make_seg_paddr(segment_id, 0)}), [this, segment_id, header](auto& cursor) { return seastar::do_with( - ExtentReader::found_record_handler_t([this, segment_id]( + SegmentManagerGroup::found_record_handler_t([this, segment_id]( record_locator_t locator, const record_group_header_t& header, const bufferlist& mdbuf - ) mutable -> ExtentReader::scan_valid_records_ertr::future<> { + ) mutable -> SegmentManagerGroup::scan_valid_records_ertr::future<> { LOG_PREFIX(SegmentCleaner::scan_nonfull_segment); DEBUG("decodeing {} records", header.records); auto maybe_headers = try_decode_record_headers(header, mdbuf); @@ -634,7 +634,7 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( mod_time_point_t ctime = header.commit_time; auto commit_type = header.commit_type; if (!ctime) { - ERROR("Scanner::init_segments: extent {} 0 commit_time", + ERROR("SegmentCleaner::scan_nonfull_segment: extent {} 0 commit_time", ctime); ceph_abort("0 commit_time"); } @@ -654,7 +654,7 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( return seastar::now(); }), [&cursor, header, segment_id, this](auto& handler) { - return scanner->scan_valid_records( + return sm_group->scan_valid_records( cursor, header.segment_nonce, segments[segment_id.device_id()]->segment_size, @@ -670,7 +670,7 @@ SegmentCleaner::scan_extents_ret SegmentCleaner::scan_nonfull_segment( }); } else if (header.get_type() == segment_type_t::JOURNAL) { logger().info( - "ExtentReader::init_segments: journal segment {}", + "SEgmentCleaner::scan_nonfull_segment: journal segment {}", segment_id); segment_set.emplace_back(std::make_pair(segment_id, std::move(header))); } else { @@ -690,7 +690,7 @@ SegmentCleaner::maybe_release_segment(Transaction &t) if (to_release != NULL_SEG_ID) { LOG_PREFIX(SegmentCleaner::maybe_release_segment); INFOT("releasing segment {}", t, to_release); - return scanner->release_segment(to_release + return sm_group->release_segment(to_release ).safe_then([this, to_release] { stats.segments_released++; mark_empty(to_release); diff --git a/src/crimson/os/seastore/segment_cleaner.h b/src/crimson/os/seastore/segment_cleaner.h index e703b19793d68..df7c225ef8a50 100644 --- a/src/crimson/os/seastore/segment_cleaner.h +++ b/src/crimson/os/seastore/segment_cleaner.h @@ -12,9 +12,9 @@ #include "crimson/common/log.h" #include "crimson/os/seastore/cached_extent.h" -#include "crimson/os/seastore/extent_reader.h" #include "crimson/os/seastore/seastore_types.h" #include "crimson/os/seastore/segment_manager.h" +#include "crimson/os/seastore/segment_manager_group.h" #include "crimson/os/seastore/transaction.h" #include "crimson/os/seastore/segment_seq_allocator.h" @@ -667,7 +667,7 @@ private: const bool detailed; const config_t config; - ExtentReaderRef scanner; + SegmentManagerGroupRef sm_group; SpaceTrackerIRef space_tracker; segment_info_set_t segments; @@ -716,7 +716,7 @@ private: public: SegmentCleaner( config_t config, - ExtentReaderRef&& scanner, + SegmentManagerGroupRef&& sm_group, bool detailed = false); SegmentSeqAllocator& get_ool_segment_seq_allocator() { @@ -766,7 +766,7 @@ public: return segments[id].get_type(); } - using release_ertr = ExtentReader::release_ertr; + using release_ertr = SegmentManagerGroup::release_ertr; release_ertr::future<> maybe_release_segment(Transaction &t); void adjust_segment_util(double old_usage, double new_usage) { @@ -968,7 +968,7 @@ private: // GC status helpers std::unique_ptr< - ExtentReader::scan_extents_cursor + SegmentManagerGroup::scan_extents_cursor > scan_cursor; /** @@ -1046,7 +1046,7 @@ private: } gc_process; using gc_ertr = work_ertr::extend_ertr< - ExtentReader::scan_extents_ertr + SegmentManagerGroup::scan_extents_ertr >; gc_cycle_ret do_gc_cycle(); @@ -1278,7 +1278,7 @@ private: using scan_extents_ret_bare = std::vector>; - using scan_extents_ertr = ExtentReader::scan_extents_ertr; + using scan_extents_ertr = SegmentManagerGroup::scan_extents_ertr; using scan_extents_ret = scan_extents_ertr::future<>; scan_extents_ret scan_nonfull_segment( const segment_header_t& header, diff --git a/src/crimson/os/seastore/extent_reader.cc b/src/crimson/os/seastore/segment_manager_group.cc similarity index 90% rename from src/crimson/os/seastore/extent_reader.cc rename to src/crimson/os/seastore/segment_manager_group.cc index a2f3c10ab3a78..3e53021d0e945 100644 --- a/src/crimson/os/seastore/extent_reader.cc +++ b/src/crimson/os/seastore/segment_manager_group.cc @@ -1,7 +1,7 @@ // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*- // vim: ts=8 sw=2 smarttab expandtab -#include "crimson/os/seastore/extent_reader.h" +#include "crimson/os/seastore/segment_manager_group.h" #include "crimson/os/seastore/logging.h" @@ -9,8 +9,8 @@ SET_SUBSYS(seastore_journal); namespace crimson::os::seastore { -ExtentReader::read_segment_tail_ret -ExtentReader::read_segment_tail(segment_id_t segment) +SegmentManagerGroup::read_segment_tail_ret +SegmentManagerGroup::read_segment_tail(segment_id_t segment) { auto& segment_manager = *segment_managers[segment.device_id()]; return segment_manager.read( @@ -22,10 +22,10 @@ ExtentReader::read_segment_tail(segment_id_t segment) ).handle_error( read_segment_header_ertr::pass_further{}, crimson::ct_error::assert_all{ - "Invalid error in ExtentReader::read_segment_tail" + "Invalid error in SegmentManagerGroup::read_segment_tail" } ).safe_then([=, &segment_manager](bufferptr bptr) -> read_segment_tail_ret { - LOG_PREFIX(ExtentReader::read_segment_tail); + LOG_PREFIX(SegmentManagerGroup::read_segment_tail); DEBUG("segment {} bptr size {}", segment, bptr.length()); segment_tail_t tail; @@ -51,8 +51,8 @@ ExtentReader::read_segment_tail(segment_id_t segment) }); } -ExtentReader::read_segment_header_ret -ExtentReader::read_segment_header(segment_id_t segment) +SegmentManagerGroup::read_segment_header_ret +SegmentManagerGroup::read_segment_header(segment_id_t segment) { auto& segment_manager = *segment_managers[segment.device_id()]; return segment_manager.read( @@ -61,10 +61,10 @@ ExtentReader::read_segment_header(segment_id_t segment) ).handle_error( read_segment_header_ertr::pass_further{}, crimson::ct_error::assert_all{ - "Invalid error in ExtentReader::read_segment_header" + "Invalid error in SegmentManagerGroup::read_segment_header" } ).safe_then([=, &segment_manager](bufferptr bptr) -> read_segment_header_ret { - LOG_PREFIX(ExtentReader::read_segment_header); + LOG_PREFIX(SegmentManagerGroup::read_segment_header); DEBUG("segment {} bptr size {}", segment, bptr.length()); segment_header_t header; @@ -90,7 +90,8 @@ ExtentReader::read_segment_header(segment_id_t segment) }); } -ExtentReader::scan_extents_ret ExtentReader::scan_extents( +SegmentManagerGroup::scan_extents_ret +SegmentManagerGroup::scan_extents( scan_extents_cursor &cursor, extent_len_t bytes_to_read) { @@ -100,7 +101,7 @@ ExtentReader::scan_extents_ret ExtentReader::scan_extents( ).handle_error( scan_extents_ertr::pass_further{}, crimson::ct_error::assert_all{ - "Invalid error in ExtentReader::scan_extents" + "Invalid error in SegmentManagerGroup::scan_extents" } ).safe_then([bytes_to_read, extents, &cursor, this](auto segment_header) { auto segment_nonce = segment_header.segment_nonce; @@ -110,7 +111,7 @@ ExtentReader::scan_extents_ret ExtentReader::scan_extents( const record_group_header_t& header, const bufferlist& mdbuf) mutable -> scan_valid_records_ertr::future<> { - LOG_PREFIX(ExtentReader::scan_extents); + LOG_PREFIX(SegmentManagerGroup::scan_extents); DEBUG("decoding {} records", header.records); auto maybe_record_extent_infos = try_decode_extent_infos(header, mdbuf); if (!maybe_record_extent_infos) { @@ -151,13 +152,14 @@ ExtentReader::scan_extents_ret ExtentReader::scan_extents( }); } -ExtentReader::scan_valid_records_ret ExtentReader::scan_valid_records( +SegmentManagerGroup::scan_valid_records_ret +SegmentManagerGroup::scan_valid_records( scan_valid_records_cursor &cursor, segment_nonce_t nonce, size_t budget, found_record_handler_t &handler) { - LOG_PREFIX(ExtentReader::scan_valid_records); + LOG_PREFIX(SegmentManagerGroup::scan_valid_records); auto& segment_manager = *segment_managers[cursor.get_segment_id().device_id()]; if (cursor.get_segment_offset() == 0) { @@ -251,12 +253,12 @@ ExtentReader::scan_valid_records_ret ExtentReader::scan_valid_records( }); } -ExtentReader::read_validate_record_metadata_ret -ExtentReader::read_validate_record_metadata( +SegmentManagerGroup::read_validate_record_metadata_ret +SegmentManagerGroup::read_validate_record_metadata( paddr_t start, segment_nonce_t nonce) { - LOG_PREFIX(ExtentReader::read_validate_record_metadata); + LOG_PREFIX(SegmentManagerGroup::read_validate_record_metadata); auto& seg_addr = start.as_seg_paddr(); auto& segment_manager = *segment_managers[seg_addr.get_segment_id().device_id()]; auto block_size = segment_manager.get_block_size(); @@ -327,12 +329,12 @@ ExtentReader::read_validate_record_metadata( }); } -ExtentReader::read_validate_data_ret -ExtentReader::read_validate_data( +SegmentManagerGroup::read_validate_data_ret +SegmentManagerGroup::read_validate_data( paddr_t record_base, const record_group_header_t &header) { - LOG_PREFIX(ExtentReader::read_validate_data); + LOG_PREFIX(SegmentManagerGroup::read_validate_data); auto& segment_manager = *segment_managers[record_base.get_device_id()]; auto data_addr = record_base.add_offset(header.mdlength); TRACE("reading record group data blocks {}~{}", data_addr, header.dlength); @@ -346,13 +348,13 @@ ExtentReader::read_validate_data( }); } -ExtentReader::consume_record_group_ertr::future<> -ExtentReader::consume_next_records( +SegmentManagerGroup::consume_record_group_ertr::future<> +SegmentManagerGroup::consume_next_records( scan_valid_records_cursor& cursor, found_record_handler_t& handler, std::size_t& budget_used) { - LOG_PREFIX(ExtentReader::consume_next_records); + LOG_PREFIX(SegmentManagerGroup::consume_next_records); auto& next = cursor.pending_record_groups.front(); auto total_length = next.header.dlength + next.header.mdlength; budget_used += total_length; diff --git a/src/crimson/os/seastore/extent_reader.h b/src/crimson/os/seastore/segment_manager_group.h similarity index 95% rename from src/crimson/os/seastore/extent_reader.h rename to src/crimson/os/seastore/segment_manager_group.h index b32ae81e64b4c..522eed1557dd0 100644 --- a/src/crimson/os/seastore/extent_reader.h +++ b/src/crimson/os/seastore/segment_manager_group.h @@ -6,21 +6,17 @@ #include "crimson/common/errorator.h" #include "crimson/os/seastore/seastore_types.h" #include "crimson/os/seastore/segment_manager.h" -#include "crimson/os/seastore/logging.h" namespace crimson::os::seastore { -class SegmentCleaner; -class TransactionManager; - -class ExtentReader { +class SegmentManagerGroup { public: std::vector& get_segment_managers() { return segment_managers; } using read_ertr = SegmentManager::read_ertr; - ExtentReader() { + SegmentManagerGroup() { segment_managers.resize(DEVICE_ID_MAX, nullptr); } using read_segment_header_ertr = crimson::errorator< @@ -122,6 +118,6 @@ private: std::size_t& budget_used); }; -using ExtentReaderRef = std::unique_ptr; +using SegmentManagerGroupRef = std::unique_ptr; } // namespace crimson::os::seastore diff --git a/src/crimson/os/seastore/transaction_manager.cc b/src/crimson/os/seastore/transaction_manager.cc index b922aedb55234..768007027233d 100644 --- a/src/crimson/os/seastore/transaction_manager.cc +++ b/src/crimson/os/seastore/transaction_manager.cc @@ -27,13 +27,13 @@ TransactionManager::TransactionManager( CacheRef _cache, LBAManagerRef _lba_manager, ExtentPlacementManagerRef&& epm, - ExtentReader& scanner) + SegmentManagerGroup& sms) : segment_cleaner(std::move(_segment_cleaner)), cache(std::move(_cache)), lba_manager(std::move(_lba_manager)), journal(std::move(_journal)), epm(std::move(epm)), - scanner(scanner) + sms(sms) { segment_cleaner->set_extent_callback(this); journal->set_write_pipeline(&write_pipeline); @@ -156,7 +156,7 @@ TransactionManager::close_ertr::future<> TransactionManager::close() { cache->dump_contents(); return journal->close(); }).safe_then([this] { - scanner.reset(); + sms.reset(); return epm->close(); }).safe_then([FNAME] { INFO("completed"); @@ -545,16 +545,16 @@ TransactionManagerRef make_transaction_manager( Device &device, bool detailed) { - auto scanner = std::make_unique(); - auto& scanner_ref = *scanner.get(); + auto sms = std::make_unique(); + auto& sms_ref = *sms.get(); auto segment_cleaner = std::make_unique( SegmentCleaner::config_t::get_default(), - std::move(scanner), + std::move(sms), detailed); ceph_assert(device.get_device_type() == device_type_t::SEGMENTED); auto sm = dynamic_cast(&device); ceph_assert(sm != nullptr); - auto journal = journal::make_segmented(*sm, scanner_ref, *segment_cleaner); + auto journal = journal::make_segmented(*sm, sms_ref, *segment_cleaner); auto epm = std::make_unique(); auto cache = std::make_unique(*epm); auto lba_manager = lba_manager::create_lba_manager(*cache); @@ -565,7 +565,7 @@ TransactionManagerRef make_transaction_manager( std::move(cache), std::move(lba_manager), std::move(epm), - scanner_ref); + sms_ref); } } diff --git a/src/crimson/os/seastore/transaction_manager.h b/src/crimson/os/seastore/transaction_manager.h index cc54ba2fb1515..2e5385025b205 100644 --- a/src/crimson/os/seastore/transaction_manager.h +++ b/src/crimson/os/seastore/transaction_manager.h @@ -28,6 +28,7 @@ #include "crimson/os/seastore/journal.h" #include "crimson/os/seastore/extent_placement_manager.h" #include "crimson/os/seastore/device.h" +#include "crimson/os/seastore/segment_manager_group.h" namespace crimson::os::seastore { class Journal; @@ -69,7 +70,7 @@ public: CacheRef cache, LBAManagerRef lba_manager, ExtentPlacementManagerRef&& epm, - ExtentReader& scanner); + SegmentManagerGroup& sms); /// Writes initial metadata to disk using mkfs_ertr = base_ertr; @@ -548,7 +549,7 @@ public: *segment_cleaner, *sm, segment_cleaner->get_ool_segment_seq_allocator())); - scanner.add_segment_manager(sm); + sms.add_segment_manager(sm); } ~TransactionManager(); @@ -561,7 +562,7 @@ private: LBAManagerRef lba_manager; JournalRef journal; ExtentPlacementManagerRef epm; - ExtentReader& scanner; + SegmentManagerGroup& sms; WritePipeline write_pipeline; diff --git a/src/test/crimson/seastore/test_btree_lba_manager.cc b/src/test/crimson/seastore/test_btree_lba_manager.cc index 63261111b6096..66f405006e995 100644 --- a/src/test/crimson/seastore/test_btree_lba_manager.cc +++ b/src/test/crimson/seastore/test_btree_lba_manager.cc @@ -28,7 +28,7 @@ struct btree_test_base : public seastar_test_suite_t, SegmentProvider { segment_manager::EphemeralSegmentManagerRef segment_manager; - ExtentReaderRef scanner; + SegmentManagerGroupRef sms; JournalRef journal; ExtentPlacementManagerRef epm; CacheRef cache; @@ -98,16 +98,16 @@ struct btree_test_base : virtual LBAManager::mkfs_ret test_structure_setup(Transaction &t) = 0; seastar::future<> set_up_fut() final { segment_manager = segment_manager::create_test_ephemeral(); - scanner.reset(new ExtentReader()); - auto& scanner_ref = *scanner.get(); + sms.reset(new SegmentManagerGroup()); + auto& sms_ref = *sms.get(); journal = journal::make_segmented( - *segment_manager, scanner_ref, *this); + *segment_manager, sms_ref, *this); epm.reset(new ExtentPlacementManager()); cache.reset(new Cache(*epm)); block_size = segment_manager->get_block_size(); next = segment_id_t{segment_manager->get_device_id(), 0}; - scanner_ref.add_segment_manager(segment_manager.get()); + sms_ref.add_segment_manager(segment_manager.get()); epm->add_device(segment_manager.get(), true); journal->set_write_pipeline(&pipeline); @@ -148,7 +148,7 @@ struct btree_test_base : }).safe_then([this] { test_structure_reset(); segment_manager.reset(); - scanner.reset(); + sms.reset(); journal.reset(); epm.reset(); cache.reset(); diff --git a/src/test/crimson/seastore/test_seastore_journal.cc b/src/test/crimson/seastore/test_seastore_journal.cc index 3599dc1603343..0daae06f73476 100644 --- a/src/test/crimson/seastore/test_seastore_journal.cc +++ b/src/test/crimson/seastore/test_seastore_journal.cc @@ -76,7 +76,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider { seastore_off_t block_size; - ExtentReaderRef scanner; + SegmentManagerGroupRef sms; segment_id_t next; @@ -125,11 +125,11 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider { seastar::future<> set_up_fut() final { segment_manager = segment_manager::create_test_ephemeral(); block_size = segment_manager->get_block_size(); - scanner.reset(new ExtentReader()); + sms.reset(new SegmentManagerGroup()); next = segment_id_t(segment_manager->get_device_id(), 0); - journal = journal::make_segmented(*segment_manager, *scanner, *this); + journal = journal::make_segmented(*segment_manager, *sms, *this); journal->set_write_pipeline(&pipeline); - scanner->add_segment_manager(segment_manager.get()); + sms->add_segment_manager(segment_manager.get()); return segment_manager->init( ).safe_then([this] { return journal->open_for_write(); @@ -144,7 +144,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider { return journal->close( ).safe_then([this] { segment_manager.reset(); - scanner.reset(); + sms.reset(); journal.reset(); }).handle_error( crimson::ct_error::all_same_way([](auto e) { @@ -158,7 +158,7 @@ struct journal_test_t : seastar_test_suite_t, SegmentProvider { return journal->close( ).safe_then([this, f=std::move(f)]() mutable { journal = journal::make_segmented( - *segment_manager, *scanner, *this); + *segment_manager, *sms, *this); journal->set_write_pipeline(&pipeline); return journal->replay(std::forward(std::move(f))); }).safe_then([this] { -- 2.39.5