return out << "SSD";
case device_type_t::ZNS:
return out << "ZNS";
- case device_type_t::SEGMENTED_EPHEMERAL:
- return out << "SEGMENTED_EPHEMERAL";
+ case device_type_t::EPHEMERAL_COLD:
+ return out << "EPHEMERAL_COLD";
+ case device_type_t::EPHEMERAL_MAIN:
+ return out << "EPHEMERAL_MAIN";
case device_type_t::RANDOM_BLOCK_SSD:
return out << "RANDOM_BLOCK_SSD";
case device_type_t::RANDOM_BLOCK_EPHEMERAL:
HDD,
SSD,
ZNS,
- SEGMENTED_EPHEMERAL,
+ EPHEMERAL_COLD,
+ EPHEMERAL_MAIN,
RANDOM_BLOCK_SSD,
RANDOM_BLOCK_EPHEMERAL,
NUM_TYPES
assert(dtype != device_type_t::NONE &&
dtype != device_type_t::NUM_TYPES);
if (dtype >= device_type_t::HDD &&
- dtype <= device_type_t::SEGMENTED_EPHEMERAL) {
+ dtype <= device_type_t::EPHEMERAL_MAIN) {
return backend_type_t::SEGMENTED;
} else {
return backend_type_t::RANDOM_BLOCK;
}
device_config_t get_ephemeral_device_config(
- std::size_t index, std::size_t num_devices)
+ std::size_t index,
+ std::size_t num_main_devices,
+ std::size_t num_cold_devices)
{
+ auto num_devices = num_main_devices + num_cold_devices;
assert(num_devices > index);
+ auto get_sec_dtype = [num_main_devices](std::size_t idx) {
+ if (idx < num_main_devices) {
+ return device_type_t::EPHEMERAL_MAIN;
+ } else {
+ return device_type_t::EPHEMERAL_COLD;
+ }
+ };
+
magic_t magic = 0xabcd;
- auto type = device_type_t::SEGMENTED_EPHEMERAL;
bool is_major_device;
secondary_device_set_t secondary_devices;
if (index == 0) {
++secondary_index) {
device_id_t secondary_id = static_cast<device_id_t>(secondary_index);
secondary_devices.insert({
- secondary_index, device_spec_t{magic, type, secondary_id}
+ secondary_index,
+ device_spec_t{
+ magic,
+ get_sec_dtype(secondary_index),
+ secondary_id
+ }
});
}
} else { // index > 0
device_id_t id = static_cast<device_id_t>(index);
seastore_meta_t meta = {};
return {is_major_device,
- device_spec_t{magic, type, id},
+ device_spec_t{
+ magic,
+ get_sec_dtype(index),
+ id
+ },
meta,
secondary_devices};
}
EphemeralSegmentManagerRef create_test_ephemeral();
device_config_t get_ephemeral_device_config(
- std::size_t index, std::size_t num_devices);
+ std::size_t index,
+ std::size_t num_main_devices,
+ std::size_t num_cold_devices);
class EphemeralSegment final : public Segment {
friend class EphemeralSegmentManager;
std::optional<device_config_t> device_config;
device_type_t get_device_type() const final {
- return device_type_t::SEGMENTED_EPHEMERAL;
+ assert(device_config);
+ return device_config->spec.dtype;
}
size_t get_offset(paddr_t addr) {
auto p_backend_type = primary_device->get_backend_type();
if (p_backend_type == backend_type_t::SEGMENTED) {
+ auto dtype = primary_device->get_device_type();
+ ceph_assert(dtype != device_type_t::HDD &&
+ dtype != device_type_t::EPHEMERAL_COLD);
sms->add_segment_manager(static_cast<SegmentManager*>(primary_device));
} else {
auto rbm = std::make_unique<BlockRBManager>(
return segment_manager->init(
).safe_then([this] {
return segment_manager->mkfs(
- segment_manager::get_ephemeral_device_config(0, 1));
+ segment_manager::get_ephemeral_device_config(0, 1, 0));
}).safe_then([this] {
sms.reset(new SegmentManagerGroup());
journal = journal::make_segmented(*this, *this);
return segment_manager->init(
).safe_then([this] {
return segment_manager->mkfs(
- segment_manager::get_ephemeral_device_config(0, 1));
+ segment_manager::get_ephemeral_device_config(0, 1, 0));
}).safe_then([this] {
epm.reset(new ExtentPlacementManager());
cache.reset(new Cache(*epm));
return segment_manager->init(
).safe_then([this] {
return segment_manager->mkfs(
- segment_manager::get_ephemeral_device_config(0, 1));
+ segment_manager::get_ephemeral_device_config(0, 1, 0));
}).safe_then([this] {
block_size = segment_manager->get_block_size();
sms.reset(new SegmentManagerGroup());
});
}).safe_then([this] {
return segment_manager->mkfs(
- segment_manager::get_ephemeral_device_config(0, get_num_devices()));
+ segment_manager::get_ephemeral_device_config(0, get_num_devices(), 0));
}).safe_then([this] {
return seastar::do_with(std::size_t(0), [this](auto &cnt) {
return crimson::do_for_each(
{
++cnt;
return sec_sm->mkfs(
- segment_manager::get_ephemeral_device_config(cnt, get_num_devices()));
+ segment_manager::get_ephemeral_device_config(cnt, get_num_devices(), 0));
});
});
}).handle_error(