From 7fbdeabe38c361a3628e906ab1b9df2c98d62741 Mon Sep 17 00:00:00 2001 From: Aravind Ramesh Date: Tue, 2 May 2023 07:55:37 +0200 Subject: [PATCH] crimson/os/seastore: change zoned device interface name from ZNS to ZBD We can essentially support SMR devices(HDD) and ZNS device(SSDs) which are both subsets of Zoned Block Devices under the same interface ZNSSegmentManager with small changes in design. Hence changing the interface name to a more contextual name ZBDSegmentManager. This also helps to add SMR device support for crimson. Signed-off-by: Aravind Ramesh --- src/crimson/os/seastore/CMakeLists.txt | 2 +- src/crimson/os/seastore/seastore_types.cc | 8 +- src/crimson/os/seastore/seastore_types.h | 4 +- src/crimson/os/seastore/segment_manager.cc | 4 +- src/crimson/os/seastore/segment_manager.h | 2 +- .../segment_manager/{zns.cc => zbd.cc} | 112 +++++++++--------- .../seastore/segment_manager/{zns.h => zbd.h} | 48 ++++---- 7 files changed, 90 insertions(+), 90 deletions(-) rename src/crimson/os/seastore/segment_manager/{zns.cc => zbd.cc} (85%) rename src/crimson/os/seastore/segment_manager/{zns.h => zbd.h} (84%) diff --git a/src/crimson/os/seastore/CMakeLists.txt b/src/crimson/os/seastore/CMakeLists.txt index 6dd19a1563a..0736547b9ab 100644 --- a/src/crimson/os/seastore/CMakeLists.txt +++ b/src/crimson/os/seastore/CMakeLists.txt @@ -58,7 +58,7 @@ CMAKE_DEPENDENT_OPTION(WITH_ZNS "enable Linux ZNS support" OFF if(WITH_ZNS) find_package(LinuxZNS REQUIRED) list(APPEND crimson_seastore_srcs - segment_manager/zns.cc) + segment_manager/zbd.cc) endif() add_library(crimson-seastore STATIC diff --git a/src/crimson/os/seastore/seastore_types.cc b/src/crimson/os/seastore/seastore_types.cc index a14201cbcf7..4e55bce0a48 100644 --- a/src/crimson/os/seastore/seastore_types.cc +++ b/src/crimson/os/seastore/seastore_types.cc @@ -777,8 +777,8 @@ device_type_t string_to_device_type(std::string type) { if (type == "SSD") { return device_type_t::SSD; } - if (type == "ZNS") { - return device_type_t::ZNS; + if (type == "ZBD") { + return device_type_t::ZBD; } if (type == "RANDOM_BLOCK_SSD") { return device_type_t::RANDOM_BLOCK_SSD; @@ -795,8 +795,8 @@ std::ostream& operator<<(std::ostream& out, device_type_t t) return out << "HDD"; case device_type_t::SSD: return out << "SSD"; - case device_type_t::ZNS: - return out << "ZNS"; + case device_type_t::ZBD: + return out << "ZBD"; case device_type_t::EPHEMERAL_COLD: return out << "EPHEMERAL_COLD"; case device_type_t::EPHEMERAL_MAIN: diff --git a/src/crimson/os/seastore/seastore_types.h b/src/crimson/os/seastore/seastore_types.h index 99d17472eb3..79e76667f13 100644 --- a/src/crimson/os/seastore/seastore_types.h +++ b/src/crimson/os/seastore/seastore_types.h @@ -875,7 +875,7 @@ enum class device_type_t : uint8_t { NONE = 0, HDD, SSD, - ZNS, + ZBD, EPHEMERAL_COLD, EPHEMERAL_MAIN, RANDOM_BLOCK_SSD, @@ -889,7 +889,7 @@ bool can_delay_allocation(device_type_t type); device_type_t string_to_device_type(std::string type); enum class backend_type_t { - SEGMENTED, // SegmentManager: SSD, ZNS, HDD + SEGMENTED, // SegmentManager: SSD, ZBD, HDD RANDOM_BLOCK // RBMDevice: RANDOM_BLOCK_SSD }; diff --git a/src/crimson/os/seastore/segment_manager.cc b/src/crimson/os/seastore/segment_manager.cc index 098a9b068f8..dbba31fd207 100644 --- a/src/crimson/os/seastore/segment_manager.cc +++ b/src/crimson/os/seastore/segment_manager.cc @@ -6,7 +6,7 @@ #include "crimson/os/seastore/logging.h" #ifdef HAVE_ZNS -#include "crimson/os/seastore/segment_manager/zns.h" +#include "crimson/os/seastore/segment_manager/zbd.h" SET_SUBSYS(seastore_device); #endif @@ -79,7 +79,7 @@ LOG_PREFIX(SegmentManager::get_segment_manager); INFO("Found {} zones.", nr_zones); if (nr_zones != 0) { return std::make_unique< - segment_manager::zns::ZNSSegmentManager + segment_manager::zbd::ZBDSegmentManager >(device + "/block"); } else { return std::make_unique< diff --git a/src/crimson/os/seastore/segment_manager.h b/src/crimson/os/seastore/segment_manager.h index 1669d124a6b..719fa6075ed 100644 --- a/src/crimson/os/seastore/segment_manager.h +++ b/src/crimson/os/seastore/segment_manager.h @@ -153,7 +153,7 @@ public: * advance_wp * * advance the segment write pointer, - * needed when writing at wp is strictly implemented. ex: ZNS backed segments + * needed when writing at wp is strictly implemented. ex: ZBD backed segments * @param offset: advance write pointer till the given offset */ virtual write_ertr::future<> advance_wp( diff --git a/src/crimson/os/seastore/segment_manager/zns.cc b/src/crimson/os/seastore/segment_manager/zbd.cc similarity index 85% rename from src/crimson/os/seastore/segment_manager/zns.cc rename to src/crimson/os/seastore/segment_manager/zbd.cc index deaaadf6668..be1d71dacaa 100644 --- a/src/crimson/os/seastore/segment_manager/zns.cc +++ b/src/crimson/os/seastore/segment_manager/zbd.cc @@ -6,7 +6,7 @@ #include #include -#include "crimson/os/seastore/segment_manager/zns.h" +#include "crimson/os/seastore/segment_manager/zbd.h" #include "crimson/common/config_proxy.h" #include "crimson/os/seastore/logging.h" #include "include/buffer.h" @@ -18,7 +18,7 @@ SET_SUBSYS(seastore_device); // limit the max padding buf size to 1MB #define MAX_PADDING_SIZE 1048576 -using z_op = crimson::os::seastore::segment_manager::zns::zone_op; +using z_op = crimson::os::seastore::segment_manager::zbd::zone_op; template <> struct fmt::formatter: fmt::formatter { template auto format(z_op s, FormatContext& ctx) { @@ -42,15 +42,15 @@ template <> struct fmt::formatter: fmt::formatter { } }; -namespace crimson::os::seastore::segment_manager::zns { +namespace crimson::os::seastore::segment_manager::zbd { -using open_device_ret = ZNSSegmentManager::access_ertr::future< +using open_device_ret = ZBDSegmentManager::access_ertr::future< std::pair>; static open_device_ret open_device( const std::string &path, seastar::open_flags mode) { - LOG_PREFIX(ZNSSegmentManager::open_device); + LOG_PREFIX(ZBDSegmentManager::open_device); return seastar::file_stat( path, seastar::follow_symlink::yes ).then([FNAME, mode, &path](auto stat) mutable { @@ -69,7 +69,7 @@ static open_device_ret open_device( ); } -static zns_sm_metadata_t make_metadata( +static zbd_sm_metadata_t make_metadata( uint64_t total_size, seastore_meta_t meta, const seastar::stat_data &data, @@ -77,7 +77,7 @@ static zns_sm_metadata_t make_metadata( size_t zone_capacity_sectors, size_t num_zones) { - LOG_PREFIX(ZNSSegmentManager::make_metadata); + LOG_PREFIX(ZBDSegmentManager::make_metadata); // TODO: support Option::size_t seastore_segment_size // to allow zones_per_segment > 1 with striping. @@ -89,7 +89,7 @@ static zns_sm_metadata_t make_metadata( size_t per_shard_segments = segments / seastar::smp::count; size_t available_size = zone_capacity * segments; size_t per_shard_available_size = zone_capacity * per_shard_segments; - std::vector shard_infos(seastar::smp::count); + std::vector shard_infos(seastar::smp::count); for (unsigned int i = 0; i < seastar::smp::count; i++) { shard_infos[i].size = per_shard_available_size; shard_infos[i].segments = per_shard_segments; @@ -115,7 +115,7 @@ static zns_sm_metadata_t make_metadata( zones_per_segment, zone_capacity * zones_per_segment); - zns_sm_metadata_t ret = zns_sm_metadata_t{ + zbd_sm_metadata_t ret = zbd_sm_metadata_t{ seastar::smp::count, segment_size, zone_capacity * zones_per_segment, @@ -205,7 +205,7 @@ static write_ertr::future<> do_write( uint64_t offset, bufferptr &bptr) { - LOG_PREFIX(ZNSSegmentManager::do_write); + LOG_PREFIX(ZBDSegmentManager::do_write); DEBUG("offset {} len {}", offset, bptr.length()); @@ -233,7 +233,7 @@ static write_ertr::future<> do_writev( bufferlist&& bl, size_t block_size) { - LOG_PREFIX(ZNSSegmentManager::do_writev); + LOG_PREFIX(ZBDSegmentManager::do_writev); DEBUG("offset {} len {}", offset, bl.length()); @@ -261,15 +261,15 @@ static write_ertr::future<> do_writev( }); } -static ZNSSegmentManager::access_ertr::future<> -write_metadata(seastar::file &device, zns_sm_metadata_t sb) +static ZBDSegmentManager::access_ertr::future<> +write_metadata(seastar::file &device, zbd_sm_metadata_t sb) { - assert(ceph::encoded_sizeof_bounded() < + assert(ceph::encoded_sizeof_bounded() < sb.block_size); return seastar::do_with( bufferptr(ceph::buffer::create_page_aligned(sb.block_size)), [=, &device](auto &bp) { - LOG_PREFIX(ZNSSegmentManager::write_metadata); + LOG_PREFIX(ZBDSegmentManager::write_metadata); DEBUG("block_size {}", sb.block_size); bufferlist bl; encode(sb, bl); @@ -288,7 +288,7 @@ static read_ertr::future<> do_read( size_t len, bufferptr &bptr) { - LOG_PREFIX(ZNSSegmentManager::do_read); + LOG_PREFIX(ZBDSegmentManager::do_read); assert(len <= bptr.length()); DEBUG("offset {} len {}", offset, @@ -312,10 +312,10 @@ static read_ertr::future<> do_read( } static -ZNSSegmentManager::access_ertr::future +ZBDSegmentManager::access_ertr::future read_metadata(seastar::file &device, seastar::stat_data sd) { - assert(ceph::encoded_sizeof_bounded() < + assert(ceph::encoded_sizeof_bounded() < sd.block_size); return seastar::do_with( bufferptr(ceph::buffer::create_page_aligned(sd.block_size)), @@ -328,29 +328,29 @@ read_metadata(seastar::file &device, seastar::stat_data sd) ).safe_then([=, &bp] { bufferlist bl; bl.push_back(bp); - zns_sm_metadata_t ret; + zbd_sm_metadata_t ret; auto bliter = bl.cbegin(); decode(ret, bliter); ret.validate(); - return ZNSSegmentManager::access_ertr::future( - ZNSSegmentManager::access_ertr::ready_future_marker{}, + return ZBDSegmentManager::access_ertr::future( + ZBDSegmentManager::access_ertr::ready_future_marker{}, ret); }); }); } -ZNSSegmentManager::mount_ret ZNSSegmentManager::mount() +ZBDSegmentManager::mount_ret ZBDSegmentManager::mount() { return shard_devices.invoke_on_all([](auto &local_device) { return local_device.shard_mount( ).handle_error( crimson::ct_error::assert_all{ - "Invalid error in ZNSSegmentManager::mount" + "Invalid error in ZBDSegmentManager::mount" }); }); } -ZNSSegmentManager::mount_ret ZNSSegmentManager::shard_mount() +ZBDSegmentManager::mount_ret ZBDSegmentManager::shard_mount() { return open_device( device_path, seastar::open_flags::rw @@ -365,7 +365,7 @@ ZNSSegmentManager::mount_ret ZNSSegmentManager::shard_mount() }); } -ZNSSegmentManager::mkfs_ret ZNSSegmentManager::mkfs( +ZBDSegmentManager::mkfs_ret ZBDSegmentManager::mkfs( device_config_t config) { return shard_devices.local().primary_mkfs(config @@ -374,21 +374,21 @@ ZNSSegmentManager::mkfs_ret ZNSSegmentManager::mkfs( return local_device.shard_mkfs( ).handle_error( crimson::ct_error::assert_all{ - "Invalid error in ZNSSegmentManager::mkfs" + "Invalid error in ZBDSegmentManager::mkfs" }); }); }); } -ZNSSegmentManager::mkfs_ret ZNSSegmentManager::primary_mkfs( +ZBDSegmentManager::mkfs_ret ZBDSegmentManager::primary_mkfs( device_config_t config) { - LOG_PREFIX(ZNSSegmentManager::primary_mkfs); + LOG_PREFIX(ZBDSegmentManager::primary_mkfs); INFO("starting, device_path {}", device_path); return seastar::do_with( seastar::file{}, seastar::stat_data{}, - zns_sm_metadata_t{}, + zbd_sm_metadata_t{}, size_t(), size_t(), size_t(), @@ -429,7 +429,7 @@ ZNSSegmentManager::mkfs_ret ZNSSegmentManager::primary_mkfs( nr_zones); metadata = sb; stats.metadata_write.increment( - ceph::encoded_sizeof_bounded()); + ceph::encoded_sizeof_bounded()); DEBUG("Wrote to stats."); return write_metadata(device, sb); }).finally([&, FNAME] { @@ -443,9 +443,9 @@ ZNSSegmentManager::mkfs_ret ZNSSegmentManager::primary_mkfs( }); } -ZNSSegmentManager::mkfs_ret ZNSSegmentManager::shard_mkfs() +ZBDSegmentManager::mkfs_ret ZBDSegmentManager::shard_mkfs() { - LOG_PREFIX(ZNSSegmentManager::shard_mkfs); + LOG_PREFIX(ZBDSegmentManager::shard_mkfs); INFO("starting, device_path {}", device_path); return open_device( device_path, seastar::open_flags::rw @@ -482,7 +482,7 @@ using blk_zone_op_ret = blk_zone_op_ertr::future<>; blk_zone_op_ret blk_zone_op(seastar::file &device, blk_zone_range &range, zone_op op) { - LOG_PREFIX(ZNSSegmentManager::blk_zone_op); + LOG_PREFIX(ZBDSegmentManager::blk_zone_op); unsigned long ioctl_op = 0; switch (op) { @@ -523,10 +523,10 @@ blk_zone_op_ret blk_zone_op(seastar::file &device, }); } -ZNSSegmentManager::open_ertr::future ZNSSegmentManager::open( +ZBDSegmentManager::open_ertr::future ZBDSegmentManager::open( segment_id_t id) { - LOG_PREFIX(ZNSSegmentManager::open); + LOG_PREFIX(ZBDSegmentManager::open); return seastar::do_with( blk_zone_range{}, [=, this](auto &range) { @@ -544,15 +544,15 @@ ZNSSegmentManager::open_ertr::future ZNSSegmentManager::open( DEBUG("segment {}, open successful", id); return open_ertr::future( open_ertr::ready_future_marker{}, - SegmentRef(new ZNSSegment(*this, id)) + SegmentRef(new ZBDSegment(*this, id)) ); }); } -ZNSSegmentManager::release_ertr::future<> ZNSSegmentManager::release( +ZBDSegmentManager::release_ertr::future<> ZBDSegmentManager::release( segment_id_t id) { - LOG_PREFIX(ZNSSegmentManager::release); + LOG_PREFIX(ZBDSegmentManager::release); DEBUG("Resetting zone/segment {}", id); return seastar::do_with( blk_zone_range{}, @@ -573,12 +573,12 @@ ZNSSegmentManager::release_ertr::future<> ZNSSegmentManager::release( }); } -SegmentManager::read_ertr::future<> ZNSSegmentManager::read( +SegmentManager::read_ertr::future<> ZBDSegmentManager::read( paddr_t addr, size_t len, ceph::bufferptr &out) { - LOG_PREFIX(ZNSSegmentManager::read); + LOG_PREFIX(ZBDSegmentManager::read); auto& seg_addr = addr.as_seg_paddr(); if (seg_addr.get_segment_id().device_segment_id() >= get_num_segments()) { ERROR("invalid segment {}", @@ -599,10 +599,10 @@ SegmentManager::read_ertr::future<> ZNSSegmentManager::read( out); } -Segment::close_ertr::future<> ZNSSegmentManager::segment_close( +Segment::close_ertr::future<> ZBDSegmentManager::segment_close( segment_id_t id, segment_off_t write_pointer) { - LOG_PREFIX(ZNSSegmentManager::segment_close); + LOG_PREFIX(ZBDSegmentManager::segment_close); return seastar::do_with( blk_zone_range{}, [=, this](auto &range) { @@ -622,12 +622,12 @@ Segment::close_ertr::future<> ZNSSegmentManager::segment_close( }); } -Segment::write_ertr::future<> ZNSSegmentManager::segment_write( +Segment::write_ertr::future<> ZBDSegmentManager::segment_write( paddr_t addr, ceph::bufferlist bl, bool ignore_check) { - LOG_PREFIX(ZNSSegmentManager::segment_write); + LOG_PREFIX(ZBDSegmentManager::segment_write); assert(addr.get_device_id() == get_device_id()); assert((bl.length() % metadata.block_size) == 0); auto& seg_addr = addr.as_seg_paddr(); @@ -644,27 +644,27 @@ Segment::write_ertr::future<> ZNSSegmentManager::segment_write( metadata.block_size); } -device_id_t ZNSSegmentManager::get_device_id() const +device_id_t ZBDSegmentManager::get_device_id() const { return metadata.device_id; }; -secondary_device_set_t& ZNSSegmentManager::get_secondary_devices() +secondary_device_set_t& ZBDSegmentManager::get_secondary_devices() { return metadata.secondary_devices; }; -magic_t ZNSSegmentManager::get_magic() const +magic_t ZBDSegmentManager::get_magic() const { return metadata.magic; }; -segment_off_t ZNSSegment::get_write_capacity() const +segment_off_t ZBDSegment::get_write_capacity() const { return manager.get_segment_size(); } -SegmentManager::close_ertr::future<> ZNSSegmentManager::close() +SegmentManager::close_ertr::future<> ZBDSegmentManager::close() { if (device) { return device.close(); @@ -672,15 +672,15 @@ SegmentManager::close_ertr::future<> ZNSSegmentManager::close() return seastar::now(); } -Segment::close_ertr::future<> ZNSSegment::close() +Segment::close_ertr::future<> ZBDSegment::close() { return manager.segment_close(id, write_pointer); } -Segment::write_ertr::future<> ZNSSegment::write( +Segment::write_ertr::future<> ZBDSegment::write( segment_off_t offset, ceph::bufferlist bl) { - LOG_PREFIX(ZNSSegment::write); + LOG_PREFIX(ZBDSegment::write); if (offset != write_pointer || offset % manager.metadata.block_size != 0) { ERROR("Segment offset and zone write pointer mismatch. " "segment {} segment-offset {} write pointer {}", @@ -695,10 +695,10 @@ Segment::write_ertr::future<> ZNSSegment::write( return manager.segment_write(paddr_t::make_seg_paddr(id, offset), bl); } -Segment::write_ertr::future<> ZNSSegment::write_padding_bytes( +Segment::write_ertr::future<> ZBDSegment::write_padding_bytes( size_t padding_bytes) { - LOG_PREFIX(ZNSSegment::write_padding_bytes); + LOG_PREFIX(ZBDSegment::write_padding_bytes); DEBUG("Writing {} padding bytes to segment {} at wp {}", padding_bytes, id, write_pointer); @@ -726,10 +726,10 @@ Segment::write_ertr::future<> ZNSSegment::write_padding_bytes( } // Advance write pointer, to given offset. -Segment::write_ertr::future<> ZNSSegment::advance_wp( +Segment::write_ertr::future<> ZBDSegment::advance_wp( segment_off_t offset) { - LOG_PREFIX(ZNSSegment::advance_wp); + LOG_PREFIX(ZBDSegment::advance_wp); DEBUG("Advancing write pointer from {} to {}", write_pointer, offset); if (offset < write_pointer) { diff --git a/src/crimson/os/seastore/segment_manager/zns.h b/src/crimson/os/seastore/segment_manager/zbd.h similarity index 84% rename from src/crimson/os/seastore/segment_manager/zns.h rename to src/crimson/os/seastore/segment_manager/zbd.h index b98ff1c89f4..c18f46336ae 100644 --- a/src/crimson/os/seastore/segment_manager/zns.h +++ b/src/crimson/os/seastore/segment_manager/zbd.h @@ -17,14 +17,14 @@ #include "include/uuid.h" -namespace crimson::os::seastore::segment_manager::zns { +namespace crimson::os::seastore::segment_manager::zbd { - struct zns_shard_info_t { + struct zbd_shard_info_t { size_t size = 0; size_t segments = 0; size_t first_segment_offset = 0; - DENC(zns_shard_info_t, v, p) { + DENC(zbd_shard_info_t, v, p) { DENC_START(1, 1, p); denc(v.size, p); denc(v.segments, p); @@ -33,7 +33,7 @@ namespace crimson::os::seastore::segment_manager::zns { } }; - struct zns_sm_metadata_t { + struct zbd_sm_metadata_t { unsigned int shard_num = 0; size_t segment_size = 0; size_t segment_capacity = 0; @@ -42,7 +42,7 @@ namespace crimson::os::seastore::segment_manager::zns { size_t block_size = 0; size_t zone_size = 0; - std::vector shard_infos; + std::vector shard_infos; seastore_meta_t meta; @@ -52,7 +52,7 @@ namespace crimson::os::seastore::segment_manager::zns { device_id_t device_id = 0; secondary_device_set_t secondary_devices; - DENC(zns_sm_metadata_t, v, p) { + DENC(zbd_sm_metadata_t, v, p) { DENC_START(1, 1, p); denc(v.shard_num, p); denc(v.segment_size, p); @@ -95,11 +95,11 @@ namespace crimson::os::seastore::segment_manager::zns { RESET, }; - class ZNSSegmentManager; + class ZBDSegmentManager; - class ZNSSegment final : public Segment { + class ZBDSegment final : public Segment { public: - ZNSSegment(ZNSSegmentManager &man, segment_id_t i) : manager(man), id(i){}; + ZBDSegment(ZBDSegmentManager &man, segment_id_t i) : manager(man), id(i){}; segment_id_t get_segment_id() const final { return id; } segment_off_t get_write_capacity() const final; @@ -108,16 +108,16 @@ namespace crimson::os::seastore::segment_manager::zns { write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final; write_ertr::future<> advance_wp(segment_off_t offset) final; - ~ZNSSegment() {} + ~ZBDSegment() {} private: - friend class ZNSSegmentManager; - ZNSSegmentManager &manager; + friend class ZBDSegmentManager; + ZBDSegmentManager &manager; const segment_id_t id; segment_off_t write_pointer = 0; write_ertr::future<> write_padding_bytes(size_t padding_bytes); }; - class ZNSSegmentManager final : public SegmentManager{ + class ZBDSegmentManager final : public SegmentManager{ // interfaces used by Device public: seastar::future<> start() { @@ -135,9 +135,9 @@ namespace crimson::os::seastore::segment_manager::zns { mount_ret mount() final; mkfs_ret mkfs(device_config_t meta) final; - ZNSSegmentManager(const std::string &path) : device_path(path) {} + ZBDSegmentManager(const std::string &path) : device_path(path) {} - ~ZNSSegmentManager() final = default; + ~ZBDSegmentManager() final = default; //interfaces used by each shard device public: @@ -152,7 +152,7 @@ namespace crimson::os::seastore::segment_manager::zns { ceph::bufferptr &out) final; device_type_t get_device_type() const final { - return device_type_t::ZNS; + return device_type_t::ZBD; } size_t get_available_size() const final { @@ -183,10 +183,10 @@ namespace crimson::os::seastore::segment_manager::zns { bool ignore_check=false); private: - friend class ZNSSegment; + friend class ZBDSegment; std::string device_path; - zns_shard_info_t shard_info; - zns_sm_metadata_t metadata; + zbd_shard_info_t shard_info; + zbd_sm_metadata_t metadata; seastar::file device; uint32_t nr_zones; struct effort_t { @@ -199,7 +199,7 @@ namespace crimson::os::seastore::segment_manager::zns { } }; - struct zns_sm_stats { + struct zbd_sm_stats { effort_t data_read = {}; effort_t data_write = {}; effort_t metadata_write = {}; @@ -209,7 +209,7 @@ namespace crimson::os::seastore::segment_manager::zns { uint64_t released_segments = 0; void reset() { - *this = zns_sm_stats{}; + *this = zbd_sm_stats{}; } } stats; @@ -233,14 +233,14 @@ namespace crimson::os::seastore::segment_manager::zns { mount_ret shard_mount(); - seastar::sharded shard_devices; + seastar::sharded shard_devices; }; } WRITE_CLASS_DENC_BOUNDED( - crimson::os::seastore::segment_manager::zns::zns_shard_info_t + crimson::os::seastore::segment_manager::zbd::zbd_shard_info_t ) WRITE_CLASS_DENC_BOUNDED( - crimson::os::seastore::segment_manager::zns::zns_sm_metadata_t + crimson::os::seastore::segment_manager::zbd::zbd_sm_metadata_t ) -- 2.47.3