journal/segmented_journal.cc
journal/segment_allocator.cc
journal.cc
+ device.cc
../../../test/crimson/seastore/test_block.cc
${PROJECT_SOURCE_DIR}/src/os/Transaction.cc
)
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*-
+// vim: ts=8 sw=2 smarttab
+
+#include "device.h"
+
+#include "segment_manager.h"
+
+namespace crimson::os::seastore {
+
+std::ostream& operator<<(std::ostream& out, const device_spec_t& ds)
+{
+ return out << "device_spec("
+ << "magic=" << ds.magic
+ << ", device_type=" << ds.dtype
+ << ", device_id=" << device_id_printer_t{ds.id}
+ << ")";
+}
+
+std::ostream& operator<<(std::ostream& out, const device_config_t& conf)
+{
+ out << "device_config_t("
+ << "major_dev=" << conf.major_dev
+ << ", magic=" << conf.magic
+ << ", device_type=" << conf.dtype
+ << ", device_id=" << device_id_printer_t{conf.device_id}
+ << ", meta=" << conf.meta
+ << ", secondary(";
+ for (const auto& [k, v] : conf.secondary_devices) {
+ out << std::to_string(k) << ": " << v;
+ }
+ return out << "))";
+}
+
+seastar::future<DeviceRef>
+Device::make_device(const std::string& device)
+{
+ // TODO: configure device type
+ return SegmentManager::get_segment_manager(device
+ ).then([](DeviceRef ret) {
+ return ret;
+ });
+}
+
+}
#include "include/buffer_fwd.h"
#include "crimson/common/errorator.h"
+#include "crimson/os/seastore/seastore_types.h"
namespace crimson::os::seastore {
+using magic_t = uint64_t;
+
+struct device_spec_t{
+ magic_t magic;
+ device_type_t dtype;
+ device_id_t id;
+ DENC(device_spec_t, v, p) {
+ DENC_START(1, 1, p);
+ denc(v.magic, p);
+ denc(v.dtype, p);
+ denc(v.id, p);
+ DENC_FINISH(p);
+ }
+};
+
+std::ostream& operator<<(std::ostream&, const device_spec_t&);
+
+using secondary_device_set_t =
+ std::map<device_id_t, device_spec_t>;
+
+struct device_config_t {
+ bool major_dev = false;
+ magic_t magic = 0;
+ device_type_t dtype = device_type_t::NONE;
+ device_id_t device_id = DEVICE_ID_NULL;
+ seastore_meta_t meta;
+ secondary_device_set_t secondary_devices;
+};
+
+std::ostream& operator<<(std::ostream&, const device_config_t&);
+
+class Device;
+using DeviceRef = std::unique_ptr<Device>;
+
/**
* Device
*
*/
class Device {
public:
+ virtual ~Device() {}
+
virtual device_id_t get_device_id() const = 0;
+ virtual magic_t get_magic() const = 0;
+
+ virtual device_type_t get_device_type() const = 0;
+
+ virtual const seastore_meta_t &get_meta() const = 0;
+
virtual seastore_off_t get_block_size() const = 0;
+ virtual std::size_t get_size() const = 0;
+
+ virtual secondary_device_set_t& get_secondary_devices() = 0;
+
+ using access_ertr = crimson::errorator<
+ crimson::ct_error::input_output_error,
+ crimson::ct_error::permission_denied,
+ crimson::ct_error::enoent>;
+
+ using mkfs_ertr = access_ertr;
+ using mkfs_ret = mkfs_ertr::future<>;
+ virtual mkfs_ret mkfs(device_config_t) = 0;
+
+ using mount_ertr = access_ertr;
+ using mount_ret = access_ertr::future<>;
+ virtual mount_ret mount() = 0;
+
+ using close_ertr = crimson::errorator<
+ crimson::ct_error::input_output_error>;
+ virtual close_ertr::future<> close() = 0;
+
using read_ertr = crimson::errorator<
crimson::ct_error::input_output_error,
crimson::ct_error::invarg,
return read_ertr::make_ready_future<bufferptr>(std::move(*ptrref));
});
}
+
+ static seastar::future<DeviceRef> make_device(const std::string &device);
};
}
+
+WRITE_CLASS_DENC(
+ crimson::os::seastore::device_spec_t
+)
#include "crimson/os/futurized_collection.h"
#include "crimson/os/seastore/segment_cleaner.h"
-#include "crimson/os/seastore/segment_manager.h"
-#include "crimson/os/seastore/segment_manager/block.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/omap_manager/btree/btree_omap_manager.h"
-#include "crimson/os/seastore/segment_manager/ephemeral.h"
#include "crimson/os/seastore/onode_manager.h"
#include "crimson/os/seastore/object_data_handler.h"
SeaStore::SeaStore(
const std::string& root,
MDStoreRef mdstore,
- SegmentManagerRef sm,
+ DeviceRef dev,
TransactionManagerRef tm,
CollectionManagerRef cm,
OnodeManagerRef om)
: root(root),
mdstore(std::move(mdstore)),
- segment_manager(std::move(sm)),
+ device(std::move(dev)),
transaction_manager(std::move(tm)),
collection_manager(std::move(cm)),
onode_manager(std::move(om)),
SeaStore::SeaStore(
const std::string& root,
- SegmentManagerRef sm,
+ DeviceRef dev,
TransactionManagerRef tm,
CollectionManagerRef cm,
OnodeManagerRef om)
: SeaStore(
root,
std::make_unique<FileMDStore>(root),
- std::move(sm), std::move(tm), std::move(cm), std::move(om)) {}
+ std::move(dev), std::move(tm), std::move(cm), std::move(om)) {}
SeaStore::~SeaStore() = default;
SeaStore::mount_ertr::future<> SeaStore::mount()
{
- return segment_manager->mount(
+ secondaries.clear();
+ return device->mount(
).safe_then([this] {
- transaction_manager->add_segment_manager(segment_manager.get(), true);
- auto sec_devices = segment_manager->get_secondary_devices();
+ transaction_manager->add_device(device.get(), true);
+ auto sec_devices = device->get_secondary_devices();
return crimson::do_for_each(sec_devices, [this](auto& device_entry) {
device_id_t id = device_entry.first;
magic_t magic = device_entry.second.magic;
device_type_t dtype = device_entry.second.dtype;
std::ostringstream oss;
oss << root << "/block." << dtype << "." << std::to_string(id);
- auto sm = std::make_unique<
- segment_manager::block::BlockSegmentManager>(oss.str());
- return sm->mount().safe_then(
- [this, sm=std::move(sm), magic]() mutable {
- boost::ignore_unused(magic); // avoid clang warning;
- assert(sm->get_magic() == magic);
- transaction_manager->add_segment_manager(sm.get(), false);
- secondaries.emplace_back(std::move(sm));
- return seastar::now();
+ return Device::make_device(oss.str()
+ ).then([this, magic](DeviceRef sec_dev) {
+ return sec_dev->mount(
+ ).safe_then([this, sec_dev=std::move(sec_dev), magic]() mutable {
+ boost::ignore_unused(magic); // avoid clang warning;
+ assert(sec_dev->get_magic() == magic);
+ transaction_manager->add_device(sec_dev.get(), false);
+ secondaries.emplace_back(std::move(sec_dev));
+ });
});
});
}).safe_then([this] {
).safe_then([this] {
return crimson::do_for_each(
secondaries,
- [](auto& sm) -> SegmentManager::close_ertr::future<> {
- return sm->close();
+ [](auto& sec_dev) -> SegmentManager::close_ertr::future<>
+ {
+ return sec_dev->close();
});
}).safe_then([this] {
- return segment_manager->close();
+ return device->close();
}).handle_error(
crimson::ct_error::assert_all{
"Invalid error in SeaStore::umount"
LOG_PREFIX(SeaStore::mkfs);
DEBUG("root: {}", root);
if (!root.empty()) {
- fut = seastar::open_directory(root).then(
- [this, &sds, new_osd_fsid](seastar::file rdir) mutable {
+ fut = seastar::open_directory(root
+ ).then([this, &sds, new_osd_fsid](seastar::file rdir) mutable {
std::unique_ptr<seastar::file> root_f =
std::make_unique<seastar::file>(std::move(rdir));
auto sub = root_f->list_directory(
- [this, &sds, new_osd_fsid](auto de) mutable
- -> seastar::future<> {
+ [this, &sds, new_osd_fsid](auto de) mutable -> seastar::future<>
+ {
LOG_PREFIX(SeaStore::mkfs);
DEBUG("found file: {}", de.name);
if (de.name.find("block.") == 0
return seastar::now();
}
auto id = std::stoi(entry_name.substr(dtype_end + 1));
- auto sm = std::make_unique<
- segment_manager::block::BlockSegmentManager
- >(root + "/" + entry_name);
- magic_t magic = (magic_t)std::rand();
- sds.emplace(
- (device_id_t)id,
- device_spec_t{
- magic,
- dtype,
- (device_id_t)id});
- return sm->mkfs(
- segment_manager_config_t{
- false,
- magic,
- dtype,
+ std::ostringstream oss;
+ oss << root << "/" << entry_name;
+ return Device::make_device(oss.str()
+ ).then([this, &sds, id, dtype, new_osd_fsid](DeviceRef sec_dev) {
+ magic_t magic = (magic_t)std::rand();
+ sds.emplace(
(device_id_t)id,
- seastore_meta_t{new_osd_fsid},
- secondary_device_set_t()}
- ).safe_then([this, sm=std::move(sm), id]() mutable {
- LOG_PREFIX(SeaStore::mkfs);
- DEBUG("mkfs: finished for segment manager {}", id);
- secondaries.emplace_back(std::move(sm));
- return seastar::now();
- }).handle_error(crimson::ct_error::assert_all{"not possible"});
+ device_spec_t{magic, dtype, (device_id_t)id});
+ return sec_dev->mkfs(device_config_t{
+ false,
+ magic,
+ dtype,
+ (device_id_t)id,
+ seastore_meta_t{new_osd_fsid},
+ secondary_device_set_t()}
+ ).safe_then([this, sec_dev=std::move(sec_dev), id]() mutable {
+ LOG_PREFIX(SeaStore::mkfs);
+ DEBUG("mkfs: finished for device {}", id);
+ secondaries.emplace_back(std::move(sec_dev));
+ }).handle_error(crimson::ct_error::assert_all{"not possible"});
+ });
}
- return seastar::now();
- });
- return sub.done().then(
- [root_f=std::move(root_f)] {
return seastar::now();
});
+ return sub.done().then([root_f=std::move(root_f)] {});
});
}
return fut.then([this, &sds, new_osd_fsid] {
- return segment_manager->mkfs(
- segment_manager_config_t{
+ return device->mkfs(
+ device_config_t{
true,
(magic_t)std::rand(),
device_type_t::SEGMENTED,
sds}
);
}).safe_then([this] {
- return crimson::do_for_each(secondaries, [this](auto& sec_sm) {
- return sec_sm->mount().safe_then([this, &sec_sm] {
- transaction_manager->add_segment_manager(sec_sm.get(), false);
+ return crimson::do_for_each(secondaries, [this](auto& sec_dev) {
+ return sec_dev->mount().safe_then([this, &sec_dev] {
+ transaction_manager->add_device(sec_dev.get(), false);
return seastar::now();
});
});
});
}).safe_then([this] {
- return segment_manager->mount();
+ return device->mount();
}).safe_then([this] {
- transaction_manager->add_segment_manager(segment_manager.get(), true);
+ transaction_manager->add_device(device.get(), true);
return transaction_manager->mkfs();
}).safe_then([this] {
- for (auto& sec_sm : secondaries) {
- transaction_manager->add_segment_manager(sec_sm.get(), false);
+ for (auto& sec_dev : secondaries) {
+ transaction_manager->add_device(sec_dev.get(), false);
}
- transaction_manager->add_segment_manager(segment_manager.get(), true);
+ transaction_manager->add_device(device.get(), true);
return transaction_manager->mount();
}).safe_then([this] {
return repeat_eagain([this] {
return _omap_get_value(
t,
layout.xattr_root.get(
- onode.get_metadata_hint(segment_manager->get_block_size())),
+ onode.get_metadata_hint(device->get_block_size())),
name);
}
).handle_error(crimson::ct_error::input_output_error::handle([FNAME] {
struct stat st;
auto &olayout = onode.get_layout();
st.st_size = olayout.size;
- st.st_blksize = segment_manager->get_block_size();
+ st.st_blksize = device->get_block_size();
st.st_blocks = (st.st_size + st.st_blksize - 1) / st.st_blksize;
st.st_nlink = 1;
DEBUGT("cid {}, oid {}, return size {}", t, c->get_cid(), oid, st.st_size);
op_type_t::OMAP_GET_VALUES,
[this, keys](auto &t, auto &onode) {
omap_root_t omap_root = onode.get_layout().omap_root.get(
- onode.get_metadata_hint(segment_manager->get_block_size()));
+ onode.get_metadata_hint(device->get_block_size()));
return _omap_get_values(
t,
std::move(omap_root),
OMapManager::omap_list_config_t config) const
{
auto root = omap_root.get(
- onode.get_metadata_hint(segment_manager->get_block_size()));
+ onode.get_metadata_hint(device->get_block_size()));
if (root.is_null()) {
return seastar::make_ready_future<_omap_list_bare_ret>(
true, omap_values_t{}
{
return seastar::do_with(
BtreeOMapManager(*transaction_manager),
- omap_root.get(onode->get_metadata_hint(segment_manager->get_block_size())),
+ omap_root.get(onode->get_metadata_hint(device->get_block_size())),
[&, keys=std::move(kvs)](auto &omap_manager, auto &root) {
tm_iertr::future<> maybe_create_root =
!root.is_null() ?
tm_iertr::now() :
omap_manager.initialize_omap(
- t, onode->get_metadata_hint(segment_manager->get_block_size())
+ t, onode->get_metadata_hint(device->get_block_size())
).si_then([&root](auto new_root) {
root = new_root;
});
LOG_PREFIX(SeaStore::_omap_clear);
DEBUGT("{} {} keys", *ctx.transaction, *onode);
if (auto omap_root = onode->get_layout().omap_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size()));
+ onode->get_metadata_hint(device->get_block_size()));
omap_root.is_null()) {
return seastar::now();
} else {
return seastar::do_with(
BtreeOMapManager(*transaction_manager),
onode->get_layout().omap_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size())),
+ onode->get_metadata_hint(device->get_block_size())),
[&ctx, &onode](
auto &omap_manager,
auto &omap_root) {
LOG_PREFIX(SeaStore::_omap_rmkeys);
DEBUGT("{} {} keys", *ctx.transaction, *onode, keys.size());
auto omap_root = onode->get_layout().omap_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size()));
+ onode->get_metadata_hint(device->get_block_size()));
if (omap_root.is_null()) {
return seastar::now();
} else {
return seastar::do_with(
BtreeOMapManager(*transaction_manager),
onode->get_layout().omap_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size())),
+ onode->get_metadata_hint(device->get_block_size())),
std::move(keys),
[&ctx, &onode](
auto &omap_manager,
LOG_PREFIX(SeaStore::_xattr_rmattr);
DEBUGT("onode={}", *ctx.transaction, *onode);
auto xattr_root = onode->get_layout().xattr_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size()));
+ onode->get_metadata_hint(device->get_block_size()));
if (xattr_root.is_null()) {
return seastar::now();
} else {
return seastar::do_with(
BtreeOMapManager(*transaction_manager),
onode->get_layout().xattr_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size())),
+ onode->get_metadata_hint(device->get_block_size())),
std::move(name),
[&ctx, &onode](auto &omap_manager, auto &xattr_root, auto &name) {
return omap_manager.omap_rm_key(xattr_root, *ctx.transaction, name)
LOG_PREFIX(SeaStore::_xattr_clear);
DEBUGT("onode={}", *ctx.transaction, *onode);
auto xattr_root = onode->get_layout().xattr_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size()));
+ onode->get_metadata_hint(device->get_block_size()));
if (xattr_root.is_null()) {
return seastar::now();
} else {
return seastar::do_with(
BtreeOMapManager(*transaction_manager),
onode->get_layout().xattr_root.get(
- onode->get_metadata_hint(segment_manager->get_block_size())),
+ onode->get_metadata_hint(device->get_block_size())),
[&ctx, &onode](auto &omap_manager, auto &xattr_root) {
return omap_manager.omap_clear(xattr_root, *ctx.transaction)
.si_then([&] {
uuid_d SeaStore::get_fsid() const
{
- return segment_manager->get_meta().seastore_id;
+ return device->get_meta().seastore_id;
}
seastar::future<std::unique_ptr<SeaStore>> make_seastore(
const std::string &device,
const ConfigValues &config)
{
- return SegmentManager::get_segment_manager(
+ return Device::make_device(
device
- ).then([&device](auto sm) {
- auto tm = make_transaction_manager(*sm, false /* detailed */);
+ ).then([&device](DeviceRef device_obj) {
+ auto tm = make_transaction_manager(*device_obj, false /* detailed */);
auto cm = std::make_unique<collection_manager::FlatCollectionManager>(*tm);
return std::make_unique<SeaStore>(
device,
- std::move(sm),
+ std::move(device_obj),
std::move(tm),
std::move(cm),
std::make_unique<crimson::os::seastore::onode::FLTreeOnodeManager>(*tm));
#include "crimson/os/futurized_collection.h"
#include "crimson/os/futurized_store.h"
+#include "crimson/os/seastore/device.h"
#include "crimson/os/seastore/transaction.h"
#include "crimson/os/seastore/onode_manager.h"
#include "crimson/os/seastore/omap_manager.h"
SeaStore(
const std::string& root,
MDStoreRef mdstore,
- SegmentManagerRef sm,
+ DeviceRef device,
TransactionManagerRef tm,
CollectionManagerRef cm,
OnodeManagerRef om);
SeaStore(
const std::string& root,
- SegmentManagerRef sm,
+ DeviceRef device,
TransactionManagerRef tm,
CollectionManagerRef cm,
OnodeManagerRef om);
std::string root;
MDStoreRef mdstore;
- SegmentManagerRef segment_manager;
- std::vector<SegmentManagerRef> secondaries;
+ DeviceRef device;
+ std::vector<DeviceRef> secondaries;
TransactionManagerRef transaction_manager;
CollectionManagerRef collection_manager;
OnodeManagerRef onode_manager;
bool can_delay_allocation(device_type_t type) {
// Some types of device may not support delayed allocation, for example PMEM.
- return type <= device_type_t::RANDOM_BLOCK;
+ return (type >= device_type_t::NONE &&
+ type <= device_type_t::RANDOM_BLOCK);
}
device_type_t string_to_device_type(std::string type) {
namespace crimson::os::seastore {
-std::ostream& operator<<(std::ostream& out, const device_spec_t& ds)
-{
- return out << "device_spec("
- << "magic=" << ds.magic
- << ", device_type=" << ds.dtype
- << ", device_id=" << std::to_string(ds.id)
- << ")";
-}
-
std::ostream& operator<<(std::ostream& out, const block_sm_superblock_t& sb)
{
out << "superblock("
return out << "))";
}
-std::ostream& operator<<(std::ostream& out, const segment_manager_config_t& conf)
-{
- out << "sm_config_t("
- << "major_dev=" << conf.major_dev
- << ", magic=" << conf.magic
- << ", device_type=" << conf.dtype
- << ", device_id=" << std::to_string(conf.device_id)
- << ", meta=" << conf.meta
- << ", secondary(";
- for (const auto& [k, v] : conf.secondary_devices) {
- out << std::to_string(k) << ": " << v;
- }
- return out << "))";
-}
-
std::ostream& operator<<(std::ostream &out, Segment::segment_state_t s)
{
using state_t = Segment::segment_state_t;
namespace crimson::os::seastore {
-using magic_t = uint64_t;
-
-struct device_spec_t{
- magic_t magic;
- device_type_t dtype;
- device_id_t id;
- DENC(device_spec_t, v, p) {
- DENC_START(1, 1, p);
- denc(v.magic, p);
- denc(v.dtype, p);
- denc(v.id, p);
- DENC_FINISH(p);
- }
-};
-
-std::ostream& operator<<(std::ostream&, const device_spec_t&);
-
-using secondary_device_set_t =
- std::map<device_id_t, device_spec_t>;
-
struct block_sm_superblock_t {
size_t size = 0;
size_t segment_size = 0;
std::ostream& operator<<(std::ostream&, const block_sm_superblock_t&);
-struct segment_manager_config_t {
- bool major_dev = false;
- magic_t magic = 0;
- device_type_t dtype = device_type_t::NONE;
- device_id_t device_id = DEVICE_ID_NULL;
- seastore_meta_t meta;
- secondary_device_set_t secondary_devices;
-};
-
-std::ostream& operator<<(std::ostream&, const segment_manager_config_t&);
-
class Segment : public boost::intrusive_ref_counter<
Segment,
boost::thread_unsafe_counter>{
class SegmentManager : public Device {
public:
- using access_ertr = crimson::errorator<
- crimson::ct_error::input_output_error,
- crimson::ct_error::permission_denied,
- crimson::ct_error::enoent>;
-
- using mount_ertr = access_ertr;
- using mount_ret = access_ertr::future<>;
- virtual mount_ret mount() = 0;
-
- using close_ertr = crimson::errorator<
- crimson::ct_error::input_output_error
- >;
- virtual close_ertr::future<> close() = 0;
-
- using mkfs_ertr = access_ertr;
- using mkfs_ret = mkfs_ertr::future<>;
- virtual mkfs_ret mkfs(segment_manager_config_t meta) = 0;
+ device_type_t get_device_type() const final {
+ return device_type_t::SEGMENTED;
+ }
using open_ertr = crimson::errorator<
crimson::ct_error::input_output_error,
virtual release_ertr::future<> release(segment_id_t id) = 0;
/* Methods for discovering device geometry, segmentid set, etc */
- virtual size_t get_size() const = 0;
virtual seastore_off_t get_segment_size() const = 0;
virtual device_segment_id_t get_num_segments() const {
ceph_assert(get_size() % get_segment_size() == 0);
ceph::encoded_sizeof_bounded<segment_tail_t>(),
(size_t)get_block_size());
}
- virtual const seastore_meta_t &get_meta() const = 0;
-
- virtual secondary_device_set_t& get_secondary_devices() = 0;
-
- virtual device_spec_t get_device_spec() const = 0;
-
- virtual magic_t get_magic() const = 0;
virtual ~SegmentManager() {}
}
-WRITE_CLASS_DENC(
- crimson::os::seastore::device_spec_t
-)
WRITE_CLASS_DENC(
crimson::os::seastore::block_sm_superblock_t
)
static
block_sm_superblock_t make_superblock(
device_id_t device_id,
- segment_manager_config_t sm_config,
+ device_config_t sm_config,
const seastar::stat_data &data)
{
LOG_PREFIX(block_make_superblock);
}
BlockSegmentManager::mkfs_ret BlockSegmentManager::mkfs(
- segment_manager_config_t sm_config)
+ device_config_t sm_config)
{
LOG_PREFIX(BlockSegmentManager::mkfs);
set_device_id(sm_config.device_id);
public:
mount_ret mount() final;
- mkfs_ret mkfs(segment_manager_config_t) final;
+ mkfs_ret mkfs(device_config_t) final;
close_ertr::future<> close();
ceph::bufferlist bl,
bool ignore_check=false);
- device_spec_t get_device_spec() const final {
- return {superblock.magic,
- superblock.dtype,
- get_device_id()};
- }
-
magic_t get_magic() const final {
return superblock.magic;
}
size_t block_size = 0;
size_t segment_size = 0;
magic_t magic = 0;
- device_type_t dtype = device_type_t::NONE;
device_id_t id = 0;
};
4 << 10,
8 << 20,
0xabcd,
- device_type_t::SEGMENTED,
0
};
return mount_ertr::now();
}
- mkfs_ret mkfs(segment_manager_config_t) {
+ mkfs_ret mkfs(device_config_t) {
return mkfs_ertr::now();
}
return sec_device_set;
}
- device_spec_t get_device_spec() const final {
- return {config.magic, config.dtype, config.id};
- }
-
magic_t get_magic() const final {
return config.magic;
}
}
ZNSSegmentManager::mkfs_ret ZNSSegmentManager::mkfs(
- segment_manager_config_t config)
+ device_config_t config)
{
logger().error("ZNSSegmentManager::mkfs: starting");
return seastar::do_with(
return metadata.secondary_devices;
};
-device_spec_t ZNSSegmentManager::get_device_spec() const
-{
- auto spec = device_spec_t();
- spec.magic = metadata.magic;
- spec.dtype = metadata.dtype;
- spec.id = metadata.device_id;
- return spec;
-};
-
magic_t ZNSSegmentManager::get_magic() const
{
return metadata.magic;
class ZNSSegmentManager final : public SegmentManager{
public:
mount_ret mount() final;
- mkfs_ret mkfs(segment_manager_config_t meta) final;
+ mkfs_ret mkfs(device_config_t meta) final;
open_ertr::future<SegmentRef> open(segment_id_t id) final;
close_ertr::future<> close() final;
secondary_device_set_t& get_secondary_devices() final;
- device_spec_t get_device_spec() const final;
-
magic_t get_magic() const final;
ZNSSegmentManager(const std::string &path) : device_path(path) {}
TransactionManager::~TransactionManager() {}
TransactionManagerRef make_transaction_manager(
- SegmentManager& sm,
+ Device &device,
bool detailed)
{
auto scanner = std::make_unique<ExtentReader>();
SegmentCleaner::config_t::get_default(),
std::move(scanner),
detailed);
- auto journal = journal::make_segmented(sm, scanner_ref, *segment_cleaner);
+ ceph_assert(device.get_device_type() == device_type_t::SEGMENTED);
+ auto sm = dynamic_cast<SegmentManager*>(&device);
+ ceph_assert(sm != nullptr);
+ auto journal = journal::make_segmented(*sm, scanner_ref, *segment_cleaner);
auto epm = std::make_unique<ExtentPlacementManager>();
auto cache = std::make_unique<Cache>(*epm);
auto lba_manager = lba_manager::create_lba_manager(*cache);
#include "crimson/os/seastore/lba_manager.h"
#include "crimson/os/seastore/journal.h"
#include "crimson/os/seastore/extent_placement_manager.h"
+#include "crimson/os/seastore/device.h"
namespace crimson::os::seastore {
class Journal;
return segment_cleaner->stat();
}
- void add_segment_manager(SegmentManager* sm, bool is_primary) {
- LOG_PREFIX(TransactionManager::add_segment_manager);
- SUBDEBUG(seastore_tm, "adding segment manager {}, is_primary={}",
- sm->get_device_id(), is_primary);
- scanner.add_segment_manager(sm);
- epm->add_device(sm, is_primary);
+ void add_device(Device* dev, bool is_primary) {
+ LOG_PREFIX(TransactionManager::add_device);
+ SUBDEBUG(seastore_tm, "adding device {}, is_primary={}",
+ dev->get_device_id(), is_primary);
+ epm->add_device(dev, is_primary);
+
+ ceph_assert(dev->get_device_type() == device_type_t::SEGMENTED);
+ auto sm = dynamic_cast<SegmentManager*>(dev);
+ ceph_assert(sm != nullptr);
epm->add_allocator(
- device_type_t::SEGMENTED,
+ dev->get_device_type(),
std::make_unique<SegmentedAllocator>(
*segment_cleaner,
*sm,
segment_cleaner->get_ool_segment_seq_allocator()));
+ scanner.add_segment_manager(sm);
}
~TransactionManager();
using TransactionManagerRef = std::unique_ptr<TransactionManager>;
TransactionManagerRef make_transaction_manager(
- SegmentManager& sm,
+ Device &device,
bool detailed);
}
#include "tm_driver.h"
-#include "crimson/os/seastore/segment_manager/block.h"
-
using namespace crimson;
using namespace crimson::os;
using namespace crimson::os::seastore;
-using namespace crimson::os::seastore::segment_manager::block;
namespace {
seastar::logger& logger() {
bufferptr ptr)
{
logger().debug("Writing offset {}", offset);
- assert(offset % segment_manager->get_block_size() == 0);
- assert((ptr.length() % (size_t)segment_manager->get_block_size()) == 0);
+ assert(offset % device->get_block_size() == 0);
+ assert((ptr.length() % (size_t)device->get_block_size()) == 0);
return seastar::do_with(ptr, [this, offset](auto& ptr) {
return repeat_eagain([this, offset, &ptr] {
return tm->with_transaction_intr(
size_t size)
{
logger().debug("Reading offset {}", offset);
- assert(offset % segment_manager->get_block_size() == 0);
- assert(size % (size_t)segment_manager->get_block_size() == 0);
+ assert(offset % device->get_block_size() == 0);
+ assert(size % (size_t)device->get_block_size() == 0);
auto blptrret = std::make_unique<bufferlist>();
auto &blret = *blptrret;
return repeat_eagain([=, &blret] {
void TMDriver::init()
{
- tm = make_transaction_manager(*segment_manager, false /* detailed */);
- tm->add_segment_manager(segment_manager.get(), true);
+ tm = make_transaction_manager(*device, false /* detailed */);
+ tm->add_device(device.get(), true);
}
void TMDriver::clear()
size_t TMDriver::get_size() const
{
- return segment_manager->get_size() * .5;
+ return device->get_size() * .5;
}
seastar::future<> TMDriver::mkfs()
{
assert(config.path);
- segment_manager = std::make_unique<
- segment_manager::block::BlockSegmentManager
- >(*config.path);
logger().debug("mkfs");
- seastore_meta_t meta;
- meta.seastore_id.generate_random();
- return segment_manager->mkfs(
- segment_manager_config_t{
- true,
- (magic_t)std::rand(),
- device_type_t::SEGMENTED,
- 0,
- meta,
- secondary_device_set_t()}
- ).safe_then([this] {
- logger().debug("");
- return segment_manager->mount();
+ return Device::make_device(*config.path
+ ).then([this](DeviceRef dev) {
+ device = std::move(dev);
+ seastore_meta_t meta;
+ meta.seastore_id.generate_random();
+ return device->mkfs(
+ device_config_t{
+ true,
+ (magic_t)std::rand(),
+ device_type_t::SEGMENTED,
+ 0,
+ meta,
+ secondary_device_set_t()});
+ }).safe_then([this] {
+ logger().debug("device mkfs done");
+ return device->mount();
}).safe_then([this] {
init();
logger().debug("tm mkfs");
return tm->close();
}).safe_then([this] {
logger().debug("sm close");
- return segment_manager->close();
+ return device->close();
}).safe_then([this] {
clear();
- segment_manager.reset();
+ device.reset();
logger().debug("mkfs complete");
return TransactionManager::mkfs_ertr::now();
}).handle_error(
{
return (config.mkfs ? mkfs() : seastar::now()
).then([this] {
- segment_manager = std::make_unique<
- segment_manager::block::BlockSegmentManager
- >(*config.path);
- return segment_manager->mount();
+ return Device::make_device(*config.path);
+ }).then([this](DeviceRef dev) {
+ device = std::move(dev);
+ return device->mount();
}).safe_then([this] {
init();
return tm->mount();
{
return tm->close().safe_then([this] {
clear();
- return segment_manager->close();
+ return device->close();
}).handle_error(
crimson::ct_error::assert_all{
"Invalid errror during TMDriver::close"
#include "crimson/os/seastore/cache.h"
#include "crimson/os/seastore/segment_cleaner.h"
-#include "crimson/os/seastore/segment_manager.h"
+#include "crimson/os/seastore/device.h"
#include "crimson/os/seastore/transaction_manager.h"
#include "test/crimson/seastore/test_block.h"
private:
const config_t config;
- using SegmentManagerRef = crimson::os::seastore::SegmentManagerRef;
- SegmentManagerRef segment_manager;
+ using DeviceRef = crimson::os::seastore::DeviceRef;
+ DeviceRef device;
using TransactionManager = crimson::os::seastore::TransactionManager;
using TransactionManagerRef = crimson::os::seastore::TransactionManagerRef;
virtual FuturizedStore::mkfs_ertr::future<> _mkfs() final {
return TMTestState::_mkfs(
).safe_then([this] {
- tm->add_segment_manager(segment_manager.get(), true);
+ tm->add_device(segment_manager.get(), true);
return tm->mount(
).safe_then([this] {
return repeat_eagain([this] {
virtual void _init() override {
tm = make_transaction_manager(*segment_manager, true);
- tm->add_segment_manager(segment_manager.get(), true);
+ tm->add_device(segment_manager.get(), true);
segment_cleaner = tm->get_segment_cleaner();
lba_manager = tm->get_lba_manager();
}
return mount_ertr::now(); // we handle this above
}
- mkfs_ret mkfs(segment_manager_config_t c) final {
+ mkfs_ret mkfs(device_config_t c) final {
return mkfs_ertr::now(); // we handle this above
}
return sm.get_secondary_devices();
}
- device_spec_t get_device_spec() const final {
- return sm.get_device_spec();
- }
-
magic_t get_magic() const final {
return sm.get_magic();
}
projects / ceph.git / commitdiff