return 0;
}
-int BlueStore::_balance_bluefs_freespace(vector<extent_t> *extents)
+int BlueStore::_balance_bluefs_freespace(vector<bluestore_extent_t> *extents)
{
int ret = 0;
assert(bluefs);
int r = alloc->reserve(gift);
assert(r == 0);
- extent_t e;
+ bluestore_extent_t e;
r = alloc->allocate(MIN(gift, 1ull<<31), min_alloc_size, 0,
&e.offset, &e.length);
if (r < 0)
}
void BlueStore::_commit_bluefs_freespace(
- const vector<extent_t>& bluefs_gift_extents)
+ const vector<bluestore_extent_t>& bluefs_gift_extents)
{
dout(10) << __func__ << dendl;
for (auto& p : bluefs_gift_extents) {
bufferlist& bl,
uint32_t op_flags)
{
- map<uint64_t,extent_t>::iterator bp, bend;
- map<uint64_t,overlay_t>::iterator op, oend;
+ map<uint64_t,bluestore_extent_t>::iterator bp, bend;
+ map<uint64_t,bluestore_overlay_t>::iterator op, oend;
uint64_t block_size = bdev->get_block_size();
int r;
IOContext ioc(NULL); // FIXME?
if (bp != bend && bp->first <= offset) {
uint64_t x_off = offset - bp->first;
x_len = MIN(x_len, bp->second.length - x_off);
- if (!bp->second.has_flag(extent_t::FLAG_UNWRITTEN)) {
+ if (!bp->second.has_flag(bluestore_extent_t::FLAG_UNWRITTEN)) {
dout(30) << __func__ << " data " << bp->first << ": " << bp->second
<< " use " << x_off << "~" << x_len
<< " final offset " << x_off + bp->second.offset
dout(20) << __func__ << " " << offset << "~" << len << " size "
<< o->onode.size << dendl;
- map<uint64_t,extent_t>::iterator bp, bend;
- map<uint64_t,overlay_t>::iterator op, oend;
+ map<uint64_t,bluestore_extent_t>::iterator bp, bend;
+ map<uint64_t,bluestore_overlay_t>::iterator op, oend;
// loop over overlays and data fragments. overlays take precedence.
bend = o->onode.block_map.end();
alloc->release(p.get_start(), p.get_len());
}
- vector<extent_t> bluefs_gift_extents;
+ vector<bluestore_extent_t> bluefs_gift_extents;
if (bluefs) {
int r = _balance_bluefs_freespace(&bluefs_gift_extents);
assert(r >= 0);
for (std::deque<TransContext *>::iterator it = wal_cleaning.begin();
it != wal_cleaning.end();
++it) {
- wal_transaction_t& wt =*(*it)->wal_txn;
+ bluestore_wal_transaction_t& wt =*(*it)->wal_txn;
// cleanup the data in overlays
- for (list<wal_op_t>::iterator p = wt.ops.begin(); p != wt.ops.end(); ++p) {
+ for (list<bluestore_wal_op_t>::iterator p = wt.ops.begin(); p != wt.ops.end(); ++p) {
for (vector<uint64_t>::iterator q = p->removed_overlays.begin();
q != p->removed_overlays.end();
++q) {
dout(10) << __func__ << " finish" << dendl;
}
-wal_op_t *BlueStore::_get_wal_op(TransContext *txc, OnodeRef o)
+bluestore_wal_op_t *BlueStore::_get_wal_op(TransContext *txc, OnodeRef o)
{
if (!txc->wal_txn) {
- txc->wal_txn = new wal_transaction_t;
+ txc->wal_txn = new bluestore_wal_transaction_t;
}
- txc->wal_txn->ops.push_back(wal_op_t());
+ txc->wal_txn->ops.push_back(bluestore_wal_op_t());
txc->wal_op_onodes.push_back(o);
return &txc->wal_txn->ops.back();
}
int BlueStore::_wal_apply(TransContext *txc)
{
- wal_transaction_t& wt = *txc->wal_txn;
+ bluestore_wal_transaction_t& wt = *txc->wal_txn;
dout(20) << __func__ << " txc " << txc << " seq " << wt.seq << dendl;
txc->state = TransContext::STATE_WAL_APPLYING;
assert(txc->ioc.pending_aios.empty());
vector<OnodeRef>::iterator q = txc->wal_op_onodes.begin();
- for (list<wal_op_t>::iterator p = wt.ops.begin();
+ for (list<bluestore_wal_op_t>::iterator p = wt.ops.begin();
p != wt.ops.end();
++p, ++q) {
int r = _do_wal_op(*p, &txc->ioc);
int BlueStore::_wal_finish(TransContext *txc)
{
- wal_transaction_t& wt = *txc->wal_txn;
+ bluestore_wal_transaction_t& wt = *txc->wal_txn;
dout(20) << __func__ << " txc " << " seq " << wt.seq << txc << dendl;
Mutex::Locker l(kv_lock);
return 0;
}
-int BlueStore::_do_wal_op(wal_op_t& wo, IOContext *ioc)
+int BlueStore::_do_wal_op(bluestore_wal_op_t& wo, IOContext *ioc)
{
const uint64_t block_size = bdev->get_block_size();
const uint64_t block_mask = ~(block_size - 1);
_do_read_all_overlays(wo);
switch (wo.op) {
- case wal_op_t::OP_WRITE:
+ case bluestore_wal_op_t::OP_WRITE:
{
dout(20) << __func__ << " write " << wo.extent << dendl;
// FIXME: do the reads async?
}
break;
- case wal_op_t::OP_ZERO:
+ case bluestore_wal_op_t::OP_ZERO:
{
dout(20) << __func__ << " zero " << wo.extent << dendl;
uint64_t offset = wo.extent.offset;
dout(20) << __func__ << " replay " << pretty_binary_string(it->key())
<< dendl;
TransContext *txc = _txc_create(osr.get());
- txc->wal_txn = new wal_transaction_t;
+ txc->wal_txn = new bluestore_wal_transaction_t;
bufferlist bl = it->value();
bufferlist::iterator p = bl.begin();
try {
{
dout(10) << __func__ << " " << o->oid << dendl;
- map<uint64_t,overlay_t>::iterator p = o->onode.overlay_map.begin();
+ map<uint64_t,bluestore_overlay_t>::iterator p = o->onode.overlay_map.begin();
while (p != o->onode.overlay_map.end()) {
dout(20) << __func__ << " rm " << p->first << " " << p->second << dendl;
string key;
<< offset << "~" << length << dendl;
int changed = 0;
- map<uint64_t,overlay_t>::iterator p =
+ map<uint64_t,bluestore_overlay_t>::iterator p =
o->onode.overlay_map.lower_bound(offset);
if (p != o->onode.overlay_map.begin()) {
--p;
if (p->first >= offset) {
dout(20) << __func__ << " trim_front " << p->first << " " << p->second
<< dendl;
- overlay_t& ov = o->onode.overlay_map[offset + length] = p->second;
+ bluestore_overlay_t& ov = o->onode.overlay_map[offset + length] = p->second;
uint64_t by = offset + length - p->first;
ov.value_offset += by;
ov.length -= by;
<< dendl;
assert(p->first < offset);
assert(p->first + p->second.length > offset + length);
- overlay_t& nov = o->onode.overlay_map[offset + length] = p->second;
+ bluestore_overlay_t& nov = o->onode.overlay_map[offset + length] = p->second;
p->second.length = offset - p->first;
uint64_t by = offset + length - p->first;
nov.value_offset += by;
dout(10) << __func__ << " " << o->oid << " "
<< offset << "~" << length << dendl;
- overlay_t& ov = o->onode.overlay_map[offset] =
- overlay_t(++o->onode.last_overlay_key, 0, length);
+ bluestore_overlay_t& ov = o->onode.overlay_map[offset] =
+ bluestore_overlay_t(++o->onode.last_overlay_key, 0, length);
dout(20) << __func__ << " added " << offset << " " << ov << dendl;
string key;
get_overlay_key(o->onode.nid, o->onode.last_overlay_key, &key);
uint64_t offset = 0;
uint64_t length = 0;
- wal_op_t *op = NULL;
+ bluestore_wal_op_t *op = NULL;
- map<uint64_t,overlay_t>::iterator p =
+ map<uint64_t,bluestore_overlay_t>::iterator p =
o->onode.overlay_map.lower_bound(orig_offset);
while (true) {
if (p != o->onode.overlay_map.end() && p->first < orig_offset + orig_length) {
<< " (first)" << dendl;
op = _get_wal_op(txc, o);
op->nid = o->onode.nid;
- op->op = wal_op_t::OP_WRITE;
+ op->op = bluestore_wal_op_t::OP_WRITE;
op->overlays.push_back(p->second);
offset = p->first;
length = p->second.length;
assert(length <= min_alloc_size);
// emit
- map<uint64_t, extent_t>::iterator bp = o->onode.find_extent(offset);
+ map<uint64_t, bluestore_extent_t>::iterator bp = o->onode.find_extent(offset);
if (bp == o->onode.block_map.end() ||
length == min_alloc_size) {
int r = _do_allocate(txc, o, offset, length, 0, false);
if (r < 0)
return r;
bp = o->onode.find_extent(offset);
- if (bp->second.has_flag(extent_t::FLAG_UNWRITTEN)) {
+ if (bp->second.has_flag(bluestore_extent_t::FLAG_UNWRITTEN)) {
dout(10) << __func__ << " zero new allocation " << bp->second << dendl;
bdev->aio_zero(bp->second.offset, bp->second.length, &txc->ioc);
- bp->second.clear_flag(extent_t::FLAG_UNWRITTEN);
+ bp->second.clear_flag(bluestore_extent_t::FLAG_UNWRITTEN);
}
}
uint64_t x_off = offset - bp->first;
return 0;
}
-void BlueStore::_do_read_all_overlays(wal_op_t& wo)
+void BlueStore::_do_read_all_overlays(bluestore_wal_op_t& wo)
{
- for (vector<overlay_t>::iterator q = wo.overlays.begin();
+ for (vector<bluestore_overlay_t>::iterator q = wo.overlays.begin();
q != wo.overlays.end(); ++q) {
string key;
get_overlay_key(wo.nid, q->key, &key);
<< " len " << p->second.length() << dendl;
}
uint64_t pos = 0;
- for (map<uint64_t,extent_t>::iterator p = o->onode.block_map.begin();
+ for (map<uint64_t,bluestore_extent_t>::iterator p = o->onode.block_map.begin();
p != o->onode.block_map.end();
++p) {
dout(30) << __func__ << " extent " << p->first << " " << p->second
pos = p->first + p->second.length;
}
pos = 0;
- for (map<uint64_t,overlay_t>::iterator p = o->onode.overlay_map.begin();
+ for (map<uint64_t,bluestore_overlay_t>::iterator p = o->onode.overlay_map.begin();
p != o->onode.overlay_map.end();
++p) {
dout(30) << __func__ << " overlay " << p->first << " " << p->second
length -= tail;
}
- map<uint64_t, extent_t>::iterator bp;
+ map<uint64_t, bluestore_extent_t>::iterator bp;
uint64_t orig_end = orig_offset + orig_length;
if (orig_offset / min_alloc_size == orig_end / min_alloc_size) {
dout(20) << " split " << bp->first << ": " << bp->second << dendl;
_txc_release(txc, bp->second.offset + left, length);
o->onode.block_map[offset + length] =
- extent_t(bp->second.offset + left + length,
+ bluestore_extent_t(bp->second.offset + left + length,
bp->second.length - (left + length));
bp->second.length = left;
dout(20) << " left " << bp->first << ": " << bp->second << dendl;
<< " (overlap " << overlap << ")" << dendl;
_txc_release(txc, bp->second.offset, overlap);
o->onode.block_map[bp->first + overlap] =
- extent_t(bp->second.offset + overlap,
+ bluestore_extent_t(bp->second.offset + overlap,
bp->second.length - overlap);
o->onode.block_map.erase(bp++);
dout(20) << " now " << bp->first << ": " << bp->second << dendl;
// allocate our new extent(s)
while (length > 0) {
- extent_t e;
+ bluestore_extent_t e;
// for safety, set the UNWRITTEN flag here. We should clear this in
// _do_write or else we likely have problems.
- e.flags |= extent_t::FLAG_UNWRITTEN;
+ e.flags |= bluestore_extent_t::FLAG_UNWRITTEN;
int r = alloc->allocate(length, min_alloc_size, hint,
&e.offset, &e.length);
assert(r == 0);
uint64_t block_size = bdev->get_block_size();
const uint64_t block_mask = ~(block_size - 1);
uint64_t min_alloc_size = g_conf->bluestore_min_alloc_size;
- map<uint64_t, extent_t>::iterator bp;
+ map<uint64_t, bluestore_extent_t>::iterator bp;
uint64_t length;
r = _do_allocate(txc, o, orig_offset, orig_length, fadvise_flags, true);
assert(offset % block_size == 0);
assert(length % block_size == 0);
uint64_t x_off = offset - bp->first;
- if (bp->second.has_flag(extent_t::FLAG_UNWRITTEN)) {
+ if (bp->second.has_flag(bluestore_extent_t::FLAG_UNWRITTEN)) {
if (x_off > 0) {
// extent is unwritten; zero up until x_off
dout(20) << __func__ << " zero " << bp->second.offset << "~" << x_off
dout(20) << __func__ << " write " << offset << "~" << length
<< " x_off " << x_off << dendl;
bdev->aio_write(bp->second.offset + x_off, bl, &txc->ioc);
- bp->second.clear_flag(extent_t::FLAG_UNWRITTEN);
+ bp->second.clear_flag(bluestore_extent_t::FLAG_UNWRITTEN);
++bp;
continue;
}
bl.swap(t);
}
assert(offset == tail_start);
- assert(!bp->second.has_flag(extent_t::FLAG_UNWRITTEN));
+ assert(!bp->second.has_flag(bluestore_extent_t::FLAG_UNWRITTEN));
_pad_zeros(o, &bl, &offset, &length, block_size);
uint64_t x_off = offset - bp->first;
dout(20) << __func__ << " write " << offset << "~" << length
if (offset % min_alloc_size == 0 &&
length % min_alloc_size == 0) {
- assert(bp->second.has_flag(extent_t::FLAG_UNWRITTEN));
+ assert(bp->second.has_flag(bluestore_extent_t::FLAG_UNWRITTEN));
}
- if (bp->second.has_flag(extent_t::FLAG_UNWRITTEN)) {
+ if (bp->second.has_flag(bluestore_extent_t::FLAG_UNWRITTEN)) {
_pad_zeros(o, &bl, &offset, &length, block_size);
if (offset > bp->first) {
uint64_t z_len = offset - bp->first;
<< " x_off " << x_off << dendl;
bdev->aio_zero(bp->second.offset + x_off, z_len, &txc->ioc);
}
- bp->second.clear_flag(extent_t::FLAG_UNWRITTEN);
+ bp->second.clear_flag(bluestore_extent_t::FLAG_UNWRITTEN);
++bp;
continue;
}
goto out;
assert(bp->first <= offset);
assert(offset + length <= bp->first + bp->second.length);
- wal_op_t *op = _get_wal_op(txc, o);
- op->op = wal_op_t::OP_WRITE;
+ bluestore_wal_op_t *op = _get_wal_op(txc, o);
+ op->op = bluestore_wal_op_t::OP_WRITE;
op->extent.offset = bp->second.offset + offset - bp->first;
op->extent.length = length;
op->data = bl;
}
// make sure we didn't leave unwritten extents behind
- for (map<uint64_t,extent_t>::iterator p = o->onode.block_map.begin();
+ for (map<uint64_t,bluestore_extent_t>::iterator p = o->onode.block_map.begin();
p != o->onode.block_map.end();
++p) {
- if (p->second.has_flag(extent_t::FLAG_UNWRITTEN)) {
+ if (p->second.has_flag(bluestore_extent_t::FLAG_UNWRITTEN)) {
derr << __func__ << " left behind an unwritten extent, out of sync with "
<< "_do_allocate" << dendl;
_dump_onode(o);
// overlay
_do_overlay_trim(txc, o, offset, length);
- map<uint64_t,extent_t>::iterator bp = o->onode.seek_extent(offset);
+ map<uint64_t,bluestore_extent_t>::iterator bp = o->onode.seek_extent(offset);
while (bp != o->onode.block_map.end()) {
if (bp->first >= offset + length)
break;
uint64_t x_len = MIN(length, bp->second.length - x_off);
// WAL
- wal_op_t *op = _get_wal_op(txc, o);
- op->op = wal_op_t::OP_ZERO;
+ bluestore_wal_op_t *op = _get_wal_op(txc, o);
+ op->op = bluestore_wal_op_t::OP_ZERO;
op->extent.offset = bp->second.offset + x_off;
op->extent.length = x_len;
dout(20) << __func__ << " wal zero " << x_off << "~" << x_len
o->flush();
// trim down fragments
- map<uint64_t,extent_t>::iterator bp = o->onode.block_map.end();
+ map<uint64_t,bluestore_extent_t>::iterator bp = o->onode.block_map.end();
if (bp != o->onode.block_map.begin())
--bp;
while (bp != o->onode.block_map.end()) {
// zero extent if trimming up?
if (offset > o->onode.size) {
- map<uint64_t,extent_t>::iterator bp = o->onode.block_map.end();
+ map<uint64_t,bluestore_extent_t>::iterator bp = o->onode.block_map.end();
if (bp != o->onode.block_map.begin())
--bp;
if (bp != o->onode.block_map.end() &&
assert(o->onode.size > bp->first); // we do no preallocation (yet)
uint64_t x_off = o->onode.size - bp->first;
uint64_t x_len = ROUND_UP_TO(offset, block_size) - o->onode.size;
- wal_op_t *op = _get_wal_op(txc, o);
- op->op = wal_op_t::OP_ZERO;
+ bluestore_wal_op_t *op = _get_wal_op(txc, o);
+ op->op = bluestore_wal_op_t::OP_ZERO;
op->extent.offset = bp->second.offset + x_off;
op->extent.length = x_len;
dout(20) << __func__ << " wal zero " << x_off << "~" << x_len
} else if (offset < o->onode.size &&
offset % block_size != 0) {
// zero trailing block?
- map<uint64_t,extent_t>::iterator bp = o->onode.find_extent(offset);
+ map<uint64_t,bluestore_extent_t>::iterator bp = o->onode.find_extent(offset);
if (bp != o->onode.block_map.end()) {
- wal_op_t *op = _get_wal_op(txc, o);
- op->op = wal_op_t::OP_ZERO;
+ bluestore_wal_op_t *op = _get_wal_op(txc, o);
+ op->op = bluestore_wal_op_t::OP_ZERO;
uint64_t z_len = block_size - offset % block_size;
op->extent.offset = bp->second.offset + offset - bp->first;
op->extent.length = block_size - offset % block_size;
}
// trim down overlays
- map<uint64_t,overlay_t>::iterator op = o->onode.overlay_map.end();
+ map<uint64_t,bluestore_overlay_t>::iterator op = o->onode.overlay_map.end();
if (op != o->onode.overlay_map.begin())
--op;
while (op != o->onode.overlay_map.end()) {
uint64_t newlen = offset - op->first;
dout(20) << __func__ << " truncate overlay " << op->first << " "
<< op->second << " to " << newlen << dendl;
- overlay_t& ov = op->second;
+ bluestore_overlay_t& ov = op->second;
ov.length = newlen;
break;
}
string key;
o->exists = false;
if (!o->onode.block_map.empty()) {
- for (map<uint64_t,extent_t>::iterator p = o->onode.block_map.begin();
+ for (map<uint64_t,bluestore_extent_t>::iterator p = o->onode.block_map.begin();
p != o->onode.block_map.end();
++p) {
dout(20) << __func__ << " dealloc " << p->second << dendl;
/// an extent map, shared by a group of objects (clones)
struct ObjectGroup {
atomic_t nref; ///< reference count
- extent_ref_map_t m;
+ bluestore_extent_ref_map_t m;
};
/// an in-memory object
string key; ///< key under PREFIX_OBJ where we are stored
boost::intrusive::list_member_hook<> lru_item;
- onode_t onode; ///< metadata stored as value in kv store
+ bluestore_onode_t onode; ///< metadata stored as value in kv store
bool dirty; // ???
bool exists;
struct Collection {
BlueStore *store;
coll_t cid;
- cnode_t cnode;
+ bluestore_cnode_t cnode;
RWLock lock;
// cache onodes on a per-collection basis to avoid lock
list<CollectionRef> removed_collections; ///< colls we removed
boost::intrusive::list_member_hook<> wal_queue_item;
- wal_transaction_t *wal_txn; ///< wal transaction (if any)
+ bluestore_wal_transaction_t *wal_txn; ///< wal transaction (if any)
vector<OnodeRef> wal_op_onodes;
interval_set<uint64_t> allocated, released;
int _open_super_meta();
int _reconcile_bluefs_freespace();
- int _balance_bluefs_freespace(vector<extent_t> *extents);
- void _commit_bluefs_freespace(const vector<extent_t>& extents);
+ int _balance_bluefs_freespace(vector<bluestore_extent_t> *extents);
+ void _commit_bluefs_freespace(const vector<bluestore_extent_t>& extents);
CollectionRef _get_collection(coll_t cid);
void _queue_reap_collection(CollectionRef& c);
kv_stop = false;
}
- wal_op_t *_get_wal_op(TransContext *txc, OnodeRef o);
+ bluestore_wal_op_t *_get_wal_op(TransContext *txc, OnodeRef o);
int _wal_apply(TransContext *txc);
int _wal_finish(TransContext *txc);
- int _do_wal_op(wal_op_t& wo, IOContext *ioc);
+ int _do_wal_op(bluestore_wal_op_t& wo, IOContext *ioc);
int _wal_replay();
public:
const bufferlist& bl);
int _do_write_overlays(TransContext *txc, OnodeRef o,
uint64_t offset, uint64_t length);
- void _do_read_all_overlays(wal_op_t& wo);
+ void _do_read_all_overlays(bluestore_wal_op_t& wo);
void _pad_zeros(OnodeRef o, bufferlist *bl, uint64_t *offset, uint64_t *length,
uint64_t block_size);
int _do_allocate(TransContext *txc,
// cnode_t
-void cnode_t::encode(bufferlist& bl) const
+void bluestore_cnode_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
::encode(bits, bl);
ENCODE_FINISH(bl);
}
-void cnode_t::decode(bufferlist::iterator& p)
+void bluestore_cnode_t::decode(bufferlist::iterator& p)
{
DECODE_START(1, p);
::decode(bits, p);
DECODE_FINISH(p);
}
-void cnode_t::dump(Formatter *f) const
+void bluestore_cnode_t::dump(Formatter *f) const
{
f->dump_unsigned("bits", bits);
}
-void cnode_t::generate_test_instances(list<cnode_t*>& o)
+void bluestore_cnode_t::generate_test_instances(list<bluestore_cnode_t*>& o)
{
- o.push_back(new cnode_t());
- o.push_back(new cnode_t(0));
- o.push_back(new cnode_t(123));
+ o.push_back(new bluestore_cnode_t());
+ o.push_back(new bluestore_cnode_t(0));
+ o.push_back(new bluestore_cnode_t(123));
}
-// extent_t
+// bluestore_extent_t
-string extent_t::get_flags_string(unsigned flags)
+string bluestore_extent_t::get_flags_string(unsigned flags)
{
string s;
if (flags & FLAG_UNWRITTEN) {
return s;
}
-void extent_t::dump(Formatter *f) const
+void bluestore_extent_t::dump(Formatter *f) const
{
f->dump_unsigned("offset", offset);
f->dump_unsigned("length", length);
f->dump_unsigned("flags", flags);
}
-void extent_t::generate_test_instances(list<extent_t*>& o)
+void bluestore_extent_t::generate_test_instances(list<bluestore_extent_t*>& o)
{
- o.push_back(new extent_t());
- o.push_back(new extent_t(123, 456));
- o.push_back(new extent_t(789, 1024, 322));
+ o.push_back(new bluestore_extent_t());
+ o.push_back(new bluestore_extent_t(123, 456));
+ o.push_back(new bluestore_extent_t(789, 1024, 322));
}
-ostream& operator<<(ostream& out, const extent_t& e)
+ostream& operator<<(ostream& out, const bluestore_extent_t& e)
{
out << e.offset << "~" << e.length;
if (e.flags)
- out << ":" << extent_t::get_flags_string(e.flags);
+ out << ":" << bluestore_extent_t::get_flags_string(e.flags);
return out;
}
-// extent_ref_map_t
+// bluestore_extent_ref_map_t
-void extent_ref_map_t::add(uint64_t offset, uint32_t len, unsigned ref)
+void bluestore_extent_ref_map_t::add(uint64_t offset, uint32_t len, unsigned ref)
{
map<uint64_t,record_t>::iterator p = ref_map.insert(
map<uint64_t,record_t>::value_type(offset, record_t(len, ref))).first;
_check();
}
-void extent_ref_map_t::_check()
+void bluestore_extent_ref_map_t::_check() const
{
uint64_t pos = 0;
unsigned refs = 0;
}
}
-void extent_ref_map_t::_maybe_merge_left(map<uint64_t,record_t>::iterator& p)
+void bluestore_extent_ref_map_t::_maybe_merge_left(map<uint64_t,record_t>::iterator& p)
{
if (p == ref_map.begin())
return;
}
}
-void extent_ref_map_t::get(uint64_t offset, uint32_t length)
+void bluestore_extent_ref_map_t::get(uint64_t offset, uint32_t length)
{
map<uint64_t,record_t>::iterator p = ref_map.lower_bound(offset);
if (p == ref_map.end() || p->first > offset) {
_check();
}
-void extent_ref_map_t::put(uint64_t offset, uint32_t length,
- vector<extent_t> *release)
+void bluestore_extent_ref_map_t::put(uint64_t offset, uint32_t length,
+ vector<bluestore_extent_t> *release)
{
map<uint64_t,record_t>::iterator p = ref_map.lower_bound(offset);
if (p == ref_map.end() || p->first > offset) {
--p->second.refs;
_maybe_merge_left(p);
} else {
- release->push_back(extent_t(p->first, length));
+ release->push_back(bluestore_extent_t(p->first, length));
ref_map.erase(p);
}
return;
_maybe_merge_left(p);
++p;
} else {
- release->push_back(extent_t(p->first, p->second.length));
+ release->push_back(bluestore_extent_t(p->first, p->second.length));
ref_map.erase(p++);
}
}
_check();
}
-void extent_ref_map_t::encode(bufferlist& bl) const
+void bluestore_extent_ref_map_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
::encode(ref_map, bl);
ENCODE_FINISH(bl);
}
-void extent_ref_map_t::decode(bufferlist::iterator& p)
+void bluestore_extent_ref_map_t::decode(bufferlist::iterator& p)
{
DECODE_START(1, p);
::decode(ref_map, p);
DECODE_FINISH(p);
}
-void extent_ref_map_t::dump(Formatter *f) const
+void bluestore_extent_ref_map_t::dump(Formatter *f) const
{
f->open_array_section("ref_map");
for (auto& p : ref_map) {
f->close_section();
}
-void extent_ref_map_t::generate_test_instances(list<extent_ref_map_t*>& o)
+void bluestore_extent_ref_map_t::generate_test_instances(list<bluestore_extent_ref_map_t*>& o)
{
- o.push_back(new extent_ref_map_t);
- o.push_back(new extent_ref_map_t);
+ o.push_back(new bluestore_extent_ref_map_t);
+ o.push_back(new bluestore_extent_ref_map_t);
o.back()->add(10, 10);
o.back()->add(30, 10, 3);
o.back()->get(15, 20);
}
-ostream& operator<<(ostream& out, const extent_ref_map_t& m)
+ostream& operator<<(ostream& out, const bluestore_extent_ref_map_t& m)
{
out << "ref_map(";
for (auto p = m.ref_map.begin(); p != m.ref_map.end(); ++p) {
return out;
}
-// overlay_t
+// bluestore_overlay_t
-void overlay_t::encode(bufferlist& bl) const
+void bluestore_overlay_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
::encode(key, bl);
ENCODE_FINISH(bl);
}
-void overlay_t::decode(bufferlist::iterator& p)
+void bluestore_overlay_t::decode(bufferlist::iterator& p)
{
DECODE_START(1, p);
::decode(key, p);
DECODE_FINISH(p);
}
-void overlay_t::dump(Formatter *f) const
+void bluestore_overlay_t::dump(Formatter *f) const
{
f->dump_unsigned("key", key);
f->dump_unsigned("value_offset", value_offset);
f->dump_unsigned("length", length);
}
-void overlay_t::generate_test_instances(list<overlay_t*>& o)
+void bluestore_overlay_t::generate_test_instances(list<bluestore_overlay_t*>& o)
{
- o.push_back(new overlay_t());
- o.push_back(new overlay_t(789, 1024, 1232232));
+ o.push_back(new bluestore_overlay_t());
+ o.push_back(new bluestore_overlay_t(789, 1024, 1232232));
}
-ostream& operator<<(ostream& out, const overlay_t& o)
+ostream& operator<<(ostream& out, const bluestore_overlay_t& o)
{
out << "overlay(" << o.value_offset << "~" << o.length
<< " key " << o.key << ")";
return out;
}
-// onode_t
+// bluestore_onode_t
-void onode_t::encode(bufferlist& bl) const
+void bluestore_onode_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
::encode(nid, bl);
ENCODE_FINISH(bl);
}
-void onode_t::decode(bufferlist::iterator& p)
+void bluestore_onode_t::decode(bufferlist::iterator& p)
{
DECODE_START(1, p);
::decode(nid, p);
DECODE_FINISH(p);
}
-void onode_t::dump(Formatter *f) const
+void bluestore_onode_t::dump(Formatter *f) const
{
f->dump_unsigned("nid", nid);
f->dump_unsigned("size", size);
f->close_section();
}
f->open_object_section("block_map");
- for (map<uint64_t, extent_t>::const_iterator p = block_map.begin();
+ for (map<uint64_t, bluestore_extent_t>::const_iterator p = block_map.begin();
p != block_map.end(); ++p) {
f->open_object_section("extent");
f->dump_unsigned("extent_offset", p->first);
}
f->close_section();
f->open_object_section("overlays");
- for (map<uint64_t, overlay_t>::const_iterator p = overlay_map.begin();
+ for (map<uint64_t, bluestore_overlay_t>::const_iterator p = overlay_map.begin();
p != overlay_map.end(); ++p) {
f->open_object_section("overlay");
f->dump_unsigned("offset", p->first);
f->dump_unsigned("expected_write_size", expected_write_size);
}
-void onode_t::generate_test_instances(list<onode_t*>& o)
+void bluestore_onode_t::generate_test_instances(list<bluestore_onode_t*>& o)
{
- o.push_back(new onode_t());
+ o.push_back(new bluestore_onode_t());
// FIXME
}
-// wal_op_t
+// bluestore_wal_op_t
-void wal_op_t::encode(bufferlist& bl) const
+void bluestore_wal_op_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
::encode(op, bl);
ENCODE_FINISH(bl);
}
-void wal_op_t::decode(bufferlist::iterator& p)
+void bluestore_wal_op_t::decode(bufferlist::iterator& p)
{
DECODE_START(1, p);
::decode(op, p);
DECODE_FINISH(p);
}
-void wal_op_t::dump(Formatter *f) const
+void bluestore_wal_op_t::dump(Formatter *f) const
{
f->dump_unsigned("op", (int)op);
f->dump_object("extent", extent);
f->dump_unsigned("nid", nid);
f->open_array_section("overlays");
- for (vector<overlay_t>::const_iterator p = overlays.begin();
+ for (vector<bluestore_overlay_t>::const_iterator p = overlays.begin();
p != overlays.end(); ++p) {
f->dump_object("overlay", *p);
}
f->close_section();
}
-void wal_op_t::generate_test_instances(list<wal_op_t*>& o)
+void bluestore_wal_op_t::generate_test_instances(list<bluestore_wal_op_t*>& o)
{
- o.push_back(new wal_op_t);
- o.push_back(new wal_op_t);
+ o.push_back(new bluestore_wal_op_t);
+ o.push_back(new bluestore_wal_op_t);
o.back()->op = OP_WRITE;
o.back()->extent.offset = 1;
o.back()->extent.length = 2;
o.back()->data.append("my data");
o.back()->nid = 3;
- o.back()->overlays.push_back(overlay_t());
- o.back()->overlays.push_back(overlay_t());
+ o.back()->overlays.push_back(bluestore_overlay_t());
+ o.back()->overlays.push_back(bluestore_overlay_t());
o.back()->overlays.back().key = 4;
o.back()->overlays.back().value_offset = 5;
o.back()->overlays.back().length = 6;
}
-void wal_transaction_t::encode(bufferlist& bl) const
+void bluestore_wal_transaction_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
::encode(seq, bl);
ENCODE_FINISH(bl);
}
-void wal_transaction_t::decode(bufferlist::iterator& p)
+void bluestore_wal_transaction_t::decode(bufferlist::iterator& p)
{
DECODE_START(1, p);
::decode(seq, p);
DECODE_FINISH(p);
}
-void wal_transaction_t::dump(Formatter *f) const
+void bluestore_wal_transaction_t::dump(Formatter *f) const
{
f->dump_unsigned("seq", seq);
f->open_array_section("ops");
- for (list<wal_op_t>::const_iterator p = ops.begin(); p != ops.end(); ++p) {
+ for (list<bluestore_wal_op_t>::const_iterator p = ops.begin(); p != ops.end(); ++p) {
f->dump_object("op", *p);
}
f->close_section();
}
-void wal_transaction_t::generate_test_instances(list<wal_transaction_t*>& o)
+void bluestore_wal_transaction_t::generate_test_instances(list<bluestore_wal_transaction_t*>& o)
{
- o.push_back(new wal_transaction_t());
- o.push_back(new wal_transaction_t());
+ o.push_back(new bluestore_wal_transaction_t());
+ o.push_back(new bluestore_wal_transaction_t());
o.back()->seq = 123;
- o.back()->ops.push_back(wal_op_t());
- o.back()->ops.push_back(wal_op_t());
- o.back()->ops.back().op = wal_op_t::OP_WRITE;
+ o.back()->ops.push_back(bluestore_wal_op_t());
+ o.back()->ops.push_back(bluestore_wal_op_t());
+ o.back()->ops.back().op = bluestore_wal_op_t::OP_WRITE;
o.back()->ops.back().extent.offset = 2;
o.back()->ops.back().extent.length = 3;
o.back()->ops.back().data.append("foodata");
ostream& operator<<(ostream& out, const bluestore_bdev_label_t& l);
/// collection metadata
-struct cnode_t {
+struct bluestore_cnode_t {
uint32_t bits; ///< how many bits of coll pgid are significant
- cnode_t(int b=0) : bits(b) {}
+ bluestore_cnode_t(int b=0) : bits(b) {}
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator& p);
void dump(Formatter *f) const;
- static void generate_test_instances(list<cnode_t*>& o);
+ static void generate_test_instances(list<bluestore_cnode_t*>& o);
};
-WRITE_CLASS_ENCODER(cnode_t)
+WRITE_CLASS_ENCODER(bluestore_cnode_t)
/// extent: a byte extent back by the block device
-struct extent_t {
+struct bluestore_extent_t {
enum {
FLAG_UNWRITTEN = 1, ///< extent is unwritten (and defined to be zero)
FLAG_SHARED = 2, ///< extent is shared by another object, and refcounted
uint32_t length;
uint32_t flags; /// or reserved
- extent_t(uint64_t o=0, uint32_t l=0, uint32_t f=0)
+ bluestore_extent_t(uint64_t o=0, uint32_t l=0, uint32_t f=0)
: offset(o), length(l), flags(f) {}
uint64_t end() const {
::decode(flags, p);
}
void dump(Formatter *f) const;
- static void generate_test_instances(list<extent_t*>& o);
+ static void generate_test_instances(list<bluestore_extent_t*>& o);
};
-WRITE_CLASS_ENCODER(extent_t)
+WRITE_CLASS_ENCODER(bluestore_extent_t)
-ostream& operator<<(ostream& out, const extent_t& bp);
+ostream& operator<<(ostream& out, const bluestore_extent_t& bp);
/// extent_map: a map of reference counted extents
-struct extent_ref_map_t {
+struct bluestore_extent_ref_map_t {
struct record_t {
uint32_t length;
uint32_t refs;
void add(uint64_t offset, uint32_t len, unsigned ref=2);
void get(uint64_t offset, uint32_t len);
- void put(uint64_t offset, uint32_t len, vector<extent_t> *release);
+ void put(uint64_t offset, uint32_t len, vector<bluestore_extent_t> *release);
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator& p);
void dump(Formatter *f) const;
- static void generate_test_instances(list<extent_ref_map_t*>& o);
+ static void generate_test_instances(list<bluestore_extent_ref_map_t*>& o);
};
-WRITE_CLASS_ENCODER(extent_ref_map_t::record_t)
-WRITE_CLASS_ENCODER(extent_ref_map_t)
+WRITE_CLASS_ENCODER(bluestore_extent_ref_map_t::record_t)
+WRITE_CLASS_ENCODER(bluestore_extent_ref_map_t)
-ostream& operator<<(ostream& out, const extent_ref_map_t& rm);
+ostream& operator<<(ostream& out, const bluestore_extent_ref_map_t& rm);
/// overlay: a byte extent backed by kv pair, logically overlaying other content
-struct overlay_t {
+struct bluestore_overlay_t {
uint64_t key; ///< key (nid+key identify the kv pair in the kvdb)
uint32_t value_offset; ///< offset in associated value for this extent
uint32_t length;
- overlay_t() : key(0), value_offset(0), length(0) {}
- overlay_t(uint64_t k, uint32_t vo, uint32_t l)
+ bluestore_overlay_t() : key(0), value_offset(0), length(0) {}
+ bluestore_overlay_t(uint64_t k, uint32_t vo, uint32_t l)
: key(k), value_offset(vo), length(l) {}
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator& p);
void dump(Formatter *f) const;
- static void generate_test_instances(list<overlay_t*>& o);
+ static void generate_test_instances(list<bluestore_overlay_t*>& o);
};
-WRITE_CLASS_ENCODER(overlay_t)
+WRITE_CLASS_ENCODER(bluestore_overlay_t)
-ostream& operator<<(ostream& out, const overlay_t& o);
+ostream& operator<<(ostream& out, const bluestore_overlay_t& o);
/// onode: per-object metadata
-struct onode_t {
+struct bluestore_onode_t {
uint64_t nid; ///< numeric id (locally unique)
uint64_t size; ///< object size
map<string, bufferptr> attrs; ///< attrs
- map<uint64_t, extent_t> block_map; ///< block data
- map<uint64_t,overlay_t> overlay_map; ///< overlay data (stored in db)
+ map<uint64_t, bluestore_extent_t> block_map; ///< block data
+ map<uint64_t,bluestore_overlay_t> overlay_map; ///< overlay data (stored in db)
map<uint64_t,uint16_t> overlay_refs; ///< overlay keys ref counts (if >1)
uint32_t last_overlay_key; ///< key for next overlay
uint64_t omap_head; ///< id for omap root node
uint32_t expected_object_size;
uint32_t expected_write_size;
- onode_t()
+ bluestore_onode_t()
: nid(0),
size(0),
last_overlay_key(0),
expected_object_size(0),
expected_write_size(0) {}
- map<uint64_t,extent_t>::iterator find_extent(uint64_t offset) {
- map<uint64_t,extent_t>::iterator fp = block_map.lower_bound(offset);
+ map<uint64_t,bluestore_extent_t>::iterator find_extent(uint64_t offset) {
+ map<uint64_t,bluestore_extent_t>::iterator fp = block_map.lower_bound(offset);
if (fp != block_map.begin()) {
--fp;
if (fp->first + fp->second.length <= offset) {
return fp;
}
- map<uint64_t,extent_t>::iterator seek_extent(uint64_t offset) {
- map<uint64_t,extent_t>::iterator fp = block_map.lower_bound(offset);
+ map<uint64_t,bluestore_extent_t>::iterator seek_extent(uint64_t offset) {
+ map<uint64_t,bluestore_extent_t>::iterator fp = block_map.lower_bound(offset);
if (fp != block_map.begin()) {
--fp;
if (fp->first + fp->second.length <= offset) {
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator& p);
void dump(Formatter *f) const;
- static void generate_test_instances(list<onode_t*>& o);
+ static void generate_test_instances(list<bluestore_onode_t*>& o);
};
-WRITE_CLASS_ENCODER(onode_t)
+WRITE_CLASS_ENCODER(bluestore_onode_t)
/// writeahead-logged op
-struct wal_op_t {
+struct bluestore_wal_op_t {
typedef enum {
OP_WRITE = 1,
OP_ZERO = 4,
} type_t;
__u8 op;
- extent_t extent;
+ bluestore_extent_t extent;
bufferlist data;
uint64_t nid;
- vector<overlay_t> overlays;
+ vector<bluestore_overlay_t> overlays;
vector<uint64_t> removed_overlays;
- wal_op_t() : nid(0) {}
+ bluestore_wal_op_t() : nid(0) {}
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator& p);
void dump(Formatter *f) const;
- static void generate_test_instances(list<wal_op_t*>& o);
+ static void generate_test_instances(list<bluestore_wal_op_t*>& o);
};
-WRITE_CLASS_ENCODER(wal_op_t)
+WRITE_CLASS_ENCODER(bluestore_wal_op_t)
/// writeahead-logged transaction
-struct wal_transaction_t {
+struct bluestore_wal_transaction_t {
uint64_t seq;
- list<wal_op_t> ops;
+ list<bluestore_wal_op_t> ops;
interval_set<uint64_t> released; ///< allocations to release after wal
int64_t _bytes; ///< cached byte count
- wal_transaction_t() : _bytes(-1) {}
+ bluestore_wal_transaction_t() : _bytes(-1) {}
#if 0
no users for htis
uint64_t get_bytes() {
if (_bytes < 0) {
_bytes = 0;
- for (list<wal_op_t>::iterator p = ops.begin(); p != ops.end(); ++p) {
+ for (list<bluestore_wal_op_t>::iterator p = ops.begin();
+ p != ops.end();
+ ++p) {
_bytes += p->extent.length;
}
}
void encode(bufferlist& bl) const;
void decode(bufferlist::iterator& p);
void dump(Formatter *f) const;
- static void generate_test_instances(list<wal_transaction_t*>& o);
+ static void generate_test_instances(list<bluestore_wal_transaction_t*>& o);
};
-WRITE_CLASS_ENCODER(wal_transaction_t)
+WRITE_CLASS_ENCODER(bluestore_wal_transaction_t)
#endif
TYPE(SequencerPosition)
#include "os/bluestore/bluestore_types.h"
-TYPE(cnode_t)
-TYPE(extent_t)
-TYPE(overlay_t)
-TYPE(onode_t)
-TYPE(wal_op_t)
-TYPE(wal_transaction_t)
+TYPE(bluestore_cnode_t)
+TYPE(bluestore_extent_t)
+TYPE(bluestore_extent_ref_map_t)
+TYPE(bluestore_overlay_t)
+TYPE(bluestore_onode_t)
+TYPE(bluestore_wal_op_t)
+TYPE(bluestore_wal_transaction_t)
#include "common/hobject.h"
TYPE(hobject_t)
#include <sstream>
-TEST(extent_ref_map_t, add)
+TEST(bluestore_extent_ref_map_t, add)
{
- extent_ref_map_t m;
+ bluestore_extent_ref_map_t m;
m.add(10, 10);
ASSERT_EQ(1, m.ref_map.size());
cout << m << std::endl;
ASSERT_EQ(2, m.ref_map.size());
}
-TEST(extent_ref_map_t, get)
+TEST(bluestore_extent_ref_map_t, get)
{
- extent_ref_map_t m;
+ bluestore_extent_ref_map_t m;
m.add(00, 30);
cout << m << std::endl;
m.get(10, 10);
ASSERT_EQ(2, m.ref_map[28].refs);
}
-TEST(extent_ref_map_t, put)
+TEST(bluestore_extent_ref_map_t, put)
{
- extent_ref_map_t m;
- vector<extent_t> r;
+ bluestore_extent_ref_map_t m;
+ vector<bluestore_extent_t> r;
m.add(10, 30, 1);
m.put(10, 30, &r);
cout << m << " " << r << std::endl;
projects / ceph.git / commitdiff