}
};
-struct rbm_metadata_header_t {
+struct rbm_superblock_t {
size_t size = 0;
size_t block_size = 0;
uint64_t feature = 0;
unsigned int shard_num = 0;
std::vector<rbm_shard_info_t> shard_infos;
- DENC(rbm_metadata_header_t, v, p) {
+ DENC(rbm_superblock_t, v, p) {
DENC_START(1, 1, p);
denc(v.size, p);
denc(v.block_size, p);
seastar::future<std::unique_ptr<random_block_device::RBMDevice>>
get_rb_device(const std::string &device);
-std::ostream &operator<<(std::ostream &out, const rbm_metadata_header_t &header);
+std::ostream &operator<<(std::ostream &out, const rbm_superblock_t &header);
std::ostream &operator<<(std::ostream &out, const rbm_shard_info_t &shard);
}
crimson::os::seastore::rbm_shard_info_t
)
WRITE_CLASS_DENC_BOUNDED(
- crimson::os::seastore::rbm_metadata_header_t
+ crimson::os::seastore::rbm_superblock_t
)
#if FMT_VERSION >= 90000
-template<> struct fmt::formatter<crimson::os::seastore::rbm_metadata_header_t> : fmt::ostream_formatter {};
+template<> struct fmt::formatter<crimson::os::seastore::rbm_superblock_t> : fmt::ostream_formatter {};
template<> struct fmt::formatter<crimson::os::seastore::rbm_shard_info_t> : fmt::ostream_formatter {};
#endif
}
#endif
-std::ostream &operator<<(std::ostream &out, const rbm_metadata_header_t &header)
+std::ostream &operator<<(std::ostream &out, const rbm_superblock_t &header)
{
- out << " rbm_metadata_header_t(size=" << header.size
+ out << " rbm_superblock_t(size=" << header.size
<< ", block_size=" << header.block_size
<< ", feature=" << header.feature
<< ", journal_size=" << header.journal_size
* Ondisk layout (TODO)
*
* ---------------------------------------------------------------------------
- * | rbm_metadata_header_t | metadatas | ... | data blocks |
+ * | rbm_superblock_t | metadatas | ... | data blocks |
* ---------------------------------------------------------------------------
*/
crimson::ct_error::assert_all{
"Invalid error open in RBMDevice::do_primary_mkfs"}
).safe_then([this] {
- return write_rbm_header(
+ return write_rbm_superblock(
).safe_then([this] {
return close();
}).handle_error(
mkfs_ertr::pass_further{},
crimson::ct_error::assert_all{
- "Invalid error write_rbm_header in RBMDevice::do_primary_mkfs"
+ "Invalid error write_rbm_superblock in RBMDevice::do_primary_mkfs"
});
});
});
}
-write_ertr::future<> RBMDevice::write_rbm_header()
+write_ertr::future<> RBMDevice::write_rbm_superblock()
{
bufferlist meta_b_header;
super.crc = 0;
return write(RBM_START_ADDRESS, std::move(bp));
}
-read_ertr::future<rbm_metadata_header_t> RBMDevice::read_rbm_header(
+read_ertr::future<rbm_superblock_t> RBMDevice::read_rbm_superblock(
rbm_abs_addr addr)
{
- LOG_PREFIX(RBMDevice::read_rbm_header);
+ LOG_PREFIX(RBMDevice::read_rbm_superblock);
assert(super.block_size > 0);
return seastar::do_with(
bufferptr(ceph::buffer::create_page_aligned(super.block_size)),
addr,
bptr
).safe_then([length=bptr.length(), this, bptr, FNAME]()
- -> read_ertr::future<rbm_metadata_header_t> {
+ -> read_ertr::future<rbm_superblock_t> {
bufferlist bl;
bl.append(bptr);
auto p = bl.cbegin();
- rbm_metadata_header_t super_block;
+ rbm_superblock_t super_block;
try {
decode(super_block, p);
}
catch (ceph::buffer::error& e) {
- DEBUG("read_rbm_header: unable to decode rbm super block {}",
+ DEBUG("read_rbm_superblock: unable to decode rbm super block {}",
e.what());
return crimson::ct_error::enoent::make();
}
bufferlist meta_b_header;
super_block.crc = 0;
encode(super_block, meta_b_header);
- assert(ceph::encoded_sizeof<rbm_metadata_header_t>(super_block) <
+ assert(ceph::encoded_sizeof<rbm_superblock_t>(super_block) <
super_block.block_size);
// Do CRC verification only if data protection is not supported.
super_block.crc = crc;
super = super_block;
DEBUG("got {} ", super);
- return read_ertr::future<rbm_metadata_header_t>(
+ return read_ertr::future<rbm_superblock_t>(
read_ertr::ready_future_marker{},
super_block
);
).safe_then([this](auto st) {
assert(st.block_size > 0);
super.block_size = st.block_size;
- return read_rbm_header(RBM_START_ADDRESS
+ return read_rbm_superblock(RBM_START_ADDRESS
).safe_then([this](auto s) {
LOG_PREFIX(RBMDevice::do_shard_mount);
shard_info = s.shard_infos[seastar::this_shard_id()];
return read(rbm_addr, out);
}
protected:
- rbm_metadata_header_t super;
+ rbm_superblock_t super;
rbm_shard_info_t shard_info;
public:
RBMDevice() {}
mount_ret do_shard_mount();
- write_ertr::future<> write_rbm_header();
+ write_ertr::future<> write_rbm_superblock();
- read_ertr::future<rbm_metadata_header_t> read_rbm_header(rbm_abs_addr addr);
+ read_ertr::future<rbm_superblock_t> read_rbm_superblock(rbm_abs_addr addr);
using stat_device_ret =
read_ertr::future<seastar::stat_data>;
return device->mkfs(config).unsafe_get();
}
- auto read_rbm_header() {
- return device->read_rbm_header(RBM_START_ADDRESS).unsafe_get();
+ auto read_rbm_superblock() {
+ return device->read_rbm_superblock(RBM_START_ADDRESS).unsafe_get();
}
auto open() {
TEST_F(rbm_test_t, mkfs_test)
{
run_async([this] {
- auto super = read_rbm_header();
+ auto super = read_rbm_superblock();
ASSERT_TRUE(
super.block_size == block_size &&
super.size == size
);
config.spec.id = DEVICE_ID_NULL;
mkfs();
- super = read_rbm_header();
+ super = read_rbm_superblock();
ASSERT_TRUE(
super.config.spec.id == DEVICE_ID_NULL &&
super.size == size