CachedExtentRef Cache::alloc_new_extent_by_type(
Transaction &t, ///< [in, out] current transaction
extent_types_t type, ///< [in] type tag
- segment_off_t length, ///< [in] length
+ seastore_off_t length, ///< [in] length
bool delay ///< [in] whether to delay paddr alloc
)
{
: L_ADDR_NULL),
i->last_committed_crc,
final_crc,
- (segment_off_t)i->get_length(),
+ (seastore_off_t)i->get_length(),
i->get_version() - 1,
i->get_delta()
});
extent_types_t type,
paddr_t offset,
laddr_t laddr,
- segment_off_t length,
+ seastore_off_t length,
const Transaction::src_t* p_src,
extent_init_func_t &&extent_init_func)
{
template <typename T, typename Func>
get_extent_ret<T> get_extent(
paddr_t offset, ///< [in] starting addr
- segment_off_t length, ///< [in] length
+ seastore_off_t length, ///< [in] length
const src_ext_t* p_metric_key, ///< [in] cache query metric key
Func &&extent_init_func ///< [in] init func for extent
) {
template <typename T>
get_extent_ret<T> get_extent(
paddr_t offset, ///< [in] starting addr
- segment_off_t length, ///< [in] length
+ seastore_off_t length, ///< [in] length
const src_ext_t* p_metric_key ///< [in] cache query metric key
) {
return get_extent<T>(
get_extent_iertr::future<TCachedExtentRef<T>> get_extent(
Transaction &t,
paddr_t offset,
- segment_off_t length,
+ seastore_off_t length,
Func &&extent_init_func) {
CachedExtentRef ret;
LOG_PREFIX(Cache::get_extent);
get_extent_iertr::future<TCachedExtentRef<T>> get_extent(
Transaction &t,
paddr_t offset,
- segment_off_t length) {
+ seastore_off_t length) {
return get_extent<T>(t, offset, length, [](T &){});
}
extent_types_t type,
paddr_t offset,
laddr_t laddr,
- segment_off_t length,
+ seastore_off_t length,
const Transaction::src_t* p_src,
extent_init_func_t &&extent_init_func
);
extent_types_t type,
paddr_t offset,
laddr_t laddr,
- segment_off_t length,
+ seastore_off_t length,
extent_init_func_t &&extent_init_func) {
CachedExtentRef ret;
auto status = t.get_extent(offset, &ret);
extent_types_t type, ///< [in] type tag
paddr_t offset, ///< [in] starting addr
laddr_t laddr, ///< [in] logical address if logical
- segment_off_t length, ///< [in] length
+ seastore_off_t length, ///< [in] length
Func &&extent_init_func ///< [in] extent init func
) {
return _get_extent_by_type(
extent_types_t type,
paddr_t offset,
laddr_t laddr,
- segment_off_t length
+ seastore_off_t length
) {
return get_extent_by_type(
t, type, offset, laddr, length, [](CachedExtent &) {});
template <typename T>
TCachedExtentRef<T> alloc_new_extent(
Transaction &t, ///< [in, out] current transaction
- segment_off_t length, ///< [in] length
+ seastore_off_t length, ///< [in] length
bool delayed = false ///< [in] whether the paddr allocation of extent is delayed
) {
auto ret = CachedExtent::make_cached_extent_ref<T>(
CachedExtentRef alloc_new_extent_by_type(
Transaction &t, ///< [in, out] current transaction
extent_types_t type, ///< [in] type tag
- segment_off_t length, ///< [in] length
+ seastore_off_t length, ///< [in] length
bool delayed = false ///< [in] whether delay addr allocation
);
friend class Cache;
CachedExtent::index extent_index;
public:
- auto get_overlap(paddr_t addr, segment_off_t len) {
+ auto get_overlap(paddr_t addr, seastore_off_t len) {
auto bottom = extent_index.upper_bound(addr, paddr_cmp());
if (bottom != extent_index.begin())
--bottom;
namespace crimson::os::seastore::collection_manager {
-constexpr static segment_off_t MIN_FLAT_BLOCK_SIZE = 4<<10;
-[[maybe_unused]] constexpr static segment_off_t MAX_FLAT_BLOCK_SIZE = 4<<20;
+constexpr static seastore_off_t MIN_FLAT_BLOCK_SIZE = 4<<10;
+[[maybe_unused]] constexpr static seastore_off_t MAX_FLAT_BLOCK_SIZE = 4<<20;
FlatCollectionManager::FlatCollectionManager(
TransactionManager &tm)
return write_func();
}
-bool SegmentedAllocator::Writer::_needs_roll(segment_off_t length) const {
+bool SegmentedAllocator::Writer::_needs_roll(seastore_off_t length) const {
return allocated_to + length > current_segment->segment->get_write_capacity();
}
assert(extents.size() == record.extents.size());
assert(!record.deltas.size());
auto record_group = record_group_t(std::move(record), block_size);
- segment_off_t extent_offset = base + record_group.size.get_mdlength();
+ seastore_off_t extent_offset = base + record_group.size.get_mdlength();
for (auto& extent : extents) {
extent.set_ool_paddr(
paddr_t::make_seg_paddr(segment, extent_offset));
extent_offset += extent.get_bptr().length();
}
assert(extent_offset ==
- (segment_off_t)(base + record_group.size.get_encoded_length()));
+ (seastore_off_t)(base + record_group.size.get_encoded_length()));
return encode_records(record_group, journal_seq_t(), nonce);
}
void add_extent(LogicalCachedExtentRef& extent) {
std::vector<OolExtent>& get_extents() {
return extents;
}
- void set_base(segment_off_t b) {
+ void set_base(seastore_off_t b) {
base = b;
}
- segment_off_t get_base() const {
+ seastore_off_t get_base() const {
return base;
}
void clear() {
std::vector<OolExtent> extents;
record_t record;
size_t block_size;
- segment_off_t base = MAX_SEG_OFF;
+ seastore_off_t base = MAX_SEG_OFF;
};
/**
finish_record_ret finish_write(
Transaction& t,
ool_record_t& record);
- bool _needs_roll(segment_off_t length) const;
+ bool _needs_roll(seastore_off_t length) const;
write_iertr::future<> _write(
Transaction& t,
SegmentManager& segment_manager;
open_segment_wrapper_ref current_segment;
std::list<open_segment_wrapper_ref> open_segments;
- segment_off_t allocated_to = 0;
+ seastore_off_t allocated_to = 0;
LBAManager& lba_manager;
Journal& journal;
crimson::condition_variable segment_rotation_guard;
CachedExtentRef alloc_new_extent_by_type(
Transaction& t,
extent_types_t type,
- segment_off_t length,
+ seastore_off_t length,
placement_hint_t hint) {
// only logical extents should fall in this path
assert(is_logical_type(type));
std::enable_if_t<std::is_base_of_v<LogicalCachedExtent, T>, int> = 0>
TCachedExtentRef<T> alloc_new_extent(
Transaction& t,
- segment_off_t length,
+ seastore_off_t length,
placement_hint_t hint) {
// only logical extents should fall in this path
static_assert(is_logical_type(T::TYPE));
auto rest_start = paddr_t::make_seg_paddr(
seg_addr.get_segment_id(),
- seg_addr.get_segment_off() + (segment_off_t)block_size
+ seg_addr.get_segment_off() + (seastore_off_t)block_size
);
auto rest_len = header.mdlength - block_size;
TRACE("reading record group header rest {}~{}", rest_start, rest_len);
cursor.seq.segment_seq,
next.offset
},
- static_cast<segment_off_t>(total_length)
+ static_cast<seastore_off_t>(total_length)
}
};
DEBUG("processing {} at {}, budget_used={}",
#include "crimson/common/errorator.h"
#include "crimson/os/seastore/seastore_types.h"
#include "crimson/os/seastore/segment_manager.h"
+#include "crimson/os/seastore/logging.h"
namespace crimson::os::seastore {
class ExtentReader {
public:
- segment_off_t get_block_size() const {
+ seastore_off_t get_block_size() const {
assert(segment_managers.size());
// assume all segment managers have the same block size
return segment_managers[0]->get_block_size();
written_to += write_length;
auto write_result = write_result_t{
write_start_seq,
- static_cast<segment_off_t>(write_length)
+ static_cast<seastore_off_t>(write_length)
};
return current_journal_segment->write(
write_start_offset, to_write
return segment_manager.get_device_id();
}
- segment_off_t get_block_size() const {
+ seastore_off_t get_block_size() const {
return segment_manager.get_block_size();
}
segment_nonce_t current_segment_nonce;
SegmentRef current_journal_segment;
- segment_off_t written_to;
+ seastore_off_t written_to;
// committed_to may be in a previous journal segment
journal_seq_t committed_to;
};
record_group_t pending;
std::size_t submitting_size = 0;
- segment_off_t submitting_length = 0;
- segment_off_t submitting_mdlength = 0;
+ seastore_off_t submitting_length = 0;
+ seastore_off_t submitting_mdlength = 0;
struct promise_result_t {
write_result_t write_result;
- segment_off_t mdlength;
+ seastore_off_t mdlength;
};
using maybe_promise_result_t = std::optional<promise_result_t>;
std::optional<seastar::shared_promise<maybe_promise_result_t> > io_promise;
extent_types_t type,
paddr_t addr,
laddr_t laddr,
- segment_off_t len) = 0;
+ seastore_off_t len) = 0;
virtual void add_pin(LBAPin &pin) = 0;
extent_types_t type,
paddr_t addr,
laddr_t laddr,
- segment_off_t len)
+ seastore_off_t len)
{
ceph_assert(is_lba_node(type));
auto c = get_context(t);
extent_types_t type,
paddr_t addr,
laddr_t laddr,
- segment_off_t len) final;
+ seastore_off_t len) final;
void add_pin(LBAPin &pin) final {
auto *bpin = reinterpret_cast<BtreeLBAPin*>(&pin);
op_context_t c,
paddr_t addr,
laddr_t laddr,
- segment_off_t len)
+ seastore_off_t len)
{
LOG_PREFIX(BtreeLBAManager::get_leaf_if_live);
return lower_bound(
op_context_t c,
paddr_t addr,
laddr_t laddr,
- segment_off_t len)
+ seastore_off_t len)
{
LOG_PREFIX(BtreeLBAManager::get_leaf_if_live);
return lower_bound(
op_context_t c,
paddr_t addr,
laddr_t laddr,
- segment_off_t len);
+ seastore_off_t len);
/// get_internal_if_live: get internal node at laddr/addr if still live
using get_internal_if_live_iertr = base_iertr;
op_context_t c,
paddr_t addr,
laddr_t laddr,
- segment_off_t len);
+ seastore_off_t len);
/**
* rewrite_lba_extent
* mutation which changes the journal trim bound.
*/
struct RootBlock : CachedExtent {
- constexpr static segment_off_t SIZE = 4<<10;
+ constexpr static seastore_off_t SIZE = 4<<10;
using Ref = TCachedExtentRef<RootBlock>;
root_t root;
return out << t;
}
-std::ostream &offset_to_stream(std::ostream &out, const segment_off_t &t)
+std::ostream &offset_to_stream(std::ostream &out, const seastore_off_t &t)
{
if (t == NULL_SEG_OFF)
return out << "NULL_OFF";
d_id,
(device_segment_id_t)(addr / (block_size * blocks_per_segment))
};
- segment_off_t off = addr % (block_size * blocks_per_segment);
+ seastore_off_t off = addr % (block_size * blocks_per_segment);
return paddr_t::make_seg_paddr(id, off);
}
// Offset within a segment on disk, see SegmentManager
// may be negative for relative offsets
-using segment_off_t = int32_t;
-constexpr segment_off_t NULL_SEG_OFF =
- std::numeric_limits<segment_off_t>::max();
-constexpr segment_off_t MAX_SEG_OFF =
- std::numeric_limits<segment_off_t>::max();
+using seastore_off_t = int32_t;
+constexpr seastore_off_t NULL_SEG_OFF =
+ std::numeric_limits<seastore_off_t>::max();
+constexpr seastore_off_t MAX_SEG_OFF =
+ std::numeric_limits<seastore_off_t>::max();
-std::ostream &offset_to_stream(std::ostream &, const segment_off_t &t);
+std::ostream &offset_to_stream(std::ostream &, const seastore_off_t &t);
/* Monotonically increasing segment seq, uniquely identifies
* the incarnation of a segment */
using common_addr_t = uint64_t;
common_addr_t dev_addr;
private:
- constexpr paddr_t(segment_id_t seg, segment_off_t offset)
+ constexpr paddr_t(segment_id_t seg, seastore_off_t offset)
: dev_addr((static_cast<common_addr_t>(seg.segment)
<< SEG_OFF_LEN_BITS) | static_cast<uint32_t>(offset)) {}
constexpr paddr_t(common_addr_t val) : dev_addr(val) {}
public:
static constexpr paddr_t make_seg_paddr(
- segment_id_t seg, segment_off_t offset) {
+ segment_id_t seg, seastore_off_t offset) {
return paddr_t(seg, offset);
}
static constexpr paddr_t make_seg_paddr(
device_id_t device,
device_segment_id_t seg,
- segment_off_t offset) {
+ seastore_off_t offset) {
return paddr_t(segment_id_t(device, seg), offset);
}
constexpr paddr_t() : paddr_t(NULL_SEG_ID, 0) {}
segment_id_t get_segment_id() const {
return segment_id_t((dev_addr & SEG_ID_MASK) >> SEG_OFF_LEN_BITS);
}
- segment_off_t get_segment_off() const {
- return segment_off_t(dev_addr & SEG_OFF_MASK);
+ seastore_off_t get_segment_off() const {
+ return seastore_off_t(dev_addr & SEG_OFF_MASK);
}
void set_segment_id(const segment_id_t id) {
dev_addr &= static_cast<common_addr_t>(
std::numeric_limits<device_segment_id_t>::max());
dev_addr |= static_cast<common_addr_t>(id.segment) << SEG_OFF_LEN_BITS;
}
- void set_segment_off(const segment_off_t off) {
+ void set_segment_off(const seastore_off_t off) {
dev_addr &= static_cast<common_addr_t>(
std::numeric_limits<device_segment_id_t>::max()) << SEG_OFF_LEN_BITS;
dev_addr |= (uint32_t)off;
}
- paddr_t add_offset(segment_off_t o) const {
+ paddr_t add_offset(seastore_off_t o) const {
return paddr_t::make_seg_paddr(get_segment_id(), get_segment_off() + o);
}
constexpr paddr_t P_ADDR_MIN = paddr_t::make_seg_paddr(segment_id_t(0, 0), 0);
constexpr paddr_t P_ADDR_MAX = paddr_t::make_seg_paddr(
segment_id_t(DEVICE_ID_MAX, DEVICE_SEGMENT_ID_MAX),
- std::numeric_limits<segment_off_t>::max());
+ std::numeric_limits<seastore_off_t>::max());
constexpr paddr_t P_ADDR_ZERO = paddr_t::make_seg_paddr(
DEVICE_ID_ZERO, 0, 0);
-constexpr paddr_t make_record_relative_paddr(segment_off_t off) {
+constexpr paddr_t make_record_relative_paddr(seastore_off_t off) {
return paddr_t::make_seg_paddr(
segment_id_t{DEVICE_ID_RECORD_RELATIVE, 0},
off);
}
-constexpr paddr_t make_block_relative_paddr(segment_off_t off) {
+constexpr paddr_t make_block_relative_paddr(seastore_off_t off) {
return paddr_t::make_seg_paddr(
segment_id_t{DEVICE_ID_BLOCK_RELATIVE, 0},
off);
}
-constexpr paddr_t make_fake_paddr(segment_off_t off) {
+constexpr paddr_t make_fake_paddr(seastore_off_t off) {
return paddr_t::make_seg_paddr(FAKE_SEG_ID, off);
}
-constexpr paddr_t delayed_temp_paddr(segment_off_t off) {
+constexpr paddr_t delayed_temp_paddr(seastore_off_t off) {
return paddr_t::make_seg_paddr(
segment_id_t{DEVICE_ID_DELAYED, 0},
off);
segment_seq_t segment_seq = 0;
paddr_t offset;
- journal_seq_t add_offset(segment_off_t o) const {
+ journal_seq_t add_offset(seastore_off_t o) const {
return {segment_seq, offset.add_offset(o)};
}
laddr_t laddr = L_ADDR_NULL; ///< logical address
uint32_t prev_crc = 0;
uint32_t final_crc = 0;
- segment_off_t length = NULL_SEG_OFF; ///< extent length
+ seastore_off_t length = NULL_SEG_OFF; ///< extent length
extent_version_t pversion; ///< prior version
ceph::bufferlist bl; ///< payload
public:
coll_root_le_t() = default;
- coll_root_le_t(laddr_t laddr, segment_off_t size)
+ coll_root_le_t(laddr_t laddr, seastore_off_t size)
: addr(laddr), size(init_extent_len_le(size)) {}
struct write_result_t {
journal_seq_t start_seq;
- segment_off_t length;
+ seastore_off_t length;
journal_seq_t get_end_seq() const {
return start_seq.add_offset(length);
return seq.offset.as_seg_paddr().get_segment_id();
}
- segment_off_t get_segment_offset() const {
+ seastore_off_t get_segment_offset() const {
return seq.offset.as_seg_paddr().get_segment_off();
}
- void increment_seq(segment_off_t off) {
+ void increment_seq(seastore_off_t off) {
auto& seg_addr = seq.offset.as_seg_paddr();
seg_addr.set_segment_off(
seg_addr.get_segment_off() + off);
int64_t SpaceTrackerDetailed::SegmentMap::allocate(
device_segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len,
const extent_len_t block_size)
{
int64_t SpaceTrackerDetailed::SegmentMap::release(
device_segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len,
const extent_len_t block_size)
{
segment_manager_info_t(
device_id_t device_id,
device_segment_id_t num_segments,
- segment_off_t segment_size,
- segment_off_t block_size,
+ seastore_off_t segment_size,
+ seastore_off_t block_size,
size_t empty_segments,
size_t size)
: device_id(device_id),
device_id_t device_id = 0;
device_segment_id_t num_segments = 0;
- segment_off_t segment_size = 0;
- segment_off_t block_size = 0;
+ seastore_off_t segment_size = 0;
+ seastore_off_t block_size = 0;
size_t empty_segments = 0;
size_t size = 0;
size_t avail_bytes = 0;
- std::map<segment_id_t, segment_off_t> open_segment_avails;
+ std::map<segment_id_t, seastore_off_t> open_segment_avails;
};
struct segment_info_t {
public:
virtual int64_t allocate(
segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len) = 0;
virtual int64_t release(
segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len) = 0;
virtual int64_t get_usage(
int64_t allocate(
segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len) final {
return update_usage(segment, len);
}
int64_t release(
segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len) final {
return update_usage(segment, -(int64_t)len);
}
int64_t allocate(
device_segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len,
const extent_len_t block_size);
int64_t release(
device_segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len,
const extent_len_t block_size);
int64_t allocate(
segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len) final {
return segment_usage[segment].allocate(
segment.device_segment_id(),
int64_t release(
segment_id_t segment,
- segment_off_t offset,
+ seastore_off_t offset,
extent_len_t len) final {
return segment_usage[segment].release(
segment.device_segment_id(),
extent_types_t type,
paddr_t addr,
laddr_t laddr,
- segment_off_t len) = 0;
+ seastore_off_t len) = 0;
/**
* release_segment
/**
* min next write location
*/
- virtual segment_off_t get_write_ptr() const = 0;
+ virtual seastore_off_t get_write_ptr() const = 0;
/**
* max capacity
*/
- virtual segment_off_t get_write_capacity() const = 0;
+ virtual seastore_off_t get_write_capacity() const = 0;
/**
* close
crimson::ct_error::enospc // write exceeds segment size
>;
virtual write_ertr::future<> write(
- segment_off_t offset, ceph::bufferlist bl) = 0;
+ seastore_off_t offset, ceph::bufferlist bl) = 0;
virtual ~Segment() {}
};
/* Methods for discovering device geometry, segmentid set, etc */
virtual size_t get_size() const = 0;
- virtual segment_off_t get_block_size() const = 0;
- virtual segment_off_t get_segment_size() const = 0;
+ virtual seastore_off_t get_block_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);
return ((device_segment_id_t)(get_size() / get_segment_size()));
BlockSegmentManager &manager, segment_id_t id)
: manager(manager), id(id) {}
-segment_off_t BlockSegment::get_write_capacity() const
+seastore_off_t BlockSegment::get_write_capacity() const
{
return manager.get_segment_size();
}
}
Segment::write_ertr::future<> BlockSegment::write(
- segment_off_t offset, ceph::bufferlist bl)
+ seastore_off_t offset, ceph::bufferlist bl)
{
LOG_PREFIX(BlockSegment::write);
auto paddr = paddr_t::make_seg_paddr(id, offset);
}
Segment::close_ertr::future<> BlockSegmentManager::segment_close(
- segment_id_t id, segment_off_t write_pointer)
+ segment_id_t id, seastore_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;
- segment_off_t write_pointer = 0;
+ seastore_off_t write_pointer = 0;
public:
BlockSegment(BlockSegmentManager &manager, segment_id_t id);
segment_id_t get_segment_id() const final { return id; }
- segment_off_t get_write_capacity() const final;
- segment_off_t get_write_ptr() const final { return write_pointer; }
+ seastore_off_t get_write_capacity() const final;
+ seastore_off_t get_write_ptr() const final { return write_pointer; }
close_ertr::future<> close() final;
- write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+ write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
~BlockSegment() {}
};
size_t get_size() const final {
return superblock.size;
}
- segment_off_t get_block_size() const {
+ seastore_off_t get_block_size() const {
return superblock.block_size;
}
- segment_off_t get_segment_size() const {
+ seastore_off_t get_segment_size() const {
return superblock.segment_size;
}
char *buffer = nullptr;
Segment::close_ertr::future<> segment_close(
- segment_id_t id, segment_off_t write_pointer);
+ segment_id_t id, seastore_off_t write_pointer);
};
}
EphemeralSegmentManager &manager, segment_id_t id)
: manager(manager), id(id) {}
-segment_off_t EphemeralSegment::get_write_capacity() const
+seastore_off_t EphemeralSegment::get_write_capacity() const
{
return manager.get_segment_size();
}
}
Segment::write_ertr::future<> EphemeralSegment::write(
- segment_off_t offset, ceph::bufferlist bl)
+ seastore_off_t offset, ceph::bufferlist bl)
{
if (offset < write_pointer || offset % manager.config.block_size != 0)
return crimson::ct_error::invarg::make();
friend class EphemeralSegmentManager;
EphemeralSegmentManager &manager;
const segment_id_t id;
- segment_off_t write_pointer = 0;
+ seastore_off_t write_pointer = 0;
public:
EphemeralSegment(EphemeralSegmentManager &manager, segment_id_t id);
segment_id_t get_segment_id() const final { return id; }
- segment_off_t get_write_capacity() const final;
- segment_off_t get_write_ptr() const final { return write_pointer; }
+ seastore_off_t get_write_capacity() const final;
+ seastore_off_t get_write_ptr() const final { return write_pointer; }
close_ertr::future<> close() final;
- write_ertr::future<> write(segment_off_t offset, ceph::bufferlist bl) final;
+ write_ertr::future<> write(seastore_off_t offset, ceph::bufferlist bl) final;
~EphemeralSegment() {}
};
size_t get_size() const final {
return config.size;
}
- segment_off_t get_block_size() const final {
+ seastore_off_t get_block_size() const final {
return config.block_size;
}
- segment_off_t get_segment_size() const final {
+ seastore_off_t get_segment_size() const final {
return config.segment_size;
}
RootBlockRef root; ///< ref to root if read or written by transaction
- segment_off_t offset = 0; ///< relative offset of next block
- segment_off_t delayed_temp_offset = 0;
+ seastore_off_t offset = 0; ///< relative offset of next block
+ seastore_off_t delayed_temp_offset = 0;
/**
* read_set
extent_types_t type,
paddr_t addr,
laddr_t laddr,
- segment_off_t len)
+ seastore_off_t len)
{
LOG_PREFIX(TransactionManager::get_extent_if_live);
DEBUGT("type {}, addr {}, laddr {}, len {}", t, type, addr, laddr, len);
extent_types_t type,
paddr_t addr,
laddr_t laddr,
- segment_off_t len) final;
+ seastore_off_t len) final;
using release_segment_ret =
SegmentCleaner::ExtentCallbackInterface::release_segment_ret;
}
struct TestBlock : crimson::os::seastore::LogicalCachedExtent {
- constexpr static segment_off_t SIZE = 4<<10;
+ constexpr static seastore_off_t SIZE = 4<<10;
using Ref = TCachedExtentRef<TestBlock>;
std::vector<test_block_delta_t> delta = {};
using TestBlockRef = TCachedExtentRef<TestBlock>;
struct TestBlockPhysical : crimson::os::seastore::CachedExtent{
- constexpr static segment_off_t SIZE = 4<<10;
+ constexpr static seastore_off_t SIZE = 4<<10;
using Ref = TCachedExtentRef<TestBlockPhysical>;
std::vector<test_block_delta_t> delta = {};
);
}
- segment_off_t next_off = 0;
+ seastore_off_t next_off = 0;
paddr_t get_paddr() {
next_off += block_size;
return make_fake_paddr(next_off);
bl.append(block.bl);
}
- ceph_assert((segment_off_t)bl.length() <
+ ceph_assert((seastore_off_t)bl.length() <
segment_manager->get_segment_size());
- if (current.as_seg_paddr().get_segment_off() + (segment_off_t)bl.length() >
+ if (current.as_seg_paddr().get_segment_off() + (seastore_off_t)bl.length() >
segment_manager->get_segment_size())
current = paddr_t::make_seg_paddr(
segment_id_t(
std::default_random_engine generator;
- segment_off_t block_size;
+ seastore_off_t block_size;
ExtentReaderRef scanner;
}
size_t get_size() const final { return sm.get_size(); }
- segment_off_t get_block_size() const final { return sm.get_block_size(); }
- segment_off_t get_segment_size() const final {
+ seastore_off_t get_block_size() const final { return sm.get_block_size(); }
+ seastore_off_t get_segment_size() const final {
return sm.get_segment_size();
}
const seastore_meta_t &get_meta() const final {
projects / ceph.git / commitdiff