From 92ca9c082ca6be771302e049e3343da3e1dfbffd Mon Sep 17 00:00:00 2001 From: myoungwon oh Date: Tue, 26 Jul 2022 17:14:58 +0900 Subject: [PATCH] seastore/rbm: rename works 1. rename NVMeBlockDevice to RBMDevice 2. rename PosixNVMeDevice to NVMeBlockDevice Signed-off-by: Myoungwon Oh --- src/crimson/os/seastore/CMakeLists.txt | 2 +- src/crimson/os/seastore/journal.cc | 2 +- src/crimson/os/seastore/journal.h | 4 +- .../journal/circular_bounded_journal.cc | 2 +- .../journal/circular_bounded_journal.h | 10 +- .../random_block_manager/block_rb_manager.cc | 2 +- .../random_block_manager/block_rb_manager.h | 10 +- .../{nvmedevice.cc => nvme_block_device.cc} | 26 +-- .../{nvmedevice.h => rbm_device.h} | 184 ++++++++---------- .../seastore/nvmedevice/test_nvmedevice.cc | 6 +- src/test/crimson/seastore/test_cbjournal.cc | 4 +- .../seastore/test_randomblock_manager.cc | 4 +- .../seastore/transaction_manager_test_state.h | 4 +- 13 files changed, 122 insertions(+), 138 deletions(-) rename src/crimson/os/seastore/random_block_manager/{nvmedevice.cc => nvme_block_device.cc} (93%) rename src/crimson/os/seastore/random_block_manager/{nvmedevice.h => rbm_device.h} (91%) diff --git a/src/crimson/os/seastore/CMakeLists.txt b/src/crimson/os/seastore/CMakeLists.txt index 408f7b494dc..6f3a8a68c2e 100644 --- a/src/crimson/os/seastore/CMakeLists.txt +++ b/src/crimson/os/seastore/CMakeLists.txt @@ -37,7 +37,7 @@ set(crimson_seastore_srcs object_data_handler.cc seastore.cc random_block_manager/block_rb_manager.cc - random_block_manager/nvmedevice.cc + random_block_manager/nvme_block_device.cc journal/segmented_journal.cc journal/segment_allocator.cc journal.cc diff --git a/src/crimson/os/seastore/journal.cc b/src/crimson/os/seastore/journal.cc index 314d62d89f5..832a45e6e79 100644 --- a/src/crimson/os/seastore/journal.cc +++ b/src/crimson/os/seastore/journal.cc @@ -13,7 +13,7 @@ JournalRef make_segmented(SegmentProvider &provider) } JournalRef make_circularbounded( - crimson::os::seastore::nvme_device::NVMeBlockDevice* device, + crimson::os::seastore::nvme_device::RBMDevice* device, std::string path) { return std::make_unique(device, path); diff --git a/src/crimson/os/seastore/journal.h b/src/crimson/os/seastore/journal.h index 05a8434a33d..7ab6f3e61ba 100644 --- a/src/crimson/os/seastore/journal.h +++ b/src/crimson/os/seastore/journal.h @@ -12,7 +12,7 @@ namespace crimson::os::seastore { namespace nvme_device { -class NVMeBlockDevice; +class RBMDevice; } class SegmentManagerGroup; @@ -110,7 +110,7 @@ namespace journal { JournalRef make_segmented(SegmentProvider &provider); JournalRef make_circularbounded( - crimson::os::seastore::nvme_device::NVMeBlockDevice* device, + crimson::os::seastore::nvme_device::RBMDevice* device, std::string path); } diff --git a/src/crimson/os/seastore/journal/circular_bounded_journal.cc b/src/crimson/os/seastore/journal/circular_bounded_journal.cc index 289b3fa4383..6e4b3aee269 100644 --- a/src/crimson/os/seastore/journal/circular_bounded_journal.cc +++ b/src/crimson/os/seastore/journal/circular_bounded_journal.cc @@ -24,7 +24,7 @@ std::ostream &operator<<(std::ostream &out, << ")"; } -CircularBoundedJournal::CircularBoundedJournal(NVMeBlockDevice* device, +CircularBoundedJournal::CircularBoundedJournal(RBMDevice* device, const std::string &path) : device(device), path(path) {} diff --git a/src/crimson/os/seastore/journal/circular_bounded_journal.h b/src/crimson/os/seastore/journal/circular_bounded_journal.h index 098cb99c58e..2179b0f1fc2 100644 --- a/src/crimson/os/seastore/journal/circular_bounded_journal.h +++ b/src/crimson/os/seastore/journal/circular_bounded_journal.h @@ -17,7 +17,7 @@ #include "crimson/os/seastore/journal.h" #include "include/uuid.h" #include "crimson/os/seastore/random_block_manager.h" -#include "crimson/os/seastore/random_block_manager/nvmedevice.h" +#include "crimson/os/seastore/random_block_manager/rbm_device.h" #include @@ -25,7 +25,7 @@ namespace crimson::os::seastore::journal { constexpr rbm_abs_addr CBJOURNAL_START_ADDRESS = 0; constexpr uint64_t CBJOURNAL_MAGIC = 0xCCCC; -using NVMeBlockDevice = nvme_device::NVMeBlockDevice; +using RBMDevice = nvme_device::RBMDevice; /** * CircularBoundedJournal @@ -77,7 +77,7 @@ public: } }; - CircularBoundedJournal(NVMeBlockDevice* device, const std::string &path); + CircularBoundedJournal(RBMDevice* device, const std::string &path); ~CircularBoundedJournal() {} open_for_mkfs_ret open_for_mkfs() final; @@ -277,12 +277,12 @@ public: rbm_abs_addr get_journal_end() const { return get_start_addr() + header.size + get_block_size(); // journal size + header length } - void add_device(NVMeBlockDevice* dev) { + void add_device(RBMDevice* dev) { device = dev; } private: cbj_header_t header; - NVMeBlockDevice* device; + RBMDevice* device; std::string path; WritePipeline *write_pipeline = nullptr; /** diff --git a/src/crimson/os/seastore/random_block_manager/block_rb_manager.cc b/src/crimson/os/seastore/random_block_manager/block_rb_manager.cc index eff58f83298..0163e8668db 100644 --- a/src/crimson/os/seastore/random_block_manager/block_rb_manager.cc +++ b/src/crimson/os/seastore/random_block_manager/block_rb_manager.cc @@ -7,7 +7,7 @@ #include "crimson/os/seastore/logging.h" #include "include/buffer.h" -#include "nvmedevice.h" +#include "rbm_device.h" #include "include/interval_set.h" #include "include/intarith.h" #include "block_rb_manager.h" diff --git a/src/crimson/os/seastore/random_block_manager/block_rb_manager.h b/src/crimson/os/seastore/random_block_manager/block_rb_manager.h index 0b46355d524..abcdd3c8771 100644 --- a/src/crimson/os/seastore/random_block_manager/block_rb_manager.h +++ b/src/crimson/os/seastore/random_block_manager/block_rb_manager.h @@ -15,7 +15,7 @@ #include "crimson/osd/exceptions.h" #include "crimson/os/seastore/transaction.h" -#include "nvmedevice.h" +#include "rbm_device.h" #include "crimson/os/seastore/random_block_manager.h" #include "crimson/common/layout.h" @@ -26,8 +26,8 @@ namespace crimson::os::seastore { constexpr uint32_t RBM_SUPERBLOCK_SIZE = 4096; -using NVMeBlockDevice = nvme_device::NVMeBlockDevice; -using NVMeBlockDeviceRef = std::unique_ptr; +using RBMDevice = nvme_device::RBMDevice; +using RBMDeviceRef = std::unique_ptr; enum { // TODO: This allows the device to manage crc on a block by itself @@ -294,7 +294,7 @@ public: * on a device, so start and end location of the device are needed to * support such case. */ - BlockRBManager(NVMeBlockDevice * device, std::string path) + BlockRBManager(RBMDevice * device, std::string path) : device(device), path(path) {} /* @@ -370,7 +370,7 @@ private: */ rbm_metadata_header_t super; //FreelistManager free_manager; // TODO: block management - NVMeBlockDevice * device; + RBMDevice * device; std::string path; int stream_id; // for multi-stream }; diff --git a/src/crimson/os/seastore/random_block_manager/nvmedevice.cc b/src/crimson/os/seastore/random_block_manager/nvme_block_device.cc similarity index 93% rename from src/crimson/os/seastore/random_block_manager/nvmedevice.cc rename to src/crimson/os/seastore/random_block_manager/nvme_block_device.cc index 365a371000a..ec0c29c2dc8 100644 --- a/src/crimson/os/seastore/random_block_manager/nvmedevice.cc +++ b/src/crimson/os/seastore/random_block_manager/nvme_block_device.cc @@ -10,7 +10,7 @@ #include "crimson/common/errorator-loop.h" #include "include/buffer.h" -#include "nvmedevice.h" +#include "rbm_device.h" namespace { seastar::logger& logger() { @@ -20,7 +20,7 @@ namespace { namespace crimson::os::seastore::nvme_device { -open_ertr::future<> PosixNVMeDevice::open( +open_ertr::future<> NVMeBlockDevice::open( const std::string &in_path, seastar::open_flags mode) { return seastar::do_with(in_path, [this, mode](auto& in_path) { @@ -62,7 +62,7 @@ open_ertr::future<> PosixNVMeDevice::open( }); } -open_ertr::future<> PosixNVMeDevice::open_for_io( +open_ertr::future<> NVMeBlockDevice::open_for_io( const std::string& in_path, seastar::open_flags mode) { io_device.resize(stream_id_count); @@ -80,7 +80,7 @@ open_ertr::future<> PosixNVMeDevice::open_for_io( }); } -write_ertr::future<> PosixNVMeDevice::write( +write_ertr::future<> NVMeBlockDevice::write( uint64_t offset, bufferptr &bptr, uint16_t stream) { @@ -109,7 +109,7 @@ write_ertr::future<> PosixNVMeDevice::write( }); } -read_ertr::future<> PosixNVMeDevice::read( +read_ertr::future<> NVMeBlockDevice::read( uint64_t offset, bufferptr &bptr) { logger().debug( @@ -133,7 +133,7 @@ read_ertr::future<> PosixNVMeDevice::read( }); } -write_ertr::future<> PosixNVMeDevice::writev( +write_ertr::future<> NVMeBlockDevice::writev( uint64_t offset, ceph::bufferlist bl, uint16_t stream) { @@ -179,7 +179,7 @@ write_ertr::future<> PosixNVMeDevice::writev( }); } -Device::close_ertr::future<> PosixNVMeDevice::close() { +Device::close_ertr::future<> NVMeBlockDevice::close() { logger().debug(" close "); return device.close().then([this]() { return seastar::do_for_each(io_device, [](auto target_device) { @@ -189,7 +189,7 @@ Device::close_ertr::future<> PosixNVMeDevice::close() { } nvme_command_ertr::future -PosixNVMeDevice::identify_controller() { +NVMeBlockDevice::identify_controller() { return seastar::do_with( nvme_admin_command_t(), nvme_identify_controller_data_t(), @@ -206,12 +206,12 @@ PosixNVMeDevice::identify_controller() { }); } -discard_ertr::future<> PosixNVMeDevice::discard(uint64_t offset, uint64_t len) { +discard_ertr::future<> NVMeBlockDevice::discard(uint64_t offset, uint64_t len) { return device.discard(offset, len); } nvme_command_ertr::future -PosixNVMeDevice::identify_namespace() { +NVMeBlockDevice::identify_namespace() { return get_nsid().safe_then([this](auto nsid) { return seastar::do_with( nvme_admin_command_t(), @@ -231,11 +231,11 @@ PosixNVMeDevice::identify_namespace() { }); } -nvme_command_ertr::future PosixNVMeDevice::get_nsid() { +nvme_command_ertr::future NVMeBlockDevice::get_nsid() { return device.ioctl(NVME_IOCTL_ID, nullptr); } -nvme_command_ertr::future PosixNVMeDevice::pass_admin( +nvme_command_ertr::future NVMeBlockDevice::pass_admin( nvme_admin_command_t& admin_cmd) { return device.ioctl(NVME_IOCTL_ADMIN_CMD, &admin_cmd).handle_exception( [](auto e)->nvme_command_ertr::future { @@ -244,7 +244,7 @@ nvme_command_ertr::future PosixNVMeDevice::pass_admin( }); } -nvme_command_ertr::future PosixNVMeDevice::pass_through_io( +nvme_command_ertr::future NVMeBlockDevice::pass_through_io( nvme_io_command_t& io_cmd) { return device.ioctl(NVME_IOCTL_IO_CMD, &io_cmd); } diff --git a/src/crimson/os/seastore/random_block_manager/nvmedevice.h b/src/crimson/os/seastore/random_block_manager/rbm_device.h similarity index 91% rename from src/crimson/os/seastore/random_block_manager/nvmedevice.h rename to src/crimson/os/seastore/random_block_manager/rbm_device.h index d097ccc8375..b3c1ade771a 100644 --- a/src/crimson/os/seastore/random_block_manager/nvmedevice.h +++ b/src/crimson/os/seastore/random_block_manager/rbm_device.h @@ -221,18 +221,7 @@ struct io_context_t { bool done = false; }; -/* - * Interface between NVMe SSD and its user. - * - * NVMeBlockDevice provides not only the basic APIs for IO, but also helper APIs - * to accelerate SSD IO performance and reduce system overhead. By aggresively - * utilizing and abstract useful features of latest NVMe SSD, it helps user ease - * to get high performance of NVMe SSD and low system overhead. - * - * Various implementations with different interfaces such as POSIX APIs, Seastar, - * and SPDK, are available. - */ -class NVMeBlockDevice : public Device { +class RBMDevice : public Device { public: using Device::read; read_ertr::future<> read ( @@ -248,17 +237,12 @@ protected: // LBA Size uint64_t block_size = 4096; - uint64_t write_granularity = 4096; - uint64_t write_alignment = 4096; - uint32_t atomic_write_unit = 4096; - - bool data_protection_enabled = false; device_id_t device_id; seastore_meta_t meta; secondary_device_set_t devices; public: - NVMeBlockDevice() {} - virtual ~NVMeBlockDevice() = default; + RBMDevice() {} + virtual ~RBMDevice() = default; template static std::unique_ptr create() { @@ -287,32 +271,9 @@ public: secondary_device_set_t& get_secondary_devices() final { return devices; } - - /* - * Service NVMe device relative size - * - * size : total size of device in byte. - * - * block_size : IO unit size in byte. Caller should follow every IO command - * aligned with block size. - * - * preffered_write_granularity(PWG), preffered_write_alignment(PWA) : IO unit - * size for write in byte. Caller should request every write IO sized multiple - * times of PWG and aligned starting address by PWA. Available only if NVMe - * Device supports NVMe protocol 1.4 or later versions. - * atomic_write_unit : The maximum size of write whose atomicity is guranteed - * by SSD even on power failure. The write equal to or smaller than - * atomic_write_unit does not require fsync(). - */ - std::size_t get_size() const { return size; } seastore_off_t get_block_size() const { return block_size; } - uint64_t get_preffered_write_granularity() const { return write_granularity; } - uint64_t get_preffered_write_alignment() const { return write_alignment; } - - uint64_t get_atomic_write_unit() const { return atomic_write_unit; } - virtual read_ertr::future<> read( uint64_t offset, bufferptr &bptr) = 0; @@ -342,67 +303,37 @@ public: ceph::bufferlist bl, uint16_t stream = 0) = 0; - /* - * For passsing through nvme IO or Admin command to SSD - * Caller can construct and execute its own nvme command - */ - virtual nvme_command_ertr::future pass_through_io( - nvme_io_command_t& command) { return seastar::make_ready_future(0); } - virtual nvme_command_ertr::future pass_admin( - nvme_admin_command_t& command) { return seastar::make_ready_future(0); } - - /* - * End-to-End Data Protection - * - * NVMe device keeps track of data integrity similar with checksum. Client can - * offload checksuming to NVMe device to reduce its CPU utilization. If data - * protection is enabled, checksum is calculated on every write and used to - * verify data on every read. - */ - bool is_data_protection_enabled() const { return data_protection_enabled; } - - /* - * Data Health - * - * Returns list of LBAs which have almost corrupted data. Data of the LBAs - * will be corrupted very soon. Caller can overwrite, unmap or refresh data to - * protect data - */ - virtual nvme_command_ertr::future> get_data_health() { - std::list fragile_lbas; - return nvme_command_ertr::future>( - nvme_command_ertr::ready_future_marker{}, - fragile_lbas - ); - } - - /* - * Recovery Level - * - * Regulate magnitude of SSD-internal data recovery. Caller can get good read - * latency with lower magnitude. - */ - virtual nvme_command_ertr::future<> set_data_recovery_level( - uint32_t level) { return nvme_command_ertr::now(); } - - /* - * Predictable Latency - * - * NVMe device can guarantee IO latency within pre-defined time window. This - * functionality will be analyzed soon. - */ + bool is_data_protection_enabled() const { return false; } }; /* * Implementation of NVMeBlockDevice with POSIX APIs * - * PosixNVMeDevice provides NVMe SSD interfaces through POSIX APIs which is + * NVMeBlockDevice provides NVMe SSD interfaces through POSIX APIs which is * generally available at most operating environment. */ -class PosixNVMeDevice : public NVMeBlockDevice { +class NVMeBlockDevice : public RBMDevice { public: - PosixNVMeDevice() {} - ~PosixNVMeDevice() = default; + + /* + * Service NVMe device relative size + * + * size : total size of device in byte. + * + * block_size : IO unit size in byte. Caller should follow every IO command + * aligned with block size. + * + * preffered_write_granularity(PWG), preffered_write_alignment(PWA) : IO unit + * size for write in byte. Caller should request every write IO sized multiple + * times of PWG and aligned starting address by PWA. Available only if NVMe + * Device supports NVMe protocol 1.4 or later versions. + * atomic_write_unit : The maximum size of write whose atomicity is guranteed + * by SSD even on power failure. The write equal to or smaller than + * atomic_write_unit does not require fsync(). + */ + + NVMeBlockDevice() {} + ~NVMeBlockDevice() = default; open_ertr::future<> open( const std::string &in_path, @@ -413,7 +344,7 @@ public: bufferptr &bptr, uint16_t stream = 0) override; - using NVMeBlockDevice::read; + using RBMDevice::read; read_ertr::future<> read( uint64_t offset, bufferptr &bptr) final; @@ -437,14 +368,61 @@ public: ceph::bufferlist bl, uint16_t stream = 0) final; + uint64_t get_preffered_write_granularity() const { return write_granularity; } + uint64_t get_preffered_write_alignment() const { return write_alignment; } + uint64_t get_atomic_write_unit() const { return atomic_write_unit; } + /* + * End-to-End Data Protection + * + * NVMe device keeps track of data integrity similar with checksum. Client can + * offload checksuming to NVMe device to reduce its CPU utilization. If data + * protection is enabled, checksum is calculated on every write and used to + * verify data on every read. + */ + bool is_data_protection_enabled() const { return data_protection_enabled; } + + /* + * Data Health + * + * Returns list of LBAs which have almost corrupted data. Data of the LBAs + * will be corrupted very soon. Caller can overwrite, unmap or refresh data to + * protect data + */ + virtual nvme_command_ertr::future> get_data_health() { + std::list fragile_lbas; + return nvme_command_ertr::future>( + nvme_command_ertr::ready_future_marker{}, + fragile_lbas + ); + } + + /* + * Recovery Level + * + * Regulate magnitude of SSD-internal data recovery. Caller can get good read + * latency with lower magnitude. + */ + virtual nvme_command_ertr::future<> set_data_recovery_level( + uint32_t level) { return nvme_command_ertr::now(); } + /* + * For passsing through nvme IO or Admin command to SSD + * Caller can construct and execute its own nvme command + */ nvme_command_ertr::future pass_admin( - nvme_admin_command_t& admin_cmd) override; + nvme_admin_command_t& admin_cmd); nvme_command_ertr::future pass_through_io( - nvme_io_command_t& io_cmd) override; + nvme_io_command_t& io_cmd); bool support_multistream = false; uint8_t data_protection_type = 0; + /* + * Predictable Latency + * + * NVMe device can guarantee IO latency within pre-defined time window. This + * functionality will be analyzed soon. + */ + private: // identify_controller/namespace are used to get SSD internal information such // as supported features, NPWG and NPWA @@ -460,10 +438,16 @@ private: uint32_t stream_index_to_open = WRITE_LIFE_NOT_SET; uint32_t stream_id_count = 1; // stream is disabled, defaultly. uint32_t awupf = 0; + + uint64_t write_granularity = 4096; + uint64_t write_alignment = 4096; + uint32_t atomic_write_unit = 4096; + + bool data_protection_enabled = false; }; -class TestMemory : public NVMeBlockDevice { +class TestMemory : public RBMDevice { public: TestMemory(size_t size) : buf(nullptr), size(size) {} @@ -491,7 +475,7 @@ public: bufferptr &bptr, uint16_t stream = 0) override; - using NVMeBlockDevice::read; + using RBMDevice::read; read_ertr::future<> read( uint64_t offset, bufferptr &bptr) override; diff --git a/src/test/crimson/seastore/nvmedevice/test_nvmedevice.cc b/src/test/crimson/seastore/nvmedevice/test_nvmedevice.cc index a89688f6240..750dcd7f35c 100644 --- a/src/test/crimson/seastore/nvmedevice/test_nvmedevice.cc +++ b/src/test/crimson/seastore/nvmedevice/test_nvmedevice.cc @@ -2,7 +2,7 @@ // vim: ts=8 sw=2 smarttab #include "include/buffer.h" -#include "crimson/os/seastore/random_block_manager/nvmedevice.h" +#include "crimson/os/seastore/random_block_manager/rbm_device.h" #include "test/crimson/gtest_seastar.h" #include "include/stringify.h" @@ -12,7 +12,7 @@ using namespace crimson::os::seastore; using namespace nvme_device; struct nvdev_test_t : seastar_test_suite_t { - std::unique_ptr device; + std::unique_ptr device; std::string dev_path; static const uint64_t DEV_SIZE = 1024 * 1024 * 1024; @@ -53,7 +53,7 @@ WRITE_CLASS_DENC_BOUNDED( TEST_F(nvdev_test_t, write_and_verify_test) { run_async([this] { - device = NVMeBlockDevice::create(); + device = RBMDevice::create(); device->open(dev_path, seastar::open_flags::rw).unsafe_get(); nvdev_test_block_t original_data; std::minstd_rand0 generator; diff --git a/src/test/crimson/seastore/test_cbjournal.cc b/src/test/crimson/seastore/test_cbjournal.cc index 58cce663a92..7e67fcedd3a 100644 --- a/src/test/crimson/seastore/test_cbjournal.cc +++ b/src/test/crimson/seastore/test_cbjournal.cc @@ -10,7 +10,7 @@ #include "crimson/os/seastore/journal.h" #include "crimson/os/seastore/journal/circular_bounded_journal.h" #include "crimson/os/seastore/random_block_manager.h" -#include "crimson/os/seastore/random_block_manager/nvmedevice.h" +#include "crimson/os/seastore/random_block_manager/rbm_device.h" #include "test/crimson/seastore/transaction_manager_test_state.h" using namespace crimson; @@ -126,7 +126,7 @@ struct cbjournal_test_t : public seastar_test_suite_t Cache cache; std::vector entries; std::unique_ptr cbj; - nvme_device::NVMeBlockDevice *device; + nvme_device::RBMDevice *device; std::default_random_engine generator; uint64_t block_size; diff --git a/src/test/crimson/seastore/test_randomblock_manager.cc b/src/test/crimson/seastore/test_randomblock_manager.cc index 8696828f2c7..edaad43c33a 100644 --- a/src/test/crimson/seastore/test_randomblock_manager.cc +++ b/src/test/crimson/seastore/test_randomblock_manager.cc @@ -7,7 +7,7 @@ #include "crimson/common/log.h" #include "crimson/os/seastore/random_block_manager/block_rb_manager.h" -#include "crimson/os/seastore/random_block_manager/nvmedevice.h" +#include "crimson/os/seastore/random_block_manager/rbm_device.h" #include "test/crimson/seastore/transaction_manager_test_state.h" using namespace crimson; @@ -26,7 +26,7 @@ constexpr uint64_t DEFAULT_BLOCK_SIZE = 4096; struct rbm_test_t : public seastar_test_suite_t, TMTestState { std::unique_ptr rbm_manager; - std::unique_ptr device; + std::unique_ptr device; struct rbm_transaction { void add_rbm_allocated_blocks(alloc_delta_t &d) { diff --git a/src/test/crimson/seastore/transaction_manager_test_state.h b/src/test/crimson/seastore/transaction_manager_test_state.h index ed5bdef02fc..bb7287f1d8e 100644 --- a/src/test/crimson/seastore/transaction_manager_test_state.h +++ b/src/test/crimson/seastore/transaction_manager_test_state.h @@ -14,7 +14,7 @@ #include "crimson/os/seastore/segment_manager.h" #include "crimson/os/seastore/collection_manager/flat_collection_manager.h" #include "crimson/os/seastore/onode_manager/staged-fltree/fltree_onode_manager.h" -#include "crimson/os/seastore/random_block_manager/nvmedevice.h" +#include "crimson/os/seastore/random_block_manager/rbm_device.h" #include "crimson/os/seastore/journal/circular_bounded_journal.h" using namespace crimson; @@ -25,7 +25,7 @@ class EphemeralTestState { protected: segment_manager::EphemeralSegmentManagerRef segment_manager; std::list secondary_segment_managers; - std::unique_ptr rb_device; + std::unique_ptr rb_device; tm_make_config_t tm_config = tm_make_config_t::get_test_segmented_journal(); EphemeralTestState(std::size_t num_segment_managers) { -- 2.39.5