allocators[type].emplace_back(std::move(allocator));
LOG_PREFIX(ExtentPlacementManager::add_allocator);
SUBDEBUG(seastore_tm, "allocators for {}: {}",
- device_type_to_string(type),
+ type,
allocators[type].size());
}
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>(
- root + "/block." + device_type_to_string(dtype)
- + "." + std::to_string(id));
+ segment_manager::block::BlockSegmentManager>(oss.str());
return sm->mount().safe_then([this, sm=std::move(sm), magic]() mutable {
assert(sm->get_magic() == magic);
transaction_manager->add_segment_manager(sm.get());
device_type_t dtype =
string_to_device_type(
entry_name.substr(6, dtype_end - 6));
- if (!dtype) {
+ if (dtype == device_type_t::NONE) {
// invalid device type
return seastar::now();
}
namespace crimson::os::seastore {
+std::ostream& operator<<(std::ostream& out, const seastore_meta_t& meta)
+{
+ return out << meta.seastore_id;
+}
+
std::ostream &segment_to_stream(std::ostream &out, const segment_id_t &t)
{
if (t == NULL_SEG_ID)
bool can_delay_allocation(device_type_t type) {
// Some types of device may not support delayed allocation, for example PMEM.
- return type <= RANDOM_BLOCK;
+ return type <= device_type_t::RANDOM_BLOCK;
}
device_type_t string_to_device_type(std::string type) {
return device_type_t::NONE;
}
-std::string device_type_to_string(device_type_t dtype) {
- switch (dtype) {
+std::ostream& operator<<(std::ostream& out, device_type_t t)
+{
+ switch (t) {
+ case device_type_t::NONE:
+ return out << "NONE";
case device_type_t::SEGMENTED:
- return "segmented";
+ return out << "SEGMENTED";
case device_type_t::RANDOM_BLOCK:
- return "random_block";
+ return out << "RANDOM_BLOCK";
case device_type_t::PMEM:
- return "pmem";
+ return out << "PMEM";
default:
- ceph_assert(0 == "impossible");
+ return out << "INVALID_DEVICE_TYPE!";
}
}
+
paddr_t convert_blk_paddr_to_paddr(blk_paddr_t addr, size_t block_size,
uint32_t blocks_per_segment, device_id_t d_id)
{
}
};
+std::ostream& operator<<(std::ostream& out, const seastore_meta_t& meta);
+
// identifies a specific physical device within seastore
using device_id_t = uint8_t;
NUM_HINTS // Constant for number of hints
};
-enum device_type_t {
+enum class device_type_t {
NONE = 0,
SEGMENTED, // i.e. Hard_Disk, SATA_SSD, NAND_NVME
RANDOM_BLOCK, // i.e. RANDOM_BD
NUM_TYPES
};
+std::ostream& operator<<(std::ostream& out, device_type_t t);
+
bool can_delay_allocation(device_type_t type);
device_type_t string_to_device_type(std::string type);
-std::string device_type_to_string(device_type_t type);
/* Monotonically increasing identifier for the location of a
* journal_record.
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("
+ << "size=" << sb.size
+ << ", segment_size=" << sb.segment_size
+ << ", block_size=" << sb.block_size
+ << ", segments=" << sb.segments
+ << ", tracker_offset=" << sb.tracker_offset
+ << ", first_segment_offset=" << sb.first_segment_offset
+ << ", major_dev=" << sb.major_dev
+ << ", magic=" << sb.magic
+ << ", device_type=" << sb.dtype
+ << ", device_id=" << std::to_string(sb.device_id)
+ << ", meta=" << sb.meta
+ << ", secondary(";
+ for (const auto& [k, v] : sb.secondary_devices) {
+ out << std::to_string(k) << ": " << v;
+ }
+ 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;
+ switch (s) {
+ case state_t::EMPTY:
+ return out << "EMPTY";
+ case state_t::OPEN:
+ return out << "OPEN";
+ case state_t::CLOSED:
+ return out << "CLOSED";
+ default:
+ return out << "INVALID_SEGMENT_STATE!";
+ }
+}
+
seastar::future<crimson::os::seastore::SegmentManagerRef>
SegmentManager::get_segment_manager(
const std::string &device)
}
};
+std::ostream& operator<<(std::ostream&, const device_spec_t&);
+
using secondary_device_set_t =
std::map<device_id_t, device_spec_t>;
}
};
+std::ostream& operator<<(std::ostream&, const block_sm_superblock_t&);
+
struct segment_manager_config_t {
bool major_dev = false;
magic_t magic = 0;
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>{
};
using SegmentRef = boost::intrusive_ptr<Segment>;
+std::ostream& operator<<(std::ostream& out, Segment::segment_state_t);
+
constexpr size_t PADDR_SIZE = sizeof(paddr_t);
class SegmentManager;
segment_manager_config_t sm_config,
const seastar::stat_data &data)
{
- LOG_PREFIX(block_make_superblock);
-
using crimson::common::get_conf;
auto config_size = get_conf<Option::size_t>(
size_t segments = (size - tracker_size - data.block_size)
/ config_segment_size;
- DEBUG(
- "size {}, block_size {}, allocated_size {}, configured_size {}, "
- "segment_size {}",
- data.size,
- data.block_size,
- data.allocated_size,
- config_size,
- config_segment_size
- );
-
return block_sm_superblock_t{
size,
config_segment_size,
BlockSegmentManager::access_ertr::future<>
write_superblock(seastar::file &device, block_sm_superblock_t sb)
{
- LOG_PREFIX(block_write_superblock);
assert(ceph::encoded_sizeof<block_sm_superblock_t>(sb) <
sb.block_size);
return seastar::do_with(
auto iter = bl.begin();
assert(bl.length() < sb.block_size);
iter.copy(bl.length(), bp.c_str());
- DEBUG("doing writeout");
return do_write(device, 0, bp);
});
}
auto sd = p.second;
return read_superblock(device, sd);
}).safe_then([=](auto sb) {
+ INFO("device {} path={} read {}", get_device_id(), device_path, sb);
superblock = sb;
stats.data_read.increment(
ceph::encoded_sizeof<block_sm_superblock_t>(superblock));
segment_manager_config_t sm_config)
{
LOG_PREFIX(BlockSegmentManager::mkfs);
- DEBUG("magic={}, dtype={}, id={}",
- sm_config.magic, sm_config.dtype, sm_config.device_id);
+ DEBUG("path={}, {}", device_path, sm_config);
return seastar::do_with(
seastar::file{},
seastar::stat_data{},
std::unique_ptr<SegmentStateTracker>(),
[=](auto &device, auto &stat, auto &sb, auto &tracker)
{
- ERROR("path {}", device_path);
check_create_device_ret maybe_create = check_create_device_ertr::now();
using crimson::common::get_conf;
if (get_conf<bool>("seastore_block_create")) {
return maybe_create.safe_then([this] {
return open_device(device_path);
- }).safe_then([&, sm_config](auto p) {
+ }).safe_then([&, sm_config, FNAME](auto p) {
device = p.first;
stat = p.second;
sb = make_superblock(sm_config, stat);
stats.metadata_write.increment(
ceph::encoded_sizeof<block_sm_superblock_t>(sb));
+ INFO("device {} path={}, writing {}", get_device_id(), device_path, sb);
return write_superblock(device, sb);
}).safe_then([&, FNAME] {
DEBUG("superblock written");
}
if (tracker->get(s_id) != segment_state_t::EMPTY) {
- ERROR("invalid segment {} state {}", id, tracker->get(s_id));
+ ERROR("invalid segment {} state {} != EMPTY", id, tracker->get(s_id));
return crimson::ct_error::invarg::make();
}
}
if (tracker->get(s_id) != segment_state_t::CLOSED) {
- ERROR("invalid segment {} state {}", id, tracker->get(s_id));
+ ERROR("invalid segment {} state {} != CLOSED", id, tracker->get(s_id));
return crimson::ct_error::invarg::make();
}
projects / ceph.git / commitdiff