Segment offset has range from 32-bit signed integer.
Signed-off-by: Yingxin Cheng <yingxin.cheng@intel.com>
void segment_info_t::init_closed(
segment_seq_t _seq, segment_type_t _type,
data_category_t _category, reclaim_gen_t _generation,
- std::size_t seg_size)
+ segment_off_t seg_size)
{
ceph_assert(_seq != NULL_SEG_SEQ);
ceph_assert(_type != segment_type_t::NULL_SEG);
ceph_assert(ssize > 0);
segment_size = ssize;
} else {
- ceph_assert(segment_size == (std::size_t)ssize);
+ ceph_assert(segment_size == ssize);
}
// NOTE: by default the segments are empty
}
ceph_assert(get_segment_size() >= segment_info.written_to);
auto seg_avail_bytes = get_segment_size() - segment_info.written_to;
- ceph_assert(avail_bytes_in_open >= seg_avail_bytes);
+ ceph_assert(avail_bytes_in_open >= (std::size_t)seg_avail_bytes);
avail_bytes_in_open -= seg_avail_bytes;
if (segment_info.modify_time != NULL_TIME) {
ceph_abort();
}
- auto new_written_to = static_cast<std::size_t>(saddr.get_segment_off());
+ auto new_written_to = saddr.get_segment_off();
ceph_assert(new_written_to <= get_segment_size());
if (segment_info.written_to > new_written_to) {
ERROR("written_to should not decrease! type={}, offset={}, {}",
DEBUG("type={}, offset={}, {}", type, offset, segment_info);
ceph_assert(type == segment_info.type);
auto avail_deduction = new_written_to - segment_info.written_to;
- ceph_assert(avail_bytes_in_open >= avail_deduction);
+ ceph_assert(avail_bytes_in_open >= (std::size_t)avail_deduction);
avail_bytes_in_open -= avail_deduction;
segment_info.written_to = new_written_to;
}
int64_t SpaceTrackerDetailed::SegmentMap::allocate(
device_segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len,
const extent_len_t block_size)
{
int64_t SpaceTrackerDetailed::SegmentMap::release(
device_segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len,
const extent_len_t block_size)
{
std::size_t num_extents = 0;
- std::size_t written_to = 0;
+ segment_off_t written_to = 0;
bool is_in_journal(journal_seq_t tail_committed) const {
return type == segment_type_t::JOURNAL &&
void init_closed(segment_seq_t, segment_type_t,
data_category_t, reclaim_gen_t,
- std::size_t);
+ segment_off_t);
void set_open(segment_seq_t, segment_type_t,
data_category_t, reclaim_gen_t);
assert(segments.size() > 0);
return segments.size();
}
- std::size_t get_segment_size() const {
+ segment_off_t get_segment_size() const {
assert(segment_size > 0);
return segment_size;
}
// See reset() for member initialization
segment_map_t<segment_info_t> segments;
- std::size_t segment_size;
+ segment_off_t segment_size;
segment_id_t journal_segment_id;
std::size_t num_in_journal_open;
public:
virtual int64_t allocate(
segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len) = 0;
virtual int64_t release(
segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len) = 0;
virtual int64_t get_usage(
class SpaceTrackerSimple : public SpaceTrackerI {
struct segment_bytes_t {
int64_t live_bytes = 0;
- seastore_off_t total_bytes = 0;
+ segment_off_t total_bytes = 0;
};
// Tracks live space for each segment
segment_map_t<segment_bytes_t> live_bytes_by_segment;
int64_t allocate(
segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len) final {
return update_usage(segment, len);
}
int64_t release(
segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len) final {
return update_usage(segment, -(int64_t)len);
}
class SpaceTrackerDetailed : public SpaceTrackerI {
class SegmentMap {
int64_t used = 0;
- seastore_off_t total_bytes = 0;
+ segment_off_t total_bytes = 0;
std::vector<bool> bitmap;
public:
SegmentMap(
size_t blocks,
- seastore_off_t total_bytes)
+ segment_off_t total_bytes)
: total_bytes(total_bytes),
bitmap(blocks, false) {}
int64_t allocate(
device_segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len,
const extent_len_t block_size);
int64_t release(
device_segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len,
const extent_len_t block_size);
int64_t allocate(
segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len) final {
return segment_usage[segment].allocate(
segment.device_segment_id(),
int64_t release(
segment_id_t segment,
- seastore_off_t offset,
+ segment_off_t offset,
extent_len_t len) final {
return segment_usage[segment].release(
segment.device_segment_id(),
struct reclaim_state_t {
reclaim_gen_t generation;
reclaim_gen_t target_generation;
- std::size_t segment_size;
+ segment_off_t segment_size;
paddr_t start_pos;
paddr_t end_pos;
static reclaim_state_t create(
segment_id_t segment_id,
reclaim_gen_t generation,
- std::size_t segment_size) {
+ segment_off_t segment_size) {
ceph_assert(generation < RECLAIM_GENERATIONS);
return {generation,
(reclaim_gen_t)(generation == RECLAIM_GENERATIONS - 1 ?
}
bool is_complete() const {
- return (std::size_t)end_pos.as_seg_paddr().get_segment_off() >= segment_size;
+ return end_pos.as_seg_paddr().get_segment_off() >= segment_size;
}
void advance(std::size_t bytes) {
start_pos = end_pos;
auto &end_seg_paddr = end_pos.as_seg_paddr();
auto next_off = end_seg_paddr.get_segment_off() + bytes;
- if (next_off > segment_size) {
+ if (next_off > (std::size_t)segment_size) {
end_seg_paddr.set_segment_off(segment_size);
} else {
end_seg_paddr.set_segment_off(next_off);
return current_segment_nonce;
}
- seastore_off_t get_written_to() const {
+ segment_off_t get_written_to() const {
assert(can_write());
return written_to;
}
SegmentProvider &segment_provider;
SegmentManagerGroup &sm_group;
SegmentRef current_segment;
- seastore_off_t written_to;
+ segment_off_t written_to;
SegmentSeqAllocator &segment_seq_allocator;
segment_nonce_t current_segment_nonce;
JournalTrimmer *trimmer;
auto &s = rhs.as_seg_paddr();
out << s.get_segment_id()
<< ","
- << seastore_off_printer_t{s.get_segment_off()};
+ << s.get_segment_off();
} else if (rhs.get_addr_type() == paddr_types_t::RANDOM_BLOCK) {
auto &s = rhs.as_blk_paddr();
out << device_id_printer_t{s.get_device_id()}
constexpr auto BLOCK_OFF_MAX =
std::numeric_limits<block_off_t>::max() >> DEVICE_ID_BITS;
+/**
+ * segment_off_t
+ *
+ * Offset within a segment on disk, may be negative for relative offsets.
+ *
+ * TODO: replace seastore_off_t
+ */
+using segment_off_t = int32_t;
+using u_segment_off_t = uint32_t;
+
constexpr auto DEVICE_ID_MASK =
((internal_paddr_t(1) << DEVICE_ID_BITS) - 1) << BLOCK_OFF_BITS;
constexpr auto BLOCK_OFF_MASK =
static paddr_t make_seg_paddr(
segment_id_t seg,
- seastore_off_t offset) {
+ segment_off_t offset) {
return paddr_t(seg, offset);
}
static paddr_t make_seg_paddr(
device_id_t device,
device_segment_id_t seg,
- seastore_off_t offset) {
+ segment_off_t offset) {
return paddr_t(segment_id_t(device, seg), offset);
}
private:
// as seg
- paddr_t(segment_id_t seg, seastore_off_t offset)
+ paddr_t(segment_id_t seg, segment_off_t offset)
: paddr_t((static_cast<internal_paddr_t>(seg.segment) << SEGMENT_OFF_BITS) |
- static_cast<u_seastore_off_t>(offset)) {}
+ static_cast<u_segment_off_t>(offset)) {}
// as blk
paddr_t(device_id_t d_id, block_off_t offset)
internal_paddr >> SEGMENT_OFF_BITS));
}
- seastore_off_t get_segment_off() const {
- return seastore_off_t(internal_paddr & SEGMENT_OFF_MASK);
+ segment_off_t get_segment_off() const {
+ return segment_off_t(internal_paddr & SEGMENT_OFF_MASK);
}
- void set_segment_off(seastore_off_t off) {
+ void set_segment_off(segment_off_t off) {
assert(off >= 0);
internal_paddr = (internal_paddr & SEGMENT_ID_MASK);
- internal_paddr |= static_cast<u_seastore_off_t>(off);
+ internal_paddr |= static_cast<u_segment_off_t>(off);
}
paddr_t add_offset(seastore_off_t o) const {
- auto off = get_segment_off() + o;
- assert(o >= 0 ? off >= get_segment_off() : off < get_segment_off());
- return paddr_t::make_seg_paddr(get_segment_id(), off);
+ device_off_t off = get_segment_off() + o;
+ assert(off >= 0);
+ assert(off <= MAX_SEG_OFF);
+ return paddr_t::make_seg_paddr(
+ get_segment_id(), static_cast<segment_off_t>(off));
}
};
return seq.offset.as_seg_paddr().get_segment_id();
}
- seastore_off_t get_segment_offset() const {
+ segment_off_t get_segment_offset() const {
return seq.offset.as_seg_paddr().get_segment_off();
}
- void increment_seq(seastore_off_t off) {
+ void increment_seq(segment_off_t off) {
auto& seg_addr = seq.offset.as_seg_paddr();
seg_addr.set_segment_off(
seg_addr.get_segment_off() + off);
/**
* min next write location
*/
- virtual seastore_off_t get_write_ptr() const = 0;
+ virtual segment_off_t get_write_ptr() const = 0;
/**
* max capacity
*/
- virtual seastore_off_t get_write_capacity() const = 0;
+ virtual segment_off_t get_write_capacity() const = 0;
/**
* close
crimson::ct_error::enospc // write exceeds segment size
>;
virtual write_ertr::future<> write(
- seastore_off_t offset, ceph::bufferlist bl) = 0;
+ segment_off_t offset, ceph::bufferlist bl) = 0;
/**
* advance_wp
* @param offset: advance write pointer till the given offset
*/
virtual write_ertr::future<> advance_wp(
- seastore_off_t offset) = 0;
+ segment_off_t offset) = 0;
virtual ~Segment() {}
};
virtual release_ertr::future<> release(segment_id_t id) = 0;
/* Methods for discovering device geometry, segmentid set, etc */
- virtual seastore_off_t get_segment_size() const = 0;
+ virtual segment_off_t get_segment_size() const = 0;
virtual device_segment_id_t get_num_segments() const {
ceph_assert(get_available_size() % get_segment_size() == 0);
return ((device_segment_id_t)(get_available_size() / get_segment_size()));
BlockSegmentManager &manager, segment_id_t id)
: manager(manager), id(id) {}
-seastore_off_t BlockSegment::get_write_capacity() const
+segment_off_t BlockSegment::get_write_capacity() const
{
return manager.get_segment_size();
}
}
Segment::write_ertr::future<> BlockSegment::write(
- seastore_off_t offset, ceph::bufferlist bl)
+ segment_off_t offset, ceph::bufferlist bl)
{
LOG_PREFIX(BlockSegment::write);
auto paddr = paddr_t::make_seg_paddr(id, offset);
}
Segment::write_ertr::future<> BlockSegment::advance_wp(
- seastore_off_t offset) {
+ segment_off_t offset) {
return write_ertr::now();
}
Segment::close_ertr::future<> BlockSegmentManager::segment_close(
- segment_id_t id, seastore_off_t write_pointer)
+ segment_id_t id, segment_off_t write_pointer)
{
LOG_PREFIX(BlockSegmentManager::segment_close);
auto s_id = id.device_segment_id();
friend class BlockSegmentManager;
BlockSegmentManager &manager;
const segment_id_t id;
- seastore_off_t write_pointer = 0;
+ segment_off_t write_pointer = 0;
public:
BlockSegment(BlockSegmentManager &manager, segment_id_t id);
segment_id_t get_segment_id() const final { return id; }
- seastore_off_t get_write_capacity() const final;
- seastore_off_t get_write_ptr() const final { return write_pointer; }
+ segment_off_t get_write_capacity() const final;
+ segment_off_t get_write_ptr() const final { return write_pointer; }
close_ertr::future<> close() final;
- write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
- write_ertr::future<> advance_wp(seastore_off_t offset) final;
+ write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+ write_ertr::future<> advance_wp(segment_off_t offset) final;
~BlockSegment() {}
};
extent_len_t get_block_size() const {
return superblock.block_size;
}
- seastore_off_t get_segment_size() const {
+ segment_off_t get_segment_size() const {
return superblock.segment_size;
}
char *buffer = nullptr;
Segment::close_ertr::future<> segment_close(
- segment_id_t id, seastore_off_t write_pointer);
+ segment_id_t id, segment_off_t write_pointer);
};
}
EphemeralSegmentManager &manager, segment_id_t id)
: manager(manager), id(id) {}
-seastore_off_t EphemeralSegment::get_write_capacity() const
+segment_off_t EphemeralSegment::get_write_capacity() const
{
return manager.get_segment_size();
}
}
Segment::write_ertr::future<> EphemeralSegment::write(
- seastore_off_t offset, ceph::bufferlist bl)
+ segment_off_t offset, ceph::bufferlist bl)
{
if (offset < write_pointer || offset % manager.config.block_size != 0)
return crimson::ct_error::invarg::make();
}
Segment::write_ertr::future<> EphemeralSegment::advance_wp(
- seastore_off_t offset)
+ segment_off_t offset)
{
return write_ertr::now();
}
friend class EphemeralSegmentManager;
EphemeralSegmentManager &manager;
const segment_id_t id;
- seastore_off_t write_pointer = 0;
+ segment_off_t write_pointer = 0;
public:
EphemeralSegment(EphemeralSegmentManager &manager, segment_id_t id);
segment_id_t get_segment_id() const final { return id; }
- seastore_off_t get_write_capacity() const final;
- seastore_off_t get_write_ptr() const final { return write_pointer; }
+ segment_off_t get_write_capacity() const final;
+ segment_off_t get_write_ptr() const final { return write_pointer; }
close_ertr::future<> close() final;
- write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
- write_ertr::future<> advance_wp(seastore_off_t offset) final;
+ write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+ write_ertr::future<> advance_wp(segment_off_t offset) final;
~EphemeralSegment() {}
};
extent_len_t get_block_size() const final {
return config.block_size;
}
- seastore_off_t get_segment_size() const final {
+ segment_off_t get_segment_size() const final {
return config.segment_size;
}
}
Segment::close_ertr::future<> ZNSSegmentManager::segment_close(
- segment_id_t id, seastore_off_t write_pointer)
+ segment_id_t id, segment_off_t write_pointer)
{
LOG_PREFIX(ZNSSegmentManager::segment_close);
return seastar::do_with(
return metadata.magic;
};
-seastore_off_t ZNSSegment::get_write_capacity() const
+segment_off_t ZNSSegment::get_write_capacity() const
{
return manager.get_segment_size();
}
}
Segment::write_ertr::future<> ZNSSegment::write(
- seastore_off_t offset, ceph::bufferlist bl)
+ segment_off_t offset, ceph::bufferlist bl)
{
LOG_PREFIX(ZNSSegment::write);
if (offset != write_pointer || offset % manager.metadata.block_size != 0) {
// Advance write pointer, to given offset.
Segment::write_ertr::future<> ZNSSegment::advance_wp(
- seastore_off_t offset)
+ segment_off_t offset)
{
LOG_PREFIX(ZNSSegment::advance_wp);
ZNSSegment(ZNSSegmentManager &man, segment_id_t i) : manager(man), id(i){};
segment_id_t get_segment_id() const final { return id; }
- seastore_off_t get_write_capacity() const final;
- seastore_off_t get_write_ptr() const final { return write_pointer; }
+ segment_off_t get_write_capacity() const final;
+ segment_off_t get_write_ptr() const final { return write_pointer; }
close_ertr::future<> close() final;
- write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
- write_ertr::future<> advance_wp(seastore_off_t offset) final;
+ write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+ write_ertr::future<> advance_wp(segment_off_t offset) final;
~ZNSSegment() {}
private:
friend class ZNSSegmentManager;
ZNSSegmentManager &manager;
const segment_id_t id;
- seastore_off_t write_pointer = 0;
+ segment_off_t write_pointer = 0;
write_ertr::future<> write_padding_bytes(size_t padding_bytes);
};
return metadata.block_size;
};
- seastore_off_t get_segment_size() const final {
+ segment_off_t get_segment_size() const final {
return metadata.segment_capacity;
};
seastar::metrics::metric_group metrics;
Segment::close_ertr::future<> segment_close(
- segment_id_t id, seastore_off_t write_pointer);
+ segment_id_t id, segment_off_t write_pointer);
uint64_t get_offset(paddr_t addr) {
auto& seg_addr = addr.as_seg_paddr();
return segment_managers[*device_ids.begin()]->get_block_size();
}
- seastore_off_t get_segment_size() const {
+ segment_off_t get_segment_size() const {
assert(device_ids.size());
return segment_managers[*device_ids.begin()]->get_segment_size();
}
bl.append(block.bl);
}
- ceph_assert((seastore_off_t)bl.length() <
+ ceph_assert((segment_off_t)bl.length() <
segment_manager->get_segment_size());
- if (current.as_seg_paddr().get_segment_off() + (seastore_off_t)bl.length() >
+ if (current.as_seg_paddr().get_segment_off() + (segment_off_t)bl.length() >
segment_manager->get_segment_size())
current = paddr_t::make_seg_paddr(
segment_id_t(
size_t get_available_size() const final { return sm.get_available_size(); }
extent_len_t get_block_size() const final { return sm.get_block_size(); }
- seastore_off_t get_segment_size() const final {
+ segment_off_t get_segment_size() const final {
return sm.get_segment_size();
}
const seastore_meta_t &get_meta() const final {