while (!p.end()) {
uint64_t pos = p.get_off();
try {
- ::decode(e, p);
+ decode(e, p);
}
catch (const buffer::error &e) {
derr << "failed to decode LogEntry at offset " << pos << dendl;
if (op.obc->obs.oi.size > 0) {
assert(op.xattrs.count(ECUtil::get_hinfo_key()));
bufferlist::iterator bp = op.xattrs[ECUtil::get_hinfo_key()].begin();
- ::decode(hinfo, bp);
+ decode(hinfo, bp);
}
op.hinfo = unstable_hashinfo_registry.lookup_or_create(hoid, hinfo);
}
op.hinfo = get_hash_info(op.hoid);
assert(op.hinfo);
op.xattrs = op.obc->attr_cache;
- ::encode(*(op.hinfo), op.xattrs[ECUtil::get_hinfo_key()]);
+ encode(*(op.hinfo), op.xattrs[ECUtil::get_hinfo_key()]);
}
map<pg_shard_t, vector<pair<int, int>>> to_read;
}
if (bl.length() > 0) {
bufferlist::iterator bp = bl.begin();
- ::decode(hinfo, bp);
+ decode(hinfo, bp);
if (checks && hinfo.get_total_chunk_size() != (uint64_t)st.st_size) {
dout(0) << __func__ << ": Mismatch of total_chunk_size "
<< hinfo.get_total_chunk_size() << dendl;
void ECSubWrite::encode(bufferlist &bl) const
{
ENCODE_START(4, 1, bl);
- ::encode(from, bl);
- ::encode(tid, bl);
- ::encode(reqid, bl);
- ::encode(soid, bl);
- ::encode(stats, bl);
- ::encode(t, bl);
- ::encode(at_version, bl);
- ::encode(trim_to, bl);
- ::encode(log_entries, bl);
- ::encode(temp_added, bl);
- ::encode(temp_removed, bl);
- ::encode(updated_hit_set_history, bl);
- ::encode(roll_forward_to, bl);
- ::encode(backfill, bl);
+ encode(from, bl);
+ encode(tid, bl);
+ encode(reqid, bl);
+ encode(soid, bl);
+ encode(stats, bl);
+ encode(t, bl);
+ encode(at_version, bl);
+ encode(trim_to, bl);
+ encode(log_entries, bl);
+ encode(temp_added, bl);
+ encode(temp_removed, bl);
+ encode(updated_hit_set_history, bl);
+ encode(roll_forward_to, bl);
+ encode(backfill, bl);
ENCODE_FINISH(bl);
}
void ECSubWrite::decode(bufferlist::iterator &bl)
{
DECODE_START(4, bl);
- ::decode(from, bl);
- ::decode(tid, bl);
- ::decode(reqid, bl);
- ::decode(soid, bl);
- ::decode(stats, bl);
- ::decode(t, bl);
- ::decode(at_version, bl);
- ::decode(trim_to, bl);
- ::decode(log_entries, bl);
- ::decode(temp_added, bl);
- ::decode(temp_removed, bl);
+ decode(from, bl);
+ decode(tid, bl);
+ decode(reqid, bl);
+ decode(soid, bl);
+ decode(stats, bl);
+ decode(t, bl);
+ decode(at_version, bl);
+ decode(trim_to, bl);
+ decode(log_entries, bl);
+ decode(temp_added, bl);
+ decode(temp_removed, bl);
if (struct_v >= 2) {
- ::decode(updated_hit_set_history, bl);
+ decode(updated_hit_set_history, bl);
}
if (struct_v >= 3) {
- ::decode(roll_forward_to, bl);
+ decode(roll_forward_to, bl);
} else {
roll_forward_to = trim_to;
}
if (struct_v >= 4) {
- ::decode(backfill, bl);
+ decode(backfill, bl);
} else {
// The old protocol used an empty transaction to indicate backfill
backfill = t.empty();
void ECSubWriteReply::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(from, bl);
- ::encode(tid, bl);
- ::encode(last_complete, bl);
- ::encode(committed, bl);
- ::encode(applied, bl);
+ encode(from, bl);
+ encode(tid, bl);
+ encode(last_complete, bl);
+ encode(committed, bl);
+ encode(applied, bl);
ENCODE_FINISH(bl);
}
void ECSubWriteReply::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(from, bl);
- ::decode(tid, bl);
- ::decode(last_complete, bl);
- ::decode(committed, bl);
- ::decode(applied, bl);
+ decode(from, bl);
+ decode(tid, bl);
+ decode(last_complete, bl);
+ decode(committed, bl);
+ decode(applied, bl);
DECODE_FINISH(bl);
}
{
if ((features & CEPH_FEATURE_OSD_FADVISE_FLAGS) == 0) {
ENCODE_START(2, 1, bl);
- ::encode(from, bl);
- ::encode(tid, bl);
+ encode(from, bl);
+ encode(tid, bl);
map<hobject_t, list<pair<uint64_t, uint64_t> >> tmp;
for (map<hobject_t, list<boost::tuple<uint64_t, uint64_t, uint32_t> >>::const_iterator m = to_read.begin();
m != to_read.end(); ++m) {
}
tmp[m->first] = tlist;
}
- ::encode(tmp, bl);
- ::encode(attrs_to_read, bl);
- ::encode(subchunks, bl);
+ encode(tmp, bl);
+ encode(attrs_to_read, bl);
+ encode(subchunks, bl);
ENCODE_FINISH(bl);
return;
}
ENCODE_START(3, 2, bl);
- ::encode(from, bl);
- ::encode(tid, bl);
- ::encode(to_read, bl);
- ::encode(attrs_to_read, bl);
- ::encode(subchunks, bl);
+ encode(from, bl);
+ encode(tid, bl);
+ encode(to_read, bl);
+ encode(attrs_to_read, bl);
+ encode(subchunks, bl);
ENCODE_FINISH(bl);
}
void ECSubRead::decode(bufferlist::iterator &bl)
{
DECODE_START(3, bl);
- ::decode(from, bl);
- ::decode(tid, bl);
+ decode(from, bl);
+ decode(tid, bl);
if (struct_v == 1) {
map<hobject_t, list<pair<uint64_t, uint64_t> >>tmp;
- ::decode(tmp, bl);
+ decode(tmp, bl);
for (map<hobject_t, list<pair<uint64_t, uint64_t> >>::const_iterator m = tmp.begin();
m != tmp.end(); ++m) {
list<boost::tuple<uint64_t, uint64_t, uint32_t> > tlist;
to_read[m->first] = tlist;
}
} else {
- ::decode(to_read, bl);
+ decode(to_read, bl);
}
- ::decode(attrs_to_read, bl);
+ decode(attrs_to_read, bl);
if (struct_v > 2 && struct_v > struct_compat) {
- ::decode(subchunks, bl);
+ decode(subchunks, bl);
} else {
for (auto &&i : attrs_to_read) {
subchunks[i].push_back(make_pair(0, 1));
void ECSubReadReply::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(from, bl);
- ::encode(tid, bl);
- ::encode(buffers_read, bl);
- ::encode(attrs_read, bl);
- ::encode(errors, bl);
+ encode(from, bl);
+ encode(tid, bl);
+ encode(buffers_read, bl);
+ encode(attrs_read, bl);
+ encode(errors, bl);
ENCODE_FINISH(bl);
}
void ECSubReadReply::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(from, bl);
- ::decode(tid, bl);
- ::decode(buffers_read, bl);
- ::decode(attrs_read, bl);
- ::decode(errors, bl);
+ decode(from, bl);
+ decode(tid, bl);
+ decode(buffers_read, bl);
+ decode(attrs_read, bl);
+ decode(errors, bl);
DECODE_FINISH(bl);
}
entry->is_modify() &&
op.updated_snaps) {
bufferlist bl(op.updated_snaps->second.size() * 8 + 8);
- ::encode(op.updated_snaps->second, bl);
+ encode(op.updated_snaps->second, bl);
entry->snaps.swap(bl);
entry->snaps.reassign_to_mempool(mempool::mempool_osd_pglog);
}
map<string, boost::optional<bufferlist> > xattr_rollback;
assert(hinfo);
bufferlist old_hinfo;
- ::encode(*hinfo, old_hinfo);
+ encode(*hinfo, old_hinfo);
xattr_rollback[ECUtil::get_hinfo_key()] = old_hinfo;
if (op.is_none() && op.truncate && op.truncate->first == 0) {
if (!op.is_delete()) {
bufferlist hbuf;
- ::encode(*hinfo, hbuf);
+ encode(*hinfo, hbuf);
for (auto &&i : *transactions) {
i.second.setattr(
coll_t(spg_t(pgid, i.first)),
void ECUtil::HashInfo::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(total_chunk_size, bl);
- ::encode(cumulative_shard_hashes, bl);
+ encode(total_chunk_size, bl);
+ encode(cumulative_shard_hashes, bl);
ENCODE_FINISH(bl);
}
void ECUtil::HashInfo::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(total_chunk_size, bl);
- ::decode(cumulative_shard_hashes, bl);
+ decode(total_chunk_size, bl);
+ decode(cumulative_shard_hashes, bl);
projected_total_chunk_size = total_chunk_size;
DECODE_FINISH(bl);
}
bool is_hinfo_key_string(const std::string &key);
const std::string &get_hinfo_key();
-}
WRITE_CLASS_ENCODER(ECUtil::HashInfo)
+}
#endif
void HitSet::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(sealed, bl);
+ encode(sealed, bl);
if (impl) {
- ::encode((__u8)impl->get_type(), bl);
+ encode((__u8)impl->get_type(), bl);
impl->encode(bl);
} else {
- ::encode((__u8)TYPE_NONE, bl);
+ encode((__u8)TYPE_NONE, bl);
}
ENCODE_FINISH(bl);
}
void HitSet::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(sealed, bl);
+ decode(sealed, bl);
__u8 type;
- ::decode(type, bl);
+ decode(type, bl);
switch ((impl_type_t)type) {
case TYPE_EXPLICIT_HASH:
impl.reset(new ExplicitHashHitSet);
{
ENCODE_START(1, 1, bl);
if (impl) {
- ::encode((__u8)impl->get_type(), bl);
+ encode((__u8)impl->get_type(), bl);
impl->encode(bl);
} else {
- ::encode((__u8)TYPE_NONE, bl);
+ encode((__u8)TYPE_NONE, bl);
}
ENCODE_FINISH(bl);
}
{
DECODE_START(1, bl);
__u8 type;
- ::decode(type, bl);
+ decode(type, bl);
if (!create_impl((impl_type_t)type))
throw buffer::malformed_input("unrecognized HitMap type");
if (impl)
}
void encode(bufferlist &bl) const override {
ENCODE_START(1, 1, bl);
- ::encode(count, bl);
- ::encode(hits, bl);
+ encode(count, bl);
+ encode(hits, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) override {
DECODE_START(1, bl);
- ::decode(count, bl);
- ::decode(hits, bl);
+ decode(count, bl);
+ decode(hits, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const override;
}
void encode(bufferlist &bl) const override {
ENCODE_START(1, 1, bl);
- ::encode(count, bl);
- ::encode(hits, bl);
+ encode(count, bl);
+ encode(hits, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) override {
DECODE_START(1, bl);
- ::decode(count, bl);
- ::decode(hits, bl);
+ decode(count, bl);
+ decode(hits, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const override;
void encode(bufferlist& bl) const override {
ENCODE_START(1, 1, bl);
- ::encode(fpp_micro, bl);
- ::encode(target_size, bl);
- ::encode(seed, bl);
+ encode(fpp_micro, bl);
+ encode(target_size, bl);
+ encode(seed, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) override {
DECODE_START(1, bl);
- ::decode(fpp_micro, bl);
- ::decode(target_size, bl);
- ::decode(seed, bl);
+ decode(fpp_micro, bl);
+ decode(target_size, bl);
+ decode(seed, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const override;
void encode(bufferlist &bl) const override {
ENCODE_START(1, 1, bl);
- ::encode(bloom, bl);
+ encode(bloom, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) override {
DECODE_START(1, bl);
- ::decode(bloom, bl);
+ decode(bloom, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const override;
dout(0) << " have superblock" << dendl;
bufferlist::iterator p;
p = sbbl.begin();
- ::decode(sb, p);
+ decode(sb, p);
if (whoami != sb.whoami) {
derr << "provided osd id " << whoami << " != superblock's " << sb.whoami
<< dendl;
sb.compat_features = get_osd_initial_compat_set();
bufferlist bl;
- ::encode(sb, bl);
+ encode(sb, bl);
ObjectStore::Transaction t;
t.create_collection(coll_t::meta(), 0);
superblock.compat_features.incompat.insert(CEPH_OSD_FEATURE_INCOMPAT_BASE);
bufferlist bl;
- ::encode(superblock, bl);
+ encode(superblock, bl);
t.write(coll_t::meta(), OSD_SUPERBLOCK_GOBJECT, 0, bl.length(), bl);
}
return r;
bufferlist::iterator p = bl.begin();
- ::decode(superblock, p);
+ decode(superblock, p);
dout(10) << "read_superblock " << superblock << dendl;
bufferlist::iterator p = caps_info.caps.begin();
string str;
try {
- ::decode(str, p);
+ decode(str, p);
}
catch (buffer::error& e) {
isvalid = false;
void osd_info_t::encode(bufferlist& bl) const
{
+ using ceph::encode;
__u8 struct_v = 1;
- ::encode(struct_v, bl);
- ::encode(last_clean_begin, bl);
- ::encode(last_clean_end, bl);
- ::encode(up_from, bl);
- ::encode(up_thru, bl);
- ::encode(down_at, bl);
- ::encode(lost_at, bl);
+ encode(struct_v, bl);
+ encode(last_clean_begin, bl);
+ encode(last_clean_end, bl);
+ encode(up_from, bl);
+ encode(up_thru, bl);
+ encode(down_at, bl);
+ encode(lost_at, bl);
}
void osd_info_t::decode(bufferlist::iterator& bl)
{
+ using ceph::decode;
__u8 struct_v;
- ::decode(struct_v, bl);
- ::decode(last_clean_begin, bl);
- ::decode(last_clean_end, bl);
- ::decode(up_from, bl);
- ::decode(up_thru, bl);
- ::decode(down_at, bl);
- ::decode(lost_at, bl);
+ decode(struct_v, bl);
+ decode(last_clean_begin, bl);
+ decode(last_clean_end, bl);
+ decode(up_from, bl);
+ decode(up_thru, bl);
+ decode(down_at, bl);
+ decode(lost_at, bl);
}
void osd_info_t::generate_test_instances(list<osd_info_t*>& o)
void osd_xinfo_t::encode(bufferlist& bl) const
{
ENCODE_START(3, 1, bl);
- ::encode(down_stamp, bl);
+ encode(down_stamp, bl);
__u32 lp = laggy_probability * 0xfffffffful;
- ::encode(lp, bl);
- ::encode(laggy_interval, bl);
- ::encode(features, bl);
- ::encode(old_weight, bl);
+ encode(lp, bl);
+ encode(laggy_interval, bl);
+ encode(features, bl);
+ encode(old_weight, bl);
ENCODE_FINISH(bl);
}
void osd_xinfo_t::decode(bufferlist::iterator& bl)
{
DECODE_START(3, bl);
- ::decode(down_stamp, bl);
+ decode(down_stamp, bl);
__u32 lp;
- ::decode(lp, bl);
+ decode(lp, bl);
laggy_probability = (float)lp / (float)0xffffffff;
- ::decode(laggy_interval, bl);
+ decode(laggy_interval, bl);
if (struct_v >= 2)
- ::decode(features, bl);
+ decode(features, bl);
else
features = 0;
if (struct_v >= 3)
- ::decode(old_weight, bl);
+ decode(old_weight, bl);
else
old_weight = 0;
DECODE_FINISH(bl);
void OSDMap::Incremental::encode_client_old(bufferlist& bl) const
{
+ using ceph::encode;
__u16 v = 5;
- ::encode(v, bl);
- ::encode(fsid, bl);
- ::encode(epoch, bl);
- ::encode(modified, bl);
+ encode(v, bl);
+ encode(fsid, bl);
+ encode(epoch, bl);
+ encode(modified, bl);
int32_t new_t = new_pool_max;
- ::encode(new_t, bl);
- ::encode(new_flags, bl);
- ::encode(fullmap, bl);
- ::encode(crush, bl);
+ encode(new_t, bl);
+ encode(new_flags, bl);
+ encode(fullmap, bl);
+ encode(crush, bl);
- ::encode(new_max_osd, bl);
- // for ::encode(new_pools, bl);
+ encode(new_max_osd, bl);
+ // for encode(new_pools, bl);
__u32 n = new_pools.size();
- ::encode(n, bl);
+ encode(n, bl);
for (const auto &new_pool : new_pools) {
n = new_pool.first;
- ::encode(n, bl);
- ::encode(new_pool.second, bl, 0);
+ encode(n, bl);
+ encode(new_pool.second, bl, 0);
}
- // for ::encode(new_pool_names, bl);
+ // for encode(new_pool_names, bl);
n = new_pool_names.size();
- ::encode(n, bl);
+ encode(n, bl);
for (const auto &new_pool_name : new_pool_names) {
n = new_pool_name.first;
- ::encode(n, bl);
- ::encode(new_pool_name.second, bl);
+ encode(n, bl);
+ encode(new_pool_name.second, bl);
}
- // for ::encode(old_pools, bl);
+ // for encode(old_pools, bl);
n = old_pools.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto &old_pool : old_pools) {
n = old_pool;
- ::encode(n, bl);
+ encode(n, bl);
}
- ::encode(new_up_client, bl, 0);
+ encode(new_up_client, bl, 0);
{
// legacy is map<int32_t,uint8_t>
uint32_t n = new_state.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto p : new_state) {
- ::encode(p.first, bl);
- ::encode((uint8_t)p.second, bl);
+ encode(p.first, bl);
+ encode((uint8_t)p.second, bl);
}
}
- ::encode(new_weight, bl);
- // for ::encode(new_pg_temp, bl);
+ encode(new_weight, bl);
+ // for encode(new_pg_temp, bl);
n = new_pg_temp.size();
- ::encode(n, bl);
+ encode(n, bl);
for (const auto &pg_temp : new_pg_temp) {
old_pg_t opg = pg_temp.first.get_old_pg();
- ::encode(opg, bl);
- ::encode(pg_temp.second, bl);
+ encode(opg, bl);
+ encode(pg_temp.second, bl);
}
}
void OSDMap::Incremental::encode_classic(bufferlist& bl, uint64_t features) const
{
+ using ceph::encode;
if ((features & CEPH_FEATURE_PGID64) == 0) {
encode_client_old(bl);
return;
// base
__u16 v = 6;
- ::encode(v, bl);
- ::encode(fsid, bl);
- ::encode(epoch, bl);
- ::encode(modified, bl);
- ::encode(new_pool_max, bl);
- ::encode(new_flags, bl);
- ::encode(fullmap, bl);
- ::encode(crush, bl);
-
- ::encode(new_max_osd, bl);
- ::encode(new_pools, bl, features);
- ::encode(new_pool_names, bl);
- ::encode(old_pools, bl);
- ::encode(new_up_client, bl, features);
+ encode(v, bl);
+ encode(fsid, bl);
+ encode(epoch, bl);
+ encode(modified, bl);
+ encode(new_pool_max, bl);
+ encode(new_flags, bl);
+ encode(fullmap, bl);
+ encode(crush, bl);
+
+ encode(new_max_osd, bl);
+ encode(new_pools, bl, features);
+ encode(new_pool_names, bl);
+ encode(old_pools, bl);
+ encode(new_up_client, bl, features);
{
uint32_t n = new_state.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto p : new_state) {
- ::encode(p.first, bl);
- ::encode((uint8_t)p.second, bl);
+ encode(p.first, bl);
+ encode((uint8_t)p.second, bl);
}
}
- ::encode(new_weight, bl);
- ::encode(new_pg_temp, bl);
+ encode(new_weight, bl);
+ encode(new_pg_temp, bl);
// extended
__u16 ev = 10;
- ::encode(ev, bl);
- ::encode(new_hb_back_up, bl, features);
- ::encode(new_up_thru, bl);
- ::encode(new_last_clean_interval, bl);
- ::encode(new_lost, bl);
- ::encode(new_blacklist, bl, features);
- ::encode(old_blacklist, bl, features);
- ::encode(new_up_cluster, bl, features);
- ::encode(cluster_snapshot, bl);
- ::encode(new_uuid, bl);
- ::encode(new_xinfo, bl);
- ::encode(new_hb_front_up, bl, features);
+ encode(ev, bl);
+ encode(new_hb_back_up, bl, features);
+ encode(new_up_thru, bl);
+ encode(new_last_clean_interval, bl);
+ encode(new_lost, bl);
+ encode(new_blacklist, bl, features);
+ encode(old_blacklist, bl, features);
+ encode(new_up_cluster, bl, features);
+ encode(cluster_snapshot, bl);
+ encode(new_uuid, bl);
+ encode(new_xinfo, bl);
+ encode(new_hb_front_up, bl, features);
}
void OSDMap::Incremental::encode(bufferlist& bl, uint64_t features) const
{
+ using ceph::encode;
if ((features & CEPH_FEATURE_OSDMAP_ENC) == 0) {
encode_classic(bl, features);
return;
v = 5;
}
ENCODE_START(v, 1, bl); // client-usable data
- ::encode(fsid, bl);
- ::encode(epoch, bl);
- ::encode(modified, bl);
- ::encode(new_pool_max, bl);
- ::encode(new_flags, bl);
- ::encode(fullmap, bl);
- ::encode(crush, bl);
-
- ::encode(new_max_osd, bl);
- ::encode(new_pools, bl, features);
- ::encode(new_pool_names, bl);
- ::encode(old_pools, bl);
- ::encode(new_up_client, bl, features);
+ encode(fsid, bl);
+ encode(epoch, bl);
+ encode(modified, bl);
+ encode(new_pool_max, bl);
+ encode(new_flags, bl);
+ encode(fullmap, bl);
+ encode(crush, bl);
+
+ encode(new_max_osd, bl);
+ encode(new_pools, bl, features);
+ encode(new_pool_names, bl);
+ encode(old_pools, bl);
+ encode(new_up_client, bl, features);
if (v >= 5) {
- ::encode(new_state, bl);
+ encode(new_state, bl);
} else {
uint32_t n = new_state.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto p : new_state) {
- ::encode(p.first, bl);
- ::encode((uint8_t)p.second, bl);
+ encode(p.first, bl);
+ encode((uint8_t)p.second, bl);
}
}
- ::encode(new_weight, bl);
- ::encode(new_pg_temp, bl);
- ::encode(new_primary_temp, bl);
- ::encode(new_primary_affinity, bl);
- ::encode(new_erasure_code_profiles, bl);
- ::encode(old_erasure_code_profiles, bl);
+ encode(new_weight, bl);
+ encode(new_pg_temp, bl);
+ encode(new_primary_temp, bl);
+ encode(new_primary_affinity, bl);
+ encode(new_erasure_code_profiles, bl);
+ encode(old_erasure_code_profiles, bl);
if (v >= 4) {
- ::encode(new_pg_upmap, bl);
- ::encode(old_pg_upmap, bl);
- ::encode(new_pg_upmap_items, bl);
- ::encode(old_pg_upmap_items, bl);
+ encode(new_pg_upmap, bl);
+ encode(old_pg_upmap, bl);
+ encode(new_pg_upmap_items, bl);
+ encode(old_pg_upmap_items, bl);
}
if (v >= 6) {
- ::encode(new_removed_snaps, bl);
- ::encode(new_purged_snaps, bl);
+ encode(new_removed_snaps, bl);
+ encode(new_purged_snaps, bl);
}
ENCODE_FINISH(bl); // client-usable data
}
target_v = 2;
}
ENCODE_START(target_v, 1, bl); // extended, osd-only data
- ::encode(new_hb_back_up, bl, features);
- ::encode(new_up_thru, bl);
- ::encode(new_last_clean_interval, bl);
- ::encode(new_lost, bl);
- ::encode(new_blacklist, bl, features);
- ::encode(old_blacklist, bl, features);
- ::encode(new_up_cluster, bl, features);
- ::encode(cluster_snapshot, bl);
- ::encode(new_uuid, bl);
- ::encode(new_xinfo, bl);
- ::encode(new_hb_front_up, bl, features);
- ::encode(features, bl); // NOTE: features arg, not the member
+ encode(new_hb_back_up, bl, features);
+ encode(new_up_thru, bl);
+ encode(new_last_clean_interval, bl);
+ encode(new_lost, bl);
+ encode(new_blacklist, bl, features);
+ encode(old_blacklist, bl, features);
+ encode(new_up_cluster, bl, features);
+ encode(cluster_snapshot, bl);
+ encode(new_uuid, bl);
+ encode(new_xinfo, bl);
+ encode(new_hb_front_up, bl, features);
+ encode(features, bl); // NOTE: features arg, not the member
if (target_v >= 3) {
- ::encode(new_nearfull_ratio, bl);
- ::encode(new_full_ratio, bl);
- ::encode(new_backfillfull_ratio, bl);
+ encode(new_nearfull_ratio, bl);
+ encode(new_full_ratio, bl);
+ encode(new_backfillfull_ratio, bl);
}
// 5 was string-based new_require_min_compat_client
if (target_v >= 6) {
- ::encode(new_require_min_compat_client, bl);
- ::encode(new_require_osd_release, bl);
+ encode(new_require_min_compat_client, bl);
+ encode(new_require_osd_release, bl);
}
ENCODE_FINISH(bl); // osd-only data
}
- ::encode((uint32_t)0, bl); // dummy inc_crc
+ encode((uint32_t)0, bl); // dummy inc_crc
crc_it = bl.end();
crc_it.advance(-4);
tail_offset = bl.length();
- ::encode(full_crc, bl);
+ encode(full_crc, bl);
ENCODE_FINISH(bl); // meta-encoding wrapper
void OSDMap::Incremental::decode_classic(bufferlist::iterator &p)
{
+ using ceph::decode;
__u32 n, t;
// base
__u16 v;
- ::decode(v, p);
- ::decode(fsid, p);
- ::decode(epoch, p);
- ::decode(modified, p);
+ decode(v, p);
+ decode(fsid, p);
+ decode(epoch, p);
+ decode(modified, p);
if (v == 4 || v == 5) {
- ::decode(n, p);
+ decode(n, p);
new_pool_max = n;
} else if (v >= 6)
- ::decode(new_pool_max, p);
- ::decode(new_flags, p);
- ::decode(fullmap, p);
- ::decode(crush, p);
+ decode(new_pool_max, p);
+ decode(new_flags, p);
+ decode(fullmap, p);
+ decode(crush, p);
- ::decode(new_max_osd, p);
+ decode(new_max_osd, p);
if (v < 6) {
new_pools.clear();
- ::decode(n, p);
+ decode(n, p);
while (n--) {
- ::decode(t, p);
- ::decode(new_pools[t], p);
+ decode(t, p);
+ decode(new_pools[t], p);
}
} else {
- ::decode(new_pools, p);
+ decode(new_pools, p);
}
if (v == 5) {
new_pool_names.clear();
- ::decode(n, p);
+ decode(n, p);
while (n--) {
- ::decode(t, p);
- ::decode(new_pool_names[t], p);
+ decode(t, p);
+ decode(new_pool_names[t], p);
}
} else if (v >= 6) {
- ::decode(new_pool_names, p);
+ decode(new_pool_names, p);
}
if (v < 6) {
old_pools.clear();
- ::decode(n, p);
+ decode(n, p);
while (n--) {
- ::decode(t, p);
+ decode(t, p);
old_pools.insert(t);
}
} else {
- ::decode(old_pools, p);
+ decode(old_pools, p);
}
- ::decode(new_up_client, p);
+ decode(new_up_client, p);
{
map<int32_t,uint8_t> ns;
- ::decode(ns, p);
+ decode(ns, p);
for (auto q : ns) {
new_state[q.first] = q.second;
}
}
- ::decode(new_weight, p);
+ decode(new_weight, p);
if (v < 6) {
new_pg_temp.clear();
- ::decode(n, p);
+ decode(n, p);
while (n--) {
old_pg_t opg;
::decode_raw(opg, p);
- ::decode(new_pg_temp[pg_t(opg)], p);
+ decode(new_pg_temp[pg_t(opg)], p);
}
} else {
- ::decode(new_pg_temp, p);
+ decode(new_pg_temp, p);
}
// decode short map, too.
// extended
__u16 ev = 0;
if (v >= 5)
- ::decode(ev, p);
- ::decode(new_hb_back_up, p);
+ decode(ev, p);
+ decode(new_hb_back_up, p);
if (v < 5)
- ::decode(new_pool_names, p);
- ::decode(new_up_thru, p);
- ::decode(new_last_clean_interval, p);
- ::decode(new_lost, p);
- ::decode(new_blacklist, p);
- ::decode(old_blacklist, p);
+ decode(new_pool_names, p);
+ decode(new_up_thru, p);
+ decode(new_last_clean_interval, p);
+ decode(new_lost, p);
+ decode(new_blacklist, p);
+ decode(old_blacklist, p);
if (ev >= 6)
- ::decode(new_up_cluster, p);
+ decode(new_up_cluster, p);
if (ev >= 7)
- ::decode(cluster_snapshot, p);
+ decode(cluster_snapshot, p);
if (ev >= 8)
- ::decode(new_uuid, p);
+ decode(new_uuid, p);
if (ev >= 9)
- ::decode(new_xinfo, p);
+ decode(new_xinfo, p);
if (ev >= 10)
- ::decode(new_hb_front_up, p);
+ decode(new_hb_front_up, p);
}
void OSDMap::Incremental::decode(bufferlist::iterator& bl)
{
+ using ceph::decode;
/**
* Older encodings of the Incremental had a single struct_v which
* covered the whole encoding, and was prior to our modern
}
{
DECODE_START(6, bl); // client-usable data
- ::decode(fsid, bl);
- ::decode(epoch, bl);
- ::decode(modified, bl);
- ::decode(new_pool_max, bl);
- ::decode(new_flags, bl);
- ::decode(fullmap, bl);
- ::decode(crush, bl);
-
- ::decode(new_max_osd, bl);
- ::decode(new_pools, bl);
- ::decode(new_pool_names, bl);
- ::decode(old_pools, bl);
- ::decode(new_up_client, bl);
+ decode(fsid, bl);
+ decode(epoch, bl);
+ decode(modified, bl);
+ decode(new_pool_max, bl);
+ decode(new_flags, bl);
+ decode(fullmap, bl);
+ decode(crush, bl);
+
+ decode(new_max_osd, bl);
+ decode(new_pools, bl);
+ decode(new_pool_names, bl);
+ decode(old_pools, bl);
+ decode(new_up_client, bl);
if (struct_v >= 5) {
- ::decode(new_state, bl);
+ decode(new_state, bl);
} else {
map<int32_t,uint8_t> ns;
- ::decode(ns, bl);
+ decode(ns, bl);
for (auto q : ns) {
new_state[q.first] = q.second;
}
}
- ::decode(new_weight, bl);
- ::decode(new_pg_temp, bl);
- ::decode(new_primary_temp, bl);
+ decode(new_weight, bl);
+ decode(new_pg_temp, bl);
+ decode(new_primary_temp, bl);
if (struct_v >= 2)
- ::decode(new_primary_affinity, bl);
+ decode(new_primary_affinity, bl);
else
new_primary_affinity.clear();
if (struct_v >= 3) {
- ::decode(new_erasure_code_profiles, bl);
- ::decode(old_erasure_code_profiles, bl);
+ decode(new_erasure_code_profiles, bl);
+ decode(old_erasure_code_profiles, bl);
} else {
new_erasure_code_profiles.clear();
old_erasure_code_profiles.clear();
}
if (struct_v >= 4) {
- ::decode(new_pg_upmap, bl);
- ::decode(old_pg_upmap, bl);
- ::decode(new_pg_upmap_items, bl);
- ::decode(old_pg_upmap_items, bl);
+ decode(new_pg_upmap, bl);
+ decode(old_pg_upmap, bl);
+ decode(new_pg_upmap_items, bl);
+ decode(old_pg_upmap_items, bl);
}
if (struct_v >= 6) {
- ::decode(new_removed_snaps, bl);
- ::decode(new_purged_snaps, bl);
+ decode(new_removed_snaps, bl);
+ decode(new_purged_snaps, bl);
}
DECODE_FINISH(bl); // client-usable data
}
{
DECODE_START(6, bl); // extended, osd-only data
- ::decode(new_hb_back_up, bl);
- ::decode(new_up_thru, bl);
- ::decode(new_last_clean_interval, bl);
- ::decode(new_lost, bl);
- ::decode(new_blacklist, bl);
- ::decode(old_blacklist, bl);
- ::decode(new_up_cluster, bl);
- ::decode(cluster_snapshot, bl);
- ::decode(new_uuid, bl);
- ::decode(new_xinfo, bl);
- ::decode(new_hb_front_up, bl);
+ decode(new_hb_back_up, bl);
+ decode(new_up_thru, bl);
+ decode(new_last_clean_interval, bl);
+ decode(new_lost, bl);
+ decode(new_blacklist, bl);
+ decode(old_blacklist, bl);
+ decode(new_up_cluster, bl);
+ decode(cluster_snapshot, bl);
+ decode(new_uuid, bl);
+ decode(new_xinfo, bl);
+ decode(new_hb_front_up, bl);
if (struct_v >= 2)
- ::decode(encode_features, bl);
+ decode(encode_features, bl);
else
encode_features = CEPH_FEATURE_PGID64 | CEPH_FEATURE_OSDMAP_ENC;
if (struct_v >= 3) {
- ::decode(new_nearfull_ratio, bl);
- ::decode(new_full_ratio, bl);
+ decode(new_nearfull_ratio, bl);
+ decode(new_full_ratio, bl);
} else {
new_nearfull_ratio = -1;
new_full_ratio = -1;
}
if (struct_v >= 4) {
- ::decode(new_backfillfull_ratio, bl);
+ decode(new_backfillfull_ratio, bl);
} else {
new_backfillfull_ratio = -1;
}
if (struct_v == 5) {
string r;
- ::decode(r, bl);
+ decode(r, bl);
if (r.length()) {
new_require_min_compat_client = ceph_release_from_name(r.c_str());
}
}
if (struct_v >= 6) {
- ::decode(new_require_min_compat_client, bl);
- ::decode(new_require_osd_release, bl);
+ decode(new_require_min_compat_client, bl);
+ decode(new_require_osd_release, bl);
} else {
if (new_flags >= 0 && (new_flags & CEPH_OSDMAP_REQUIRE_LUMINOUS)) {
// only for compat with post-kraken pre-luminous test clusters
if (struct_v >= 8) {
have_crc = true;
crc_front.substr_of(bl.get_bl(), start_offset, bl.get_off() - start_offset);
- ::decode(inc_crc, bl);
+ decode(inc_crc, bl);
tail_offset = bl.get_off();
- ::decode(full_crc, bl);
+ decode(full_crc, bl);
} else {
have_crc = false;
full_crc = 0;
void OSDMap::dedup(const OSDMap *o, OSDMap *n)
{
+ using ceph::encode;
if (o->epoch == n->epoch)
return;
// does crush match?
bufferlist oc, nc;
- ::encode(*o->crush, oc, CEPH_FEATURES_SUPPORTED_DEFAULT);
- ::encode(*n->crush, nc, CEPH_FEATURES_SUPPORTED_DEFAULT);
+ encode(*o->crush, oc, CEPH_FEATURES_SUPPORTED_DEFAULT);
+ encode(*n->crush, nc, CEPH_FEATURES_SUPPORTED_DEFAULT);
if (oc.contents_equal(nc)) {
n->crush = o->crush;
}
// serialize, unserialize
void OSDMap::encode_client_old(bufferlist& bl) const
{
+ using ceph::encode;
__u16 v = 5;
- ::encode(v, bl);
+ encode(v, bl);
// base
- ::encode(fsid, bl);
- ::encode(epoch, bl);
- ::encode(created, bl);
- ::encode(modified, bl);
+ encode(fsid, bl);
+ encode(epoch, bl);
+ encode(created, bl);
+ encode(modified, bl);
- // for ::encode(pools, bl);
+ // for encode(pools, bl);
__u32 n = pools.size();
- ::encode(n, bl);
+ encode(n, bl);
for (const auto &pool : pools) {
n = pool.first;
- ::encode(n, bl);
- ::encode(pool.second, bl, 0);
+ encode(n, bl);
+ encode(pool.second, bl, 0);
}
- // for ::encode(pool_name, bl);
+ // for encode(pool_name, bl);
n = pool_name.size();
- ::encode(n, bl);
+ encode(n, bl);
for (const auto &pname : pool_name) {
n = pname.first;
- ::encode(n, bl);
- ::encode(pname.second, bl);
+ encode(n, bl);
+ encode(pname.second, bl);
}
- // for ::encode(pool_max, bl);
+ // for encode(pool_max, bl);
n = pool_max;
- ::encode(n, bl);
+ encode(n, bl);
- ::encode(flags, bl);
+ encode(flags, bl);
- ::encode(max_osd, bl);
+ encode(max_osd, bl);
{
uint32_t n = osd_state.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto s : osd_state) {
- ::encode((uint8_t)s, bl);
+ encode((uint8_t)s, bl);
}
}
- ::encode(osd_weight, bl);
- ::encode(osd_addrs->client_addr, bl, 0);
+ encode(osd_weight, bl);
+ encode(osd_addrs->client_addr, bl, 0);
- // for ::encode(pg_temp, bl);
+ // for encode(pg_temp, bl);
n = pg_temp->size();
- ::encode(n, bl);
+ encode(n, bl);
for (const auto pg : *pg_temp) {
old_pg_t opg = pg.first.get_old_pg();
- ::encode(opg, bl);
- ::encode(pg.second, bl);
+ encode(opg, bl);
+ encode(pg.second, bl);
}
// crush
bufferlist cbl;
crush->encode(cbl, 0 /* legacy (no) features */);
- ::encode(cbl, bl);
+ encode(cbl, bl);
}
void OSDMap::encode_classic(bufferlist& bl, uint64_t features) const
{
+ using ceph::encode;
if ((features & CEPH_FEATURE_PGID64) == 0) {
encode_client_old(bl);
return;
}
__u16 v = 6;
- ::encode(v, bl);
+ encode(v, bl);
// base
- ::encode(fsid, bl);
- ::encode(epoch, bl);
- ::encode(created, bl);
- ::encode(modified, bl);
+ encode(fsid, bl);
+ encode(epoch, bl);
+ encode(created, bl);
+ encode(modified, bl);
- ::encode(pools, bl, features);
- ::encode(pool_name, bl);
- ::encode(pool_max, bl);
+ encode(pools, bl, features);
+ encode(pool_name, bl);
+ encode(pool_max, bl);
- ::encode(flags, bl);
+ encode(flags, bl);
- ::encode(max_osd, bl);
+ encode(max_osd, bl);
{
uint32_t n = osd_state.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto s : osd_state) {
- ::encode((uint8_t)s, bl);
+ encode((uint8_t)s, bl);
}
}
- ::encode(osd_weight, bl);
- ::encode(osd_addrs->client_addr, bl, features);
+ encode(osd_weight, bl);
+ encode(osd_addrs->client_addr, bl, features);
- ::encode(*pg_temp, bl);
+ encode(*pg_temp, bl);
// crush
bufferlist cbl;
crush->encode(cbl, 0 /* legacy (no) features */);
- ::encode(cbl, bl);
+ encode(cbl, bl);
// extended
__u16 ev = 10;
- ::encode(ev, bl);
- ::encode(osd_addrs->hb_back_addr, bl, features);
- ::encode(osd_info, bl);
- ::encode(blacklist, bl, features);
- ::encode(osd_addrs->cluster_addr, bl, features);
- ::encode(cluster_snapshot_epoch, bl);
- ::encode(cluster_snapshot, bl);
- ::encode(*osd_uuid, bl);
- ::encode(osd_xinfo, bl);
- ::encode(osd_addrs->hb_front_addr, bl, features);
+ encode(ev, bl);
+ encode(osd_addrs->hb_back_addr, bl, features);
+ encode(osd_info, bl);
+ encode(blacklist, bl, features);
+ encode(osd_addrs->cluster_addr, bl, features);
+ encode(cluster_snapshot_epoch, bl);
+ encode(cluster_snapshot, bl);
+ encode(*osd_uuid, bl);
+ encode(osd_xinfo, bl);
+ encode(osd_addrs->hb_front_addr, bl, features);
}
void OSDMap::encode(bufferlist& bl, uint64_t features) const
{
+ using ceph::encode;
if ((features & CEPH_FEATURE_OSDMAP_ENC) == 0) {
encode_classic(bl, features);
return;
}
ENCODE_START(v, 1, bl); // client-usable data
// base
- ::encode(fsid, bl);
- ::encode(epoch, bl);
- ::encode(created, bl);
- ::encode(modified, bl);
+ encode(fsid, bl);
+ encode(epoch, bl);
+ encode(created, bl);
+ encode(modified, bl);
- ::encode(pools, bl, features);
- ::encode(pool_name, bl);
- ::encode(pool_max, bl);
+ encode(pools, bl, features);
+ encode(pool_name, bl);
+ encode(pool_max, bl);
if (v < 4) {
decltype(flags) f = flags;
f |= CEPH_OSDMAP_REQUIRE_KRAKEN;
else if (require_osd_release == CEPH_RELEASE_JEWEL)
f |= CEPH_OSDMAP_REQUIRE_JEWEL;
- ::encode(f, bl);
+ encode(f, bl);
} else {
- ::encode(flags, bl);
+ encode(flags, bl);
}
- ::encode(max_osd, bl);
+ encode(max_osd, bl);
if (v >= 5) {
- ::encode(osd_state, bl);
+ encode(osd_state, bl);
} else {
uint32_t n = osd_state.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto s : osd_state) {
- ::encode((uint8_t)s, bl);
+ encode((uint8_t)s, bl);
}
}
- ::encode(osd_weight, bl);
- ::encode(osd_addrs->client_addr, bl, features);
+ encode(osd_weight, bl);
+ encode(osd_addrs->client_addr, bl, features);
- ::encode(*pg_temp, bl);
- ::encode(*primary_temp, bl);
+ encode(*pg_temp, bl);
+ encode(*primary_temp, bl);
if (osd_primary_affinity) {
- ::encode(*osd_primary_affinity, bl);
+ encode(*osd_primary_affinity, bl);
} else {
vector<__u32> v;
- ::encode(v, bl);
+ encode(v, bl);
}
// crush
bufferlist cbl;
crush->encode(cbl, features);
- ::encode(cbl, bl);
- ::encode(erasure_code_profiles, bl);
+ encode(cbl, bl);
+ encode(erasure_code_profiles, bl);
if (v >= 4) {
- ::encode(pg_upmap, bl);
- ::encode(pg_upmap_items, bl);
+ encode(pg_upmap, bl);
+ encode(pg_upmap_items, bl);
} else {
assert(pg_upmap.empty());
assert(pg_upmap_items.empty());
}
if (v >= 6) {
- ::encode(crush_version, bl);
+ encode(crush_version, bl);
}
if (v >= 7) {
- ::encode(new_removed_snaps, bl);
- ::encode(new_purged_snaps, bl);
+ encode(new_removed_snaps, bl);
+ encode(new_purged_snaps, bl);
}
ENCODE_FINISH(bl); // client-usable data
}
target_v = 5;
}
ENCODE_START(target_v, 1, bl); // extended, osd-only data
- ::encode(osd_addrs->hb_back_addr, bl, features);
- ::encode(osd_info, bl);
+ encode(osd_addrs->hb_back_addr, bl, features);
+ encode(osd_info, bl);
{
// put this in a sorted, ordered map<> so that we encode in a
// deterministic order.
map<entity_addr_t,utime_t> blacklist_map;
for (const auto &addr : blacklist)
blacklist_map.insert(make_pair(addr.first, addr.second));
- ::encode(blacklist_map, bl, features);
- }
- ::encode(osd_addrs->cluster_addr, bl, features);
- ::encode(cluster_snapshot_epoch, bl);
- ::encode(cluster_snapshot, bl);
- ::encode(*osd_uuid, bl);
- ::encode(osd_xinfo, bl);
- ::encode(osd_addrs->hb_front_addr, bl, features);
+ encode(blacklist_map, bl, features);
+ }
+ encode(osd_addrs->cluster_addr, bl, features);
+ encode(cluster_snapshot_epoch, bl);
+ encode(cluster_snapshot, bl);
+ encode(*osd_uuid, bl);
+ encode(osd_xinfo, bl);
+ encode(osd_addrs->hb_front_addr, bl, features);
if (target_v >= 2) {
- ::encode(nearfull_ratio, bl);
- ::encode(full_ratio, bl);
- ::encode(backfillfull_ratio, bl);
+ encode(nearfull_ratio, bl);
+ encode(full_ratio, bl);
+ encode(backfillfull_ratio, bl);
}
// 4 was string-based new_require_min_compat_client
if (target_v >= 5) {
- ::encode(require_min_compat_client, bl);
- ::encode(require_osd_release, bl);
+ encode(require_min_compat_client, bl);
+ encode(require_osd_release, bl);
}
if (target_v >= 6) {
- ::encode(removed_snaps_queue, bl);
+ encode(removed_snaps_queue, bl);
}
ENCODE_FINISH(bl); // osd-only data
}
- ::encode((uint32_t)0, bl); // dummy crc
+ encode((uint32_t)0, bl); // dummy crc
crc_it = bl.end();
crc_it.advance(-4);
tail_offset = bl.length();
void OSDMap::decode_classic(bufferlist::iterator& p)
{
+ using ceph::decode;
__u32 n, t;
__u16 v;
- ::decode(v, p);
+ decode(v, p);
// base
- ::decode(fsid, p);
- ::decode(epoch, p);
- ::decode(created, p);
- ::decode(modified, p);
+ decode(fsid, p);
+ decode(epoch, p);
+ decode(created, p);
+ decode(modified, p);
if (v < 6) {
if (v < 4) {
int32_t max_pools = 0;
- ::decode(max_pools, p);
+ decode(max_pools, p);
pool_max = max_pools;
}
pools.clear();
- ::decode(n, p);
+ decode(n, p);
while (n--) {
- ::decode(t, p);
- ::decode(pools[t], p);
+ decode(t, p);
+ decode(pools[t], p);
}
if (v == 4) {
- ::decode(n, p);
+ decode(n, p);
pool_max = n;
} else if (v == 5) {
pool_name.clear();
- ::decode(n, p);
+ decode(n, p);
while (n--) {
- ::decode(t, p);
- ::decode(pool_name[t], p);
+ decode(t, p);
+ decode(pool_name[t], p);
}
- ::decode(n, p);
+ decode(n, p);
pool_max = n;
}
} else {
- ::decode(pools, p);
- ::decode(pool_name, p);
- ::decode(pool_max, p);
+ decode(pools, p);
+ decode(pool_name, p);
+ decode(pool_max, p);
}
// kludge around some old bug that zeroed out pool_max (#2307)
if (pools.size() && pool_max < pools.rbegin()->first) {
pool_max = pools.rbegin()->first;
}
- ::decode(flags, p);
+ decode(flags, p);
- ::decode(max_osd, p);
+ decode(max_osd, p);
{
vector<uint8_t> os;
- ::decode(os, p);
+ decode(os, p);
osd_state.resize(os.size());
for (unsigned i = 0; i < os.size(); ++i) {
osd_state[i] = os[i];
}
}
- ::decode(osd_weight, p);
- ::decode(osd_addrs->client_addr, p);
+ decode(osd_weight, p);
+ decode(osd_addrs->client_addr, p);
if (v <= 5) {
pg_temp->clear();
- ::decode(n, p);
+ decode(n, p);
while (n--) {
old_pg_t opg;
::decode_raw(opg, p);
mempool::osdmap::vector<int32_t> v;
- ::decode(v, p);
+ decode(v, p);
pg_temp->set(pg_t(opg), v);
}
} else {
- ::decode(*pg_temp, p);
+ decode(*pg_temp, p);
}
// crush
bufferlist cbl;
- ::decode(cbl, p);
+ decode(cbl, p);
auto cblp = cbl.begin();
crush->decode(cblp);
// extended
__u16 ev = 0;
if (v >= 5)
- ::decode(ev, p);
- ::decode(osd_addrs->hb_back_addr, p);
- ::decode(osd_info, p);
+ decode(ev, p);
+ decode(osd_addrs->hb_back_addr, p);
+ decode(osd_info, p);
if (v < 5)
- ::decode(pool_name, p);
+ decode(pool_name, p);
- ::decode(blacklist, p);
+ decode(blacklist, p);
if (ev >= 6)
- ::decode(osd_addrs->cluster_addr, p);
+ decode(osd_addrs->cluster_addr, p);
else
osd_addrs->cluster_addr.resize(osd_addrs->client_addr.size());
if (ev >= 7) {
- ::decode(cluster_snapshot_epoch, p);
- ::decode(cluster_snapshot, p);
+ decode(cluster_snapshot_epoch, p);
+ decode(cluster_snapshot, p);
}
if (ev >= 8) {
- ::decode(*osd_uuid, p);
+ decode(*osd_uuid, p);
} else {
osd_uuid->resize(max_osd);
}
if (ev >= 9)
- ::decode(osd_xinfo, p);
+ decode(osd_xinfo, p);
else
osd_xinfo.resize(max_osd);
if (ev >= 10)
- ::decode(osd_addrs->hb_front_addr, p);
+ decode(osd_addrs->hb_front_addr, p);
else
osd_addrs->hb_front_addr.resize(osd_addrs->hb_back_addr.size());
void OSDMap::decode(bufferlist::iterator& bl)
{
+ using ceph::decode;
/**
* Older encodings of the OSDMap had a single struct_v which
* covered the whole encoding, and was prior to our modern
{
DECODE_START(7, bl); // client-usable data
// base
- ::decode(fsid, bl);
- ::decode(epoch, bl);
- ::decode(created, bl);
- ::decode(modified, bl);
+ decode(fsid, bl);
+ decode(epoch, bl);
+ decode(created, bl);
+ decode(modified, bl);
- ::decode(pools, bl);
- ::decode(pool_name, bl);
- ::decode(pool_max, bl);
+ decode(pools, bl);
+ decode(pool_name, bl);
+ decode(pool_max, bl);
- ::decode(flags, bl);
+ decode(flags, bl);
- ::decode(max_osd, bl);
+ decode(max_osd, bl);
if (struct_v >= 5) {
- ::decode(osd_state, bl);
+ decode(osd_state, bl);
} else {
vector<uint8_t> os;
- ::decode(os, bl);
+ decode(os, bl);
osd_state.resize(os.size());
for (unsigned i = 0; i < os.size(); ++i) {
osd_state[i] = os[i];
}
}
- ::decode(osd_weight, bl);
- ::decode(osd_addrs->client_addr, bl);
+ decode(osd_weight, bl);
+ decode(osd_addrs->client_addr, bl);
- ::decode(*pg_temp, bl);
- ::decode(*primary_temp, bl);
+ decode(*pg_temp, bl);
+ decode(*primary_temp, bl);
if (struct_v >= 2) {
osd_primary_affinity.reset(new mempool::osdmap::vector<__u32>);
- ::decode(*osd_primary_affinity, bl);
+ decode(*osd_primary_affinity, bl);
if (osd_primary_affinity->empty())
osd_primary_affinity.reset();
} else {
// crush
bufferlist cbl;
- ::decode(cbl, bl);
+ decode(cbl, bl);
auto cblp = cbl.begin();
crush->decode(cblp);
if (struct_v >= 3) {
- ::decode(erasure_code_profiles, bl);
+ decode(erasure_code_profiles, bl);
} else {
erasure_code_profiles.clear();
}
if (struct_v >= 4) {
- ::decode(pg_upmap, bl);
- ::decode(pg_upmap_items, bl);
+ decode(pg_upmap, bl);
+ decode(pg_upmap_items, bl);
} else {
pg_upmap.clear();
pg_upmap_items.clear();
}
if (struct_v >= 6) {
- ::decode(crush_version, bl);
+ decode(crush_version, bl);
}
if (struct_v >= 7) {
- ::decode(new_removed_snaps, bl);
- ::decode(new_purged_snaps, bl);
+ decode(new_removed_snaps, bl);
+ decode(new_purged_snaps, bl);
}
DECODE_FINISH(bl); // client-usable data
}
{
DECODE_START(6, bl); // extended, osd-only data
- ::decode(osd_addrs->hb_back_addr, bl);
- ::decode(osd_info, bl);
- ::decode(blacklist, bl);
- ::decode(osd_addrs->cluster_addr, bl);
- ::decode(cluster_snapshot_epoch, bl);
- ::decode(cluster_snapshot, bl);
- ::decode(*osd_uuid, bl);
- ::decode(osd_xinfo, bl);
- ::decode(osd_addrs->hb_front_addr, bl);
+ decode(osd_addrs->hb_back_addr, bl);
+ decode(osd_info, bl);
+ decode(blacklist, bl);
+ decode(osd_addrs->cluster_addr, bl);
+ decode(cluster_snapshot_epoch, bl);
+ decode(cluster_snapshot, bl);
+ decode(*osd_uuid, bl);
+ decode(osd_xinfo, bl);
+ decode(osd_addrs->hb_front_addr, bl);
if (struct_v >= 2) {
- ::decode(nearfull_ratio, bl);
- ::decode(full_ratio, bl);
+ decode(nearfull_ratio, bl);
+ decode(full_ratio, bl);
} else {
nearfull_ratio = 0;
full_ratio = 0;
}
if (struct_v >= 3) {
- ::decode(backfillfull_ratio, bl);
+ decode(backfillfull_ratio, bl);
} else {
backfillfull_ratio = 0;
}
if (struct_v == 4) {
string r;
- ::decode(r, bl);
+ decode(r, bl);
if (r.length())
require_min_compat_client = ceph_release_from_name(r.c_str());
}
if (struct_v >= 5) {
- ::decode(require_min_compat_client, bl);
- ::decode(require_osd_release, bl);
+ decode(require_min_compat_client, bl);
+ decode(require_osd_release, bl);
if (require_osd_release >= CEPH_RELEASE_LUMINOUS) {
flags &= ~(CEPH_OSDMAP_LEGACY_REQUIRE_FLAGS);
flags |= CEPH_OSDMAP_RECOVERY_DELETES;
}
}
if (struct_v >= 6) {
- ::decode(removed_snaps_queue, bl);
+ decode(removed_snaps_queue, bl);
}
DECODE_FINISH(bl); // osd-only data
}
if (struct_v >= 8) {
crc_front.substr_of(bl.get_bl(), start_offset, bl.get_off() - start_offset);
- ::decode(crc, bl);
+ decode(crc, bl);
tail_offset = bl.get_off();
crc_defined = true;
} else {
map_t map;
void encode(bufferlist& bl) const {
+ using ceph::encode;
uint32_t n = map.size();
- ::encode(n, bl);
+ encode(n, bl);
for (auto &p : map) {
- ::encode(p.first, bl);
+ encode(p.first, bl);
bl.append((char*)p.second, (*p.second + 1) * sizeof(int32_t));
}
}
void decode(bufferlist::iterator& p) {
+ using ceph::decode;
data.clear();
map.clear();
uint32_t n;
- ::decode(n, p);
+ decode(n, p);
if (!n)
return;
bufferlist::iterator pstart = p;
offsets.resize(n);
for (unsigned i=0; i<n; ++i) {
pg_t pgid;
- ::decode(pgid, p);
+ decode(pgid, p);
offsets[i].first = pgid;
offsets[i].second = p.get_off() - start_off;
uint32_t vn;
- ::decode(vn, p);
+ decode(vn, p);
p.advance(vn * sizeof(int32_t));
}
size_t len = p.get_off() - start_off;
data.clear();
}
void set(pg_t pgid, const mempool::osdmap::vector<int32_t>& v) {
+ using ceph::encode;
size_t need = sizeof(int32_t) * (1 + v.size());
if (need < data.get_append_buffer_unused_tail_length()) {
bufferptr z(data.get_append_buffer_unused_tail_length());
z.zero();
data.append(z.c_str(), z.length());
}
- ::encode(v, data);
+ encode(v, data);
map[pgid] = (int32_t*)(data.back().end_c_str()) - (1 + v.size());
}
mempool::osdmap::vector<int32_t> get(pg_t pgid) {
mempool::osdmap::map<pg_t,mempool::osdmap::vector<int32_t> > pg_temp;
void encode(bufferlist& bl) const {
- ::encode(pg_temp, bl);
+ encode(pg_temp, bl);
}
void decode(bufferlist::iterator& p) {
- ::decode(pg_temp, p);
+ decode(pg_temp, p);
}
friend bool operator==(const PGTempMap& l, const PGTempMap& r) {
return
if (info_struct_v < latest_struct_v) {
map<string,bufferlist> v;
__u8 ver = latest_struct_v;
- ::encode(ver, v[infover_key]);
+ encode(ver, v[infover_key]);
t.omap_setkeys(coll, pgmeta_oid, v);
}
PerfCounters *logger)
{
if (dirty_epoch) {
- ::encode(epoch, (*km)[epoch_key]);
+ encode(epoch, (*km)[epoch_key]);
}
if (logger)
bool did = fast.try_apply_to(&last_written_info);
assert(did); // we verified last_update increased above
if (info == last_written_info) {
- ::encode(fast, (*km)[fastinfo_key]);
+ encode(fast, (*km)[fastinfo_key]);
if (logger)
logger->inc(l_osd_pg_fastinfo);
return 0;
// info. store purged_snaps separately.
interval_set<snapid_t> purged_snaps;
purged_snaps.swap(info.purged_snaps);
- ::encode(info, (*km)[info_key]);
+ encode(info, (*km)[info_key]);
purged_snaps.swap(info.purged_snaps);
if (dirty_big_info) {
// potentially big stuff
bufferlist& bigbl = (*km)[biginfo_key];
- ::encode(past_intervals, bigbl);
- ::encode(info.purged_snaps, bigbl);
+ encode(past_intervals, bigbl);
+ encode(info.purged_snaps, bigbl);
//dout(20) << "write_info bigbl " << bigbl.length() << dendl;
if (logger)
logger->inc(l_osd_pg_biginfo);
bufferlist hint;
uint32_t pg_num = pool->get_pg_num();
uint64_t expected_num_objects_pg = pool->expected_num_objects / pg_num;
- ::encode(pg_num, hint);
- ::encode(expected_num_objects_pg, hint);
+ encode(pg_num, hint);
+ encode(expected_num_objects_pg, hint);
uint32_t hint_type = ObjectStore::Transaction::COLL_HINT_EXPECTED_NUM_OBJECTS;
t.collection_hint(coll, hint_type, hint);
}
t.touch(coll, pgmeta_oid);
map<string,bufferlist> values;
__u8 struct_v = latest_struct_v;
- ::encode(struct_v, values[infover_key]);
+ encode(struct_v, values[infover_key]);
t.omap_setkeys(coll, pgmeta_oid, values);
}
// sanity check version
bufferlist::iterator bp = values[infover_key].begin();
__u8 struct_v = 0;
- ::decode(struct_v, bp);
+ decode(struct_v, bp);
assert(struct_v >= 8);
// get epoch
bp = values[epoch_key].begin();
- ::decode(cur_epoch, bp);
+ decode(cur_epoch, bp);
} else {
// probably bug 10617; see OSD::load_pgs()
return -1;
values.size() == 4);
bufferlist::iterator p = values[infover_key].begin();
- ::decode(struct_v, p);
+ decode(struct_v, p);
assert(struct_v >= 10);
p = values[info_key].begin();
- ::decode(info, p);
+ decode(info, p);
p = values[biginfo_key].begin();
- ::decode(past_intervals, p);
- ::decode(info.purged_snaps, p);
+ decode(past_intervals, p);
+ decode(info.purged_snaps, p);
p = values[fastinfo_key].begin();
if (!p.end()) {
pg_fast_info_t fast;
- ::decode(fast, p);
+ decode(fast, p);
fast.try_apply_to(&info);
}
return 0;
bufferlist snapbl = i->snaps;
bufferlist::iterator p = snapbl.begin();
try {
- ::decode(snaps, p);
+ decode(snaps, p);
} catch (...) {
snaps.clear();
}
bl.push_back(o.attrs[SS_ATTR]);
auto p = bl.begin();
try {
- ::decode(snapset, p);
+ decode(snapset, p);
} catch(...) {
continue;
}
// Fix object info
oi.soid = hoid;
bl.clear();
- ::encode(oi, bl, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
+ encode(oi, bl, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
bufferptr bp(bl.c_str(), bl.length());
o.attrs[OI_ATTR] = bp;
object_info_t oi;
try {
bufferlist::iterator bliter = bv.begin();
- ::decode(oi, bliter);
+ decode(oi, bliter);
} catch (...) {
dout(0) << __func__ << ": Need version of replica, bad object_info_t: " << soid << dendl;
assert(0);
spg_t(info.pgid.pgid, get_primary().shard),
msg->map_epoch,
pg_whoami);
- ::encode(map, reply->get_data());
+ encode(map, reply->get_data());
osd->send_message_osd_cluster(reply, msg->get_connection());
}
ss_bl.push_back(k->second);
try {
bufferlist::iterator bliter = ss_bl.begin();
- ::decode(ss, bliter);
+ decode(ss, bliter);
} catch (...) {
// invalid snapset, probably corrupt
shard_info.set_ss_attr_corrupted();
bl.push_back(k->second);
try {
bufferlist::iterator bliter = bl.begin();
- ::decode(oi, bliter);
+ decode(oi, bliter);
} catch (...) {
// invalid object info, probably corrupt
shard_info.set_oi_attr_corrupted();
if (entry.version > dirty_to_dups)
break;
bufferlist bl;
- ::encode(entry, bl);
+ encode(entry, bl);
(*km)[entry.get_key_name()].claim(bl);
}
p->version >= dirty_to_dups;
++p) {
bufferlist bl;
- ::encode(*p, bl);
+ encode(*p, bl);
(*km)[p->get_key_name()].claim(bl);
}
if (dirty_divergent_priors) {
//dout(10) << "write_log_and_missing: writing divergent_priors" << dendl;
- ::encode(divergent_priors, (*km)["divergent_priors"]);
+ encode(divergent_priors, (*km)["divergent_priors"]);
}
if (require_rollback) {
- ::encode(
+ encode(
log.get_can_rollback_to(),
(*km)["can_rollback_to"]);
- ::encode(
+ encode(
log.get_rollback_info_trimmed_to(),
(*km)["rollback_info_trimmed_to"]);
}
if (entry.version > dirty_to_dups)
break;
bufferlist bl;
- ::encode(entry, bl);
+ encode(entry, bl);
(*km)[entry.get_key_name()].claim(bl);
}
p->version >= dirty_to_dups;
++p) {
bufferlist bl;
- ::encode(*p, bl);
+ encode(*p, bl);
(*km)[p->get_key_name()].claim(bl);
}
to_remove.insert(key);
} else {
uint64_t features = missing.may_include_deletes ? CEPH_FEATURE_OSD_RECOVERY_DELETES : 0;
- ::encode(make_pair(obj, item), (*km)[key], features);
+ encode(make_pair(obj, item), (*km)[key], features);
}
});
if (require_rollback) {
- ::encode(
+ encode(
log.get_can_rollback_to(),
(*km)["can_rollback_to"]);
- ::encode(
+ encode(
log.get_rollback_info_trimmed_to(),
(*km)["rollback_info_trimmed_to"]);
}
bufferlist bl = p->value();//Copy bufferlist before creating iterator
bufferlist::iterator bp = bl.begin();
if (p->key() == "divergent_priors") {
- ::decode(divergent_priors, bp);
+ decode(divergent_priors, bp);
ldpp_dout(dpp, 20) << "read_log_and_missing " << divergent_priors.size()
<< " divergent_priors" << dendl;
must_rebuild = true;
debug_verify_stored_missing = false;
} else if (p->key() == "can_rollback_to") {
- ::decode(on_disk_can_rollback_to, bp);
+ decode(on_disk_can_rollback_to, bp);
} else if (p->key() == "rollback_info_trimmed_to") {
- ::decode(on_disk_rollback_info_trimmed_to, bp);
+ decode(on_disk_rollback_info_trimmed_to, bp);
} else if (p->key() == "may_include_deletes_in_missing") {
missing.may_include_deletes = true;
} else if (p->key().substr(0, 7) == string("missing")) {
hobject_t oid;
pg_missing_item item;
- ::decode(oid, bp);
- ::decode(item, bp);
+ decode(oid, bp);
+ decode(item, bp);
if (item.is_delete()) {
assert(missing.may_include_deletes);
}
missing.add(oid, item.need, item.have, item.is_delete());
} else if (p->key().substr(0, 4) == string("dup_")) {
pg_log_dup_t dup;
- ::decode(dup, bp);
+ decode(dup, bp);
if (!dups.empty()) {
assert(dups.back().version < dup.version);
}
map<string, bufferlist> &keys ///< [in] omap keys, may be cleared
) {
bufferlist bl;
- ::encode(keys, bl);
+ encode(keys, bl);
omap_setkeys(hoid, bl);
}
void omap_rmkeys(
set<string> &keys ///< [in] omap keys, may be cleared
) {
bufferlist bl;
- ::encode(keys, bl);
+ encode(keys, bl);
omap_rmkeys(hoid, bl);
}
void omap_setheader(
recovery_info.oi.prior_version = recovery_info.oi.version;
recovery_info.oi.version = latest->version;
bufferlist bl;
- ::encode(recovery_info.oi, bl,
+ encode(recovery_info.oi, bl,
get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
assert(!pool.info.is_erasure());
t->setattr(coll, ghobject_t(recovery_info.soid), OI_ATTR, bl);
int init(bufferlist::iterator ¶ms) override
{
try {
- ::decode(xattr, params);
- ::decode(val, params);
+ decode(xattr, params);
+ decode(val, params);
} catch (buffer::error &e) {
return -EINVAL;
}
int init(bufferlist::iterator ¶ms) override
{
try {
- ::decode(parent_ino, params);
+ decode(parent_ino, params);
} catch (buffer::error &e) {
return -EINVAL;
}
generic_dout(0) << "PGLSParentFilter::filter" << dendl;
- ::decode(bt, iter);
+ decode(bt, iter);
vector<inode_backpointer_t>::iterator vi;
for (vi = bt.ancestors.begin(); vi != bt.ancestors.end(); ++vi) {
generic_dout(0) << "vi->dirino=" << vi->dirino << " parent_ino=" << parent_ino << dendl;
if (vi->dirino == parent_ino) {
- ::encode(*vi, outdata);
+ encode(*vi, outdata);
return true;
}
}
PGLSFilter *filter;
try {
- ::decode(type, iter);
+ decode(type, iter);
}
catch (buffer::error& e) {
return -EINVAL;
switch (p->op.op) {
case CEPH_OSD_OP_PGNLS_FILTER:
try {
- ::decode(cname, bp);
- ::decode(mname, bp);
+ decode(cname, bp);
+ decode(mname, bp);
}
catch (const buffer::error& e) {
dout(0) << "unable to decode PGLS_FILTER description in " << *m << dendl;
vector<hobject_t> sentries;
pg_nls_response_t response;
try {
- ::decode(response.handle, bp);
+ decode(response.handle, bp);
}
catch (const buffer::error& e) {
dout(0) << "unable to decode PGNLS handle in " << *m << dendl;
response.handle = next;
}
dout(10) << "pgnls handle=" << response.handle << dendl;
- ::encode(response, osd_op.outdata);
+ encode(response, osd_op.outdata);
if (filter)
- ::encode(filter_out, osd_op.outdata);
+ encode(filter_out, osd_op.outdata);
dout(10) << " pgnls result=" << result << " outdata.length()="
<< osd_op.outdata.length() << dendl;
}
case CEPH_OSD_OP_PGLS_FILTER:
try {
- ::decode(cname, bp);
- ::decode(mname, bp);
+ decode(cname, bp);
+ decode(mname, bp);
}
catch (const buffer::error& e) {
dout(0) << "unable to decode PGLS_FILTER description in " << *m << dendl;
vector<hobject_t> sentries;
pg_ls_response_t response;
try {
- ::decode(response.handle, bp);
+ decode(response.handle, bp);
}
catch (const buffer::error& e) {
dout(0) << "unable to decode PGLS handle in " << *m << dendl;
result = 1;
}
response.handle = next;
- ::encode(response, osd_op.outdata);
+ encode(response, osd_op.outdata);
if (filter)
- ::encode(filter_out, osd_op.outdata);
+ encode(filter_out, osd_op.outdata);
dout(10) << " pgls result=" << result << " outdata.length()="
<< osd_op.outdata.length() << dendl;
}
ls.push_back(make_pair(p->begin, p->end));
if (hit_set)
ls.push_back(make_pair(hit_set_start_stamp, utime_t()));
- ::encode(ls, osd_op.outdata);
+ encode(ls, osd_op.outdata);
}
break;
result= -ENOENT;
break;
}
- ::encode(*hit_set, osd_op.outdata);
+ encode(*hit_set, osd_op.outdata);
result = osd_op.outdata.length();
} else {
// read an archived HitSet.
arg.start_after,
arg.max_return);
}
- ::encode(result, osd_op->outdata);
+ encode(result, osd_op->outdata);
return r;
}
pg_whoami,
get_osdmap()->get_epoch(), m->query_epoch,
spg_t(info.pgid.pgid, get_primary().shard), bi.begin, bi.end);
- ::encode(bi.objects, reply->get_data());
+ encode(bi.objects, reply->get_data());
osd->send_message_osd_cluster(reply, m->get_connection());
}
break;
coi.prior_version = coi.version;
coi.version = ctx->at_version;
bl.clear();
- ::encode(coi, bl, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
+ encode(coi, bl, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
t->setattr(coid, OI_ATTR, bl);
ctx->log.push_back(
map <string, bufferlist> attrs;
bl.clear();
- ::encode(snapset, bl);
+ encode(snapset, bl);
attrs[SS_ATTR].claim(bl);
bl.clear();
- ::encode(head_obc->obs.oi, bl,
+ encode(head_obc->obs.oi, bl,
get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
attrs[OI_ATTR].claim(bl);
t->setattrs(head_oid, attrs);
map<string, bufferlist> m;
if (bl.length()) {
bufferlist::iterator p = bl.begin();
- ::decode(header, p);
- ::decode(m, p);
+ decode(header, p);
+ decode(m, p);
assert(p.end());
}
while (!bp.end()) {
__u8 op;
string key;
- ::decode(op, bp);
+ decode(op, bp);
switch (op) {
case CEPH_OSD_TMAP_SET: // insert key
{
- ::decode(key, bp);
+ decode(key, bp);
bufferlist data;
- ::decode(data, bp);
+ decode(data, bp);
m[key] = data;
}
break;
case CEPH_OSD_TMAP_RM: // remove key
- ::decode(key, bp);
+ decode(key, bp);
if (!m.count(key)) {
return -ENOENT;
}
m.erase(key);
break;
case CEPH_OSD_TMAP_RMSLOPPY: // remove key
- ::decode(key, bp);
+ decode(key, bp);
m.erase(key);
break;
case CEPH_OSD_TMAP_HDR: // update header
{
- ::decode(header, bp);
+ decode(header, bp);
}
break;
default:
// reencode
bufferlist obl;
- ::encode(header, obl);
- ::encode(m, obl);
+ encode(header, obl);
+ encode(m, obl);
// write it out
vector<OSDOp> nops(1);
bufferlist header;
__u32 nkeys = 0;
if (newop.outdata.length()) {
- ::decode(header, ip);
- ::decode(nkeys, ip);
+ decode(header, ip);
+ decode(nkeys, ip);
}
dout(10) << "tmapup header " << header.length() << dendl;
if (!bp.end() && *bp == CEPH_OSD_TMAP_HDR) {
++bp;
- ::decode(header, bp);
+ decode(header, bp);
dout(10) << "tmapup new header " << header.length() << dendl;
}
- ::encode(header, obl);
+ encode(header, obl);
dout(20) << "tmapup initial nkeys " << nkeys << dendl;
bool have_next = false;
if (!ip.end()) {
have_next = true;
- ::decode(nextkey, ip);
- ::decode(nextval, ip);
+ decode(nextkey, ip);
+ decode(nextval, ip);
}
while (!bp.end() && !result) {
__u8 op;
string key;
try {
- ::decode(op, bp);
- ::decode(key, bp);
+ decode(op, bp);
+ decode(key, bp);
}
catch (buffer::error& e) {
return -EINVAL;
break;
if (nextkey < key) {
// copy untouched.
- ::encode(nextkey, newkeydata);
- ::encode(nextval, newkeydata);
+ encode(nextkey, newkeydata);
+ encode(nextval, newkeydata);
dout(20) << " keep " << nextkey << " " << nextval.length() << dendl;
} else {
// don't copy; discard old value. and stop.
nkeys--;
}
if (!ip.end()) {
- ::decode(nextkey, ip);
- ::decode(nextval, ip);
+ decode(nextkey, ip);
+ decode(nextval, ip);
} else {
have_next = false;
}
if (op == CEPH_OSD_TMAP_SET) {
bufferlist val;
try {
- ::decode(val, bp);
+ decode(val, bp);
}
catch (buffer::error& e) {
return -EINVAL;
}
- ::encode(key, newkeydata);
- ::encode(val, newkeydata);
+ encode(key, newkeydata);
+ encode(val, newkeydata);
dout(20) << " set " << key << " " << val.length() << dendl;
nkeys++;
} else if (op == CEPH_OSD_TMAP_CREATE) {
}
bufferlist val;
try {
- ::decode(val, bp);
+ decode(val, bp);
}
catch (buffer::error& e) {
return -EINVAL;
}
- ::encode(key, newkeydata);
- ::encode(val, newkeydata);
+ encode(key, newkeydata);
+ encode(val, newkeydata);
dout(20) << " create " << key << " " << val.length() << dendl;
nkeys++;
} else if (op == CEPH_OSD_TMAP_RM) {
// copy remaining
if (have_next) {
- ::encode(nextkey, newkeydata);
- ::encode(nextval, newkeydata);
+ encode(nextkey, newkeydata);
+ encode(nextval, newkeydata);
dout(20) << " keep " << nextkey << " " << nextval.length() << dendl;
}
if (!ip.end()) {
// encode final key count + key data
dout(20) << "tmapup final nkeys " << nkeys << dendl;
- ::encode(nkeys, obl);
+ encode(nkeys, obl);
obl.claim_append(newkeydata);
if (0) {
// sanity check
bufferlist::iterator tp = obl.begin();
bufferlist h;
- ::decode(h, tp);
+ decode(h, tp);
map<string,bufferlist> d;
- ::decode(d, tp);
+ decode(d, tp);
assert(tp.end());
dout(0) << " **** debug sanity check, looks ok ****" << dendl;
}
*len = r;
bufferlist outdata;
map<uint64_t, uint64_t> extents = {{data_offset, r}};
- ::encode(extents, outdata);
+ encode(extents, outdata);
::encode_destructively(*data_bl, outdata);
data_bl->swap(outdata);
}
case Checksummer::CSUM_XXHASH32:
{
Checksummer::xxhash32::init_value_t init_value;
- ::decode(init_value, *init_value_bl_it);
+ decode(init_value, *init_value_bl_it);
Checksummer::calculate<Checksummer::xxhash32>(
init_value, csum_chunk_size, 0, read_bl.length(), read_bl,
&csum_data);
case Checksummer::CSUM_XXHASH64:
{
Checksummer::xxhash64::init_value_t init_value;
- ::decode(init_value, *init_value_bl_it);
+ decode(init_value, *init_value_bl_it);
Checksummer::calculate<Checksummer::xxhash64>(
init_value, csum_chunk_size, 0, read_bl.length(), read_bl,
&csum_data);
case Checksummer::CSUM_CRC32C:
{
Checksummer::crc32c::init_value_t init_value;
- ::decode(init_value, *init_value_bl_it);
+ decode(init_value, *init_value_bl_it);
Checksummer::calculate<Checksummer::crc32c>(
init_value, csum_chunk_size, 0, read_bl.length(), read_bl,
&csum_data);
}
}
- ::encode(csum_count, osd_op.outdata);
+ encode(csum_count, osd_op.outdata);
osd_op.outdata.claim_append(csum);
return 0;
}
} else {
dout(10) << " sparse read ended up empty for " << soid << dendl;
map<uint64_t, uint64_t> extents;
- ::encode(extents, osd_op.outdata);
+ encode(extents, osd_op.outdata);
}
} else {
// read into a buffer
op.extent.length = total_read;
- ::encode(m, osd_op.outdata); // re-encode since it might be modified
+ encode(m, osd_op.outdata); // re-encode since it might be modified
::encode_destructively(data_bl, osd_op.outdata);
dout(10) << " sparse_read got " << total_read << " bytes from object "
tracepoint(osd, do_osd_op_pre_stat, soid.oid.name.c_str(), soid.snap.val);
if (obs.exists && !oi.is_whiteout()) {
- ::encode(oi.size, osd_op.outdata);
- ::encode(oi.mtime, osd_op.outdata);
+ encode(oi.size, osd_op.outdata);
+ encode(oi.mtime, osd_op.outdata);
dout(10) << "stat oi has " << oi.size << " " << oi.mtime << dendl;
} else {
result = -ENOENT;
{
tracepoint(osd, do_osd_op_pre_isdirty, soid.oid.name.c_str(), soid.snap.val);
bool is_dirty = obs.oi.is_dirty();
- ::encode(is_dirty, osd_op.outdata);
+ encode(is_dirty, osd_op.outdata);
ctx->delta_stats.num_rd++;
result = 0;
}
&out);
bufferlist bl;
- ::encode(out, bl);
+ encode(out, bl);
ctx->delta_stats.num_rd_kb += SHIFT_ROUND_UP(bl.length(), 10);
ctx->delta_stats.num_rd++;
osd_op.outdata.claim_append(bl);
{
uint64_t u64val;
try {
- ::decode(u64val, bp);
+ decode(u64val, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
try {
uint32_t ver; // obsolete
- ::decode(ver, bp);
- ::decode(timeout, bp);
- ::decode(bl, bp);
+ decode(ver, bp);
+ decode(timeout, bp);
+ decode(bl, bp);
} catch (const buffer::error &e) {
timeout = 0;
}
ctx->notifies.push_back(n);
// return our unique notify id to the client
- ::encode(n.notify_id, osd_op.outdata);
+ encode(n.notify_id, osd_op.outdata);
}
break;
try {
uint64_t notify_id = 0;
uint64_t watch_cookie = 0;
- ::decode(notify_id, bp);
- ::decode(watch_cookie, bp);
+ decode(notify_id, bp);
+ decode(watch_cookie, bp);
bufferlist reply_bl;
if (!bp.end()) {
- ::decode(reply_bl, bp);
+ decode(reply_bl, bp);
}
tracepoint(osd, do_osd_op_pre_notify_ack, soid.oid.name.c_str(), soid.snap.val, notify_id, watch_cookie, "Y");
OpContext::NotifyAck ack(notify_id, watch_cookie, reply_bl);
bufferlist::iterator p = osd_op.indata.begin();
string category;
try {
- ::decode(category, p);
+ decode(category, p);
}
catch (buffer::error& e) {
result = -EINVAL;
snapid_t target_snapid = (uint64_t)op.copy_from.snapid;
version_t target_version = op.copy_from.src_version;
try {
- ::decode(target_name, bp);
- ::decode(target_oloc, bp);
+ decode(target_name, bp);
+ decode(target_oloc, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
uint64_t src_offset, src_length, tgt_offset;
object_t tgt_name;
try {
- ::decode(src_offset, bp);
- ::decode(src_length, bp);
- ::decode(tgt_oloc, bp);
- ::decode(tgt_name, bp);
- ::decode(tgt_offset, bp);
+ decode(src_offset, bp);
+ decode(src_length, bp);
+ decode(tgt_oloc, bp);
+ decode(tgt_name, bp);
+ decode(tgt_offset, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
bool unsorted = false;
if (true) {
bufferlist header;
- ::decode(header, bp);
+ decode(header, bp);
uint32_t n;
- ::decode(n, bp);
+ decode(n, bp);
string last_key;
while (n--) {
string key;
- ::decode(key, bp);
+ decode(key, bp);
dout(10) << "tmapput key " << key << dendl;
bufferlist val;
- ::decode(val, bp);
+ decode(val, bp);
if (key < last_key) {
dout(10) << "TMAPPUT is unordered; resorting" << dendl;
unsorted = true;
bp = osd_op.indata.begin();
bufferlist header;
map<string, bufferlist> m;
- ::decode(header, bp);
- ::decode(m, bp);
+ decode(header, bp);
+ decode(m, bp);
assert(bp.end());
bufferlist newbl;
- ::encode(header, newbl);
- ::encode(m, newbl);
+ encode(header, newbl);
+ encode(m, newbl);
newop.indata = newbl;
}
result = do_osd_ops(ctx, nops);
string start_after;
uint64_t max_return;
try {
- ::decode(start_after, bp);
- ::decode(max_return, bp);
+ decode(start_after, bp);
+ decode(max_return, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
truncated = true;
break;
}
- ::encode(iter->key(), bl);
+ encode(iter->key(), bl);
}
} // else return empty out_set
- ::encode(num, osd_op.outdata);
+ encode(num, osd_op.outdata);
osd_op.outdata.claim_append(bl);
- ::encode(truncated, osd_op.outdata);
+ encode(truncated, osd_op.outdata);
ctx->delta_stats.num_rd_kb += SHIFT_ROUND_UP(osd_op.outdata.length(), 10);
ctx->delta_stats.num_rd++;
}
uint64_t max_return;
string filter_prefix;
try {
- ::decode(start_after, bp);
- ::decode(max_return, bp);
- ::decode(filter_prefix, bp);
+ decode(start_after, bp);
+ decode(max_return, bp);
+ decode(filter_prefix, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
truncated = true;
break;
}
- ::encode(iter->key(), bl);
- ::encode(iter->value(), bl);
+ encode(iter->key(), bl);
+ encode(iter->value(), bl);
}
} // else return empty out_set
- ::encode(num, osd_op.outdata);
+ encode(num, osd_op.outdata);
osd_op.outdata.claim_append(bl);
- ::encode(truncated, osd_op.outdata);
+ encode(truncated, osd_op.outdata);
ctx->delta_stats.num_rd_kb += SHIFT_ROUND_UP(osd_op.outdata.length(), 10);
ctx->delta_stats.num_rd++;
}
{
set<string> keys_to_get;
try {
- ::decode(keys_to_get, bp);
+ decode(keys_to_get, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
if (oi.is_omap()) {
osd->store->omap_get_values(ch, ghobject_t(soid), keys_to_get, &out);
} // else return empty omap entries
- ::encode(out, osd_op.outdata);
+ encode(out, osd_op.outdata);
ctx->delta_stats.num_rd_kb += SHIFT_ROUND_UP(osd_op.outdata.length(), 10);
ctx->delta_stats.num_rd++;
}
}
map<string, pair<bufferlist, int> > assertions;
try {
- ::decode(assertions, bp);
+ decode(assertions, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
dout(20) << "setting vals: " << dendl;
map<string,bufferlist> to_set;
bufferlist::iterator pt = to_set_bl.begin();
- ::decode(to_set, pt);
+ decode(to_set, pt);
for (map<string, bufferlist>::iterator i = to_set.begin();
i != to_set.end();
++i) {
snapid_t src_snapid = (uint64_t)op.copy_from.snapid;
version_t src_version = op.copy_from.src_version;
try {
- ::decode(src_name, bp);
- ::decode(src_oloc, bp);
+ decode(src_name, bp);
+ decode(src_oloc, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
do_osd_ops(ctx, nops);
try {
bufferlist::iterator i = newop.outdata.begin();
- ::decode(*header, i);
+ decode(*header, i);
(*vals).substr_of(newop.outdata, i.get_off(), i.get_remaining());
} catch (...) {
dout(20) << "unsuccessful at decoding tmap for " << ctx->new_obs.oi.soid
object_info_t *poi)
{
bufferlist bv;
- ::encode(*poi, bv, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
+ encode(*poi, bv, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
t->clone(coid, head);
setattr_maybe_cache(obc, t, OI_ATTR, bv);
ctx->obs->oi.version,
ctx->obs->oi.user_version,
osd_reqid_t(), ctx->new_obs.oi.mtime, 0));
- ::encode(snaps, ctx->log.back().snaps);
+ encode(snaps, ctx->log.back().snaps);
ctx->at_version.version++;
}
// object_info_t
map <string, bufferlist> attrs;
bufferlist bv(sizeof(ctx->new_obs.oi));
- ::encode(ctx->new_obs.oi, bv,
+ encode(ctx->new_obs.oi, bv,
get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
attrs[OI_ATTR].claim(bv);
dout(10) << " final snapset " << ctx->new_snapset
<< " in " << soid << dendl;
bufferlist bss;
- ::encode(ctx->new_snapset, bss);
+ encode(ctx->new_snapset, bss);
attrs[SS_ATTR].claim(bss);
} else {
dout(10) << " no snapset (this is a clone)" << dendl;
case pg_log_entry_t::CLEAN:
dout(20) << __func__ << " encoding snaps from " << ctx->new_snapset
<< dendl;
- ::encode(ctx->new_snapset.clone_snaps[soid.snap], ctx->log.back().snaps);
+ encode(ctx->new_snapset.clone_snaps[soid.snap], ctx->log.back().snaps);
break;
default:
break;
bufferlist bl;
bl.substr_of(reply_obj.data, 0, len);
reply_obj.data.swap(bl);
- ::encode(reply_obj, osd_op->outdata, features);
+ encode(reply_obj, osd_op->outdata, features);
}
};
object_copy_cursor_t cursor;
uint64_t out_max;
try {
- ::decode(cursor, bp);
- ::decode(out_max, bp);
+ decode(cursor, bp);
+ decode(out_max, bp);
}
catch (buffer::error& e) {
result = -EINVAL;
iter->upper_bound(cursor.omap_offset);
for (; iter->valid(); iter->next(false)) {
++omap_keys;
- ::encode(iter->key(), omap_data);
- ::encode(iter->value(), omap_data);
+ encode(iter->key(), omap_data);
+ encode(iter->value(), omap_data);
left -= iter->key().length() + 4 + iter->value().length() + 4;
if (left <= 0)
break;
}
if (omap_keys) {
- ::encode(omap_keys, reply_obj.omap_data);
+ encode(omap_keys, reply_obj.omap_data);
reply_obj.omap_data.claim_append(omap_data);
}
if (iter->valid()) {
<< dendl;
reply_obj.cursor = cursor;
if (!async_read_started) {
- ::encode(reply_obj, osd_op.outdata, features);
+ encode(reply_obj, osd_op.outdata, features);
}
if (cb && !async_read_started) {
delete cb;
pg_log.get_log().get_object_reqids(oid, 10, &reply_obj.reqids);
dout(20) << __func__ << " got reqids " << reply_obj.reqids << dendl;
- ::encode(reply_obj, osd_op.outdata, features);
+ encode(reply_obj, osd_op.outdata, features);
osd_op.rval = -ENOENT;
MOSDOpReply *reply = new MOSDOpReply(m, 0, get_osdmap()->get_epoch(), 0, false,
op->qos_resp);
if (cop->omap_data.length()) {
map<string,bufferlist> omap;
bufferlist::iterator p = cop->omap_data.begin();
- ::decode(omap, p);
+ decode(omap, p);
t->omap_setkeys(cop->results.temp_oid, omap);
cop->omap_data.clear();
}
oi.prior_version = obc->obs.oi.version;
oi.version = ctx->at_version;
bufferlist bl;
- ::encode(oi, bl, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
+ encode(oi, bl, get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
t->setattr(obc->obs.oi.soid, OI_ATTR, bl);
// apply new object state.
object_info_t oi;
try {
bufferlist::iterator bliter = bv.begin();
- ::decode(oi, bliter);
+ decode(oi, bliter);
} catch (...) {
dout(0) << __func__ << ": obc corrupt: " << soid << dendl;
return ObjectContextRef(); // -ENOENT!
return;
hit_set->seal();
- ::encode(*hit_set, bl);
+ encode(*hit_set, bl);
dout(20) << __func__ << " archive " << oid << dendl;
if (agent_state) {
ctx->delta_stats.num_bytes_hit_set_archive += bl.length();
bufferlist bss;
- ::encode(ctx->new_snapset, bss);
+ encode(ctx->new_snapset, bss);
bufferlist boi(sizeof(ctx->new_obs.oi));
- ::encode(ctx->new_obs.oi, boi,
+ encode(ctx->new_obs.oi, boi,
get_osdmap()->get_features(CEPH_ENTITY_TYPE_OSD, nullptr));
ctx->op_t->create(oid);
}
HitSetRef hs(new HitSet);
bufferlist::iterator pbl = bl.begin();
- ::decode(*hs, pbl);
+ decode(*hs, pbl);
agent_state->add_hit_set(p->begin.sec(), hs);
}
}
bufferlist::iterator blp = bl.begin();
try {
snapset = SnapSet(); // Initialize optional<> before decoding into it
- ::decode(snapset.get(), blp);
+ decode(snapset.get(), blp);
} catch (buffer::error& e) {
snapset = boost::none;
osd->clog->error() << mode << " " << info.pgid << " " << soid
<< soid << " error=" << r << dendl;
} else try {
bufferlist::iterator bliter = bv.begin();
- ::decode(oi, bliter);
+ decode(oi, bliter);
v = oi.version;
} catch (...) {
// Leave v as default constructed. This will fail when sent to older OSDs, but
auto oiter = pgt->op_map.find(le.soid);
if (oiter != pgt->op_map.end() && oiter->second.updated_snaps) {
bufferlist bl(oiter->second.updated_snaps->second.size() * 8 + 8);
- ::encode(oiter->second.updated_snaps->second, bl);
+ encode(oiter->second.updated_snaps->second, bl);
le.snaps.swap(bl);
le.snaps.reassign_to_mempool(mempool::mempool_osd_pglog);
}
if (seed == 0) {
// legacy
bufferlist bl;
- ::encode(hdrbl, bl);
+ encode(hdrbl, bl);
oh << bl;
} else {
oh << hdrbl;
value_sum += iter->value().length();
- ::encode(iter->key(), bl);
- ::encode(iter->value(), bl);
+ encode(iter->key(), bl);
+ encode(iter->value(), bl);
oh << bl;
bl.clear();
}
<< ", pinfo.last_backfill "
<< pinfo.last_backfill << ")" << dendl;
ObjectStore::Transaction t;
- ::encode(t, wr->get_data());
+ encode(t, wr->get_data());
} else {
- ::encode(op_t, wr->get_data());
+ encode(op_t, wr->get_data());
wr->get_header().data_off = op_t.get_data_alignment();
}
- ::encode(log_entries, wr->logbl);
+ encode(log_entries, wr->logbl);
if (pinfo.is_incomplete())
wr->pg_stats = pinfo.stats; // reflects backfill progress
vector<pg_log_entry_t> log;
bufferlist::iterator p = const_cast<bufferlist&>(m->get_data()).begin();
- ::decode(rm->opt, p);
+ decode(rm->opt, p);
if (m->new_temp_oid != hobject_t()) {
dout(20) << __func__ << " start tracking temp " << m->new_temp_oid << dendl;
}
p = const_cast<bufferlist&>(m->logbl).begin();
- ::decode(log, p);
+ decode(log, p);
rm->opt.set_fadvise_flag(CEPH_OSD_OP_FLAG_FADVISE_DONTNEED);
bool update_snaps = false;
object_info_t oi;
try {
bufferlist::iterator bliter = bv.begin();
- ::decode(oi, bliter);
+ decode(oi, bliter);
} catch (...) {
dout(0) << __func__ << ": bad object_info_t: " << recovery_info.soid << dendl;
return -EINVAL;
Mapping() : snap(0) {}
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(snap, bl);
- ::encode(hoid, bl);
+ encode(snap, bl);
+ encode(hoid, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(snap, bl);
- ::decode(hoid, bl);
+ decode(snap, bl);
+ decode(hoid, bl);
DECODE_FINISH(bl);
}
};
const pair<snapid_t, hobject_t> &in)
{
bufferlist bl;
- ::encode(Mapping(in), bl);
+ encode(Mapping(in), bl);
return make_pair(
to_raw_key(in),
bl);
Mapping map;
bufferlist bl(image.second);
bufferlist::iterator bp(bl.begin());
- ::decode(map, bp);
+ decode(map, bp);
return make_pair(map.snap, map.hoid);
}
void SnapMapper::object_snaps::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(oid, bl);
- ::encode(snaps, bl);
+ encode(oid, bl);
+ encode(snaps, bl);
ENCODE_FINISH(bl);
}
void SnapMapper::object_snaps::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(oid, bl);
- ::decode(snaps, bl);
+ decode(oid, bl);
+ decode(snaps, bl);
DECODE_FINISH(bl);
}
}
if (out) {
bufferlist::iterator bp = got.begin()->second.begin();
- ::decode(*out, bp);
+ decode(*out, bp);
dout(20) << __func__ << " " << oid << " " << out->snaps << dendl;
assert(!out->snaps.empty());
} else {
assert(check(oid));
map<string, bufferlist> to_set;
bufferlist bl;
- ::encode(in, bl);
+ encode(in, bl);
to_set[to_object_key(oid)] = bl;
dout(20) << __func__ << " " << oid << " " << in.snaps << dendl;
if (g_conf->subsys.should_gather(ceph_subsys_osd, 20)) {
if (watchers.empty() || timed_out) {
// prepare reply
bufferlist bl;
- ::encode(notify_replies, bl);
+ encode(notify_replies, bl);
list<pair<uint64_t,uint64_t> > missed;
for (set<WatchRef>::iterator p = watchers.begin(); p != watchers.end(); ++p) {
missed.push_back(make_pair((*p)->get_watcher_gid(),
(*p)->get_cookie()));
}
- ::encode(missed, bl);
+ encode(missed, bl);
bufferlist empty;
MWatchNotify *reply(new MWatchNotify(cookie, version, notify_id,
void pg_shard_t::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(osd, bl);
- ::encode(shard, bl);
+ encode(osd, bl);
+ encode(shard, bl);
ENCODE_FINISH(bl);
}
void pg_shard_t::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(osd, bl);
- ::decode(shard, bl);
+ decode(osd, bl);
+ decode(shard, bl);
DECODE_FINISH(bl);
}
assert(hash == -1 || key.empty());
__u8 encode_compat = 3;
ENCODE_START(6, encode_compat, bl);
- ::encode(pool, bl);
+ encode(pool, bl);
int32_t preferred = -1; // tell old code there is no preferred osd (-1).
- ::encode(preferred, bl);
- ::encode(key, bl);
- ::encode(nspace, bl);
- ::encode(hash, bl);
+ encode(preferred, bl);
+ encode(key, bl);
+ encode(nspace, bl);
+ encode(hash, bl);
if (hash != -1)
encode_compat = MAX(encode_compat, 6); // need to interpret the hash
ENCODE_FINISH_NEW_COMPAT(bl, encode_compat);
DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, p);
if (struct_v < 2) {
int32_t op;
- ::decode(op, p);
+ decode(op, p);
pool = op;
int16_t pref;
- ::decode(pref, p);
+ decode(pref, p);
} else {
- ::decode(pool, p);
+ decode(pool, p);
int32_t preferred;
- ::decode(preferred, p);
+ decode(preferred, p);
}
- ::decode(key, p);
+ decode(key, p);
if (struct_v >= 5)
- ::decode(nspace, p);
+ decode(nspace, p);
if (struct_v >= 6)
- ::decode(hash, p);
+ decode(hash, p);
else
hash = -1;
DECODE_FINISH(p);
void request_redirect_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(redirect_locator, bl);
- ::encode(redirect_object, bl);
- ::encode(osd_instructions, bl);
+ encode(redirect_locator, bl);
+ encode(redirect_object, bl);
+ encode(osd_instructions, bl);
ENCODE_FINISH(bl);
}
void request_redirect_t::decode(bufferlist::iterator& bl)
{
DECODE_START(1, bl);
- ::decode(redirect_locator, bl);
- ::decode(redirect_object, bl);
- ::decode(osd_instructions, bl);
+ decode(redirect_locator, bl);
+ decode(redirect_object, bl);
+ decode(osd_instructions, bl);
DECODE_FINISH(bl);
}
void objectstore_perf_stat_t::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(os_commit_latency, bl);
- ::encode(os_apply_latency, bl);
+ encode(os_commit_latency, bl);
+ encode(os_apply_latency, bl);
ENCODE_FINISH(bl);
}
void objectstore_perf_stat_t::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(os_commit_latency, bl);
- ::decode(os_apply_latency, bl);
+ decode(os_commit_latency, bl);
+ decode(os_apply_latency, bl);
DECODE_FINISH(bl);
}
void osd_stat_t::encode(bufferlist &bl) const
{
ENCODE_START(7, 2, bl);
- ::encode(kb, bl);
- ::encode(kb_used, bl);
- ::encode(kb_avail, bl);
- ::encode(snap_trim_queue_len, bl);
- ::encode(num_snap_trimming, bl);
- ::encode(hb_peers, bl);
- ::encode((uint32_t)0, bl);
- ::encode(op_queue_age_hist, bl);
- ::encode(os_perf_stat, bl);
- ::encode(up_from, bl);
- ::encode(seq, bl);
- ::encode(num_pgs, bl);
+ encode(kb, bl);
+ encode(kb_used, bl);
+ encode(kb_avail, bl);
+ encode(snap_trim_queue_len, bl);
+ encode(num_snap_trimming, bl);
+ encode(hb_peers, bl);
+ encode((uint32_t)0, bl);
+ encode(op_queue_age_hist, bl);
+ encode(os_perf_stat, bl);
+ encode(up_from, bl);
+ encode(seq, bl);
+ encode(num_pgs, bl);
ENCODE_FINISH(bl);
}
void osd_stat_t::decode(bufferlist::iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 2, 2, bl);
- ::decode(kb, bl);
- ::decode(kb_used, bl);
- ::decode(kb_avail, bl);
- ::decode(snap_trim_queue_len, bl);
- ::decode(num_snap_trimming, bl);
- ::decode(hb_peers, bl);
+ decode(kb, bl);
+ decode(kb_used, bl);
+ decode(kb_avail, bl);
+ decode(snap_trim_queue_len, bl);
+ decode(num_snap_trimming, bl);
+ decode(hb_peers, bl);
vector<int> num_hb_out;
- ::decode(num_hb_out, bl);
+ decode(num_hb_out, bl);
if (struct_v >= 3)
- ::decode(op_queue_age_hist, bl);
+ decode(op_queue_age_hist, bl);
if (struct_v >= 4)
- ::decode(os_perf_stat, bl);
+ decode(os_perf_stat, bl);
if (struct_v >= 6) {
- ::decode(up_from, bl);
- ::decode(seq, bl);
+ decode(up_from, bl);
+ decode(seq, bl);
}
if (struct_v >= 7) {
- ::decode(num_pgs, bl);
+ decode(num_pgs, bl);
}
DECODE_FINISH(bl);
}
void coll_t::encode(bufferlist& bl) const
{
+ using ceph::encode;
// when changing this, remember to update encoded_size() too.
if (is_temp()) {
// can't express this as v2...
__u8 struct_v = 3;
- ::encode(struct_v, bl);
- ::encode(to_str(), bl);
+ encode(struct_v, bl);
+ encode(to_str(), bl);
} else {
__u8 struct_v = 2;
- ::encode(struct_v, bl);
- ::encode((__u8)type, bl);
- ::encode(pgid, bl);
+ encode(struct_v, bl);
+ encode((__u8)type, bl);
+ encode(pgid, bl);
snapid_t snap = CEPH_NOSNAP;
- ::encode(snap, bl);
+ encode(snap, bl);
}
}
void coll_t::decode(bufferlist::iterator& bl)
{
+ using ceph::decode;
__u8 struct_v;
- ::decode(struct_v, bl);
+ decode(struct_v, bl);
switch (struct_v) {
case 1:
{
snapid_t snap;
- ::decode(pgid, bl);
- ::decode(snap, bl);
+ decode(pgid, bl);
+ decode(snap, bl);
// infer the type
if (pgid == spg_t() && snap == 0) {
{
__u8 _type;
snapid_t snap;
- ::decode(_type, bl);
- ::decode(pgid, bl);
- ::decode(snap, bl);
+ decode(_type, bl);
+ decode(pgid, bl);
+ decode(snap, bl);
type = (type_t)_type;
removal_seq = 0;
}
case 3:
{
string str;
- ::decode(str, bl);
+ decode(str, bl);
bool ok = parse(str);
if (!ok)
throw std::domain_error(std::string("unable to parse pg ") + str);
void pool_snap_info_t::encode(bufferlist& bl, uint64_t features) const
{
+ using ceph::encode;
if ((features & CEPH_FEATURE_PGPOOL3) == 0) {
__u8 struct_v = 1;
- ::encode(struct_v, bl);
- ::encode(snapid, bl);
- ::encode(stamp, bl);
- ::encode(name, bl);
+ encode(struct_v, bl);
+ encode(snapid, bl);
+ encode(stamp, bl);
+ encode(name, bl);
return;
}
ENCODE_START(2, 2, bl);
- ::encode(snapid, bl);
- ::encode(stamp, bl);
- ::encode(name, bl);
+ encode(snapid, bl);
+ encode(stamp, bl);
+ encode(name, bl);
ENCODE_FINISH(bl);
}
void pool_snap_info_t::decode(bufferlist::iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
- ::decode(snapid, bl);
- ::decode(stamp, bl);
- ::decode(name, bl);
+ decode(snapid, bl);
+ decode(stamp, bl);
+ decode(name, bl);
DECODE_FINISH(bl);
}
explicit pool_opts_encoder_t(bufferlist& bl_) : bl(bl_) {}
void operator()(std::string s) const {
- ::encode(static_cast<int32_t>(pool_opts_t::STR), bl);
- ::encode(s, bl);
+ encode(static_cast<int32_t>(pool_opts_t::STR), bl);
+ encode(s, bl);
}
void operator()(int i) const {
- ::encode(static_cast<int32_t>(pool_opts_t::INT), bl);
- ::encode(i, bl);
+ encode(static_cast<int32_t>(pool_opts_t::INT), bl);
+ encode(i, bl);
}
void operator()(double d) const {
- ::encode(static_cast<int32_t>(pool_opts_t::DOUBLE), bl);
- ::encode(d, bl);
+ encode(static_cast<int32_t>(pool_opts_t::DOUBLE), bl);
+ encode(d, bl);
}
private:
void pool_opts_t::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
uint32_t n = static_cast<uint32_t>(opts.size());
- ::encode(n, bl);
+ encode(n, bl);
for (opts_t::const_iterator i = opts.begin(); i != opts.end(); ++i) {
- ::encode(static_cast<int32_t>(i->first), bl);
+ encode(static_cast<int32_t>(i->first), bl);
boost::apply_visitor(pool_opts_encoder_t(bl), i->second);
}
ENCODE_FINISH(bl);
void pool_opts_t::decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
__u32 n;
- ::decode(n, bl);
+ decode(n, bl);
opts.clear();
while (n--) {
int32_t k, t;
- ::decode(k, bl);
- ::decode(t, bl);
+ decode(k, bl);
+ decode(t, bl);
if (t == STR) {
std::string s;
- ::decode(s, bl);
+ decode(s, bl);
opts[static_cast<key_t>(k)] = s;
} else if (t == INT) {
int i;
- ::decode(i, bl);
+ decode(i, bl);
opts[static_cast<key_t>(k)] = i;
} else if (t == DOUBLE) {
double d;
- ::decode(d, bl);
+ decode(d, bl);
opts[static_cast<key_t>(k)] = d;
} else {
assert(!"invalid type");
void pg_pool_t::encode(bufferlist& bl, uint64_t features) const
{
+ using ceph::encode;
if ((features & CEPH_FEATURE_PGPOOL3) == 0) {
// this encoding matches the old struct ceph_pg_pool
__u8 struct_v = 2;
- ::encode(struct_v, bl);
- ::encode(type, bl);
- ::encode(size, bl);
- ::encode(crush_rule, bl);
- ::encode(object_hash, bl);
- ::encode(pg_num, bl);
- ::encode(pgp_num, bl);
+ encode(struct_v, bl);
+ encode(type, bl);
+ encode(size, bl);
+ encode(crush_rule, bl);
+ encode(object_hash, bl);
+ encode(pg_num, bl);
+ encode(pgp_num, bl);
__u32 lpg_num = 0, lpgp_num = 0; // tell old code that there are no localized pgs.
- ::encode(lpg_num, bl);
- ::encode(lpgp_num, bl);
- ::encode(last_change, bl);
- ::encode(snap_seq, bl);
- ::encode(snap_epoch, bl);
+ encode(lpg_num, bl);
+ encode(lpgp_num, bl);
+ encode(last_change, bl);
+ encode(snap_seq, bl);
+ encode(snap_epoch, bl);
__u32 n = snaps.size();
- ::encode(n, bl);
+ encode(n, bl);
n = removed_snaps.num_intervals();
- ::encode(n, bl);
+ encode(n, bl);
- ::encode(auid, bl);
+ encode(auid, bl);
- ::encode_nohead(snaps, bl, features);
- ::encode_nohead(removed_snaps, bl);
+ encode_nohead(snaps, bl, features);
+ encode_nohead(removed_snaps, bl);
return;
}
if ((features & CEPH_FEATURE_OSDENC) == 0) {
__u8 struct_v = 4;
- ::encode(struct_v, bl);
- ::encode(type, bl);
- ::encode(size, bl);
- ::encode(crush_rule, bl);
- ::encode(object_hash, bl);
- ::encode(pg_num, bl);
- ::encode(pgp_num, bl);
+ encode(struct_v, bl);
+ encode(type, bl);
+ encode(size, bl);
+ encode(crush_rule, bl);
+ encode(object_hash, bl);
+ encode(pg_num, bl);
+ encode(pgp_num, bl);
__u32 lpg_num = 0, lpgp_num = 0; // tell old code that there are no localized pgs.
- ::encode(lpg_num, bl);
- ::encode(lpgp_num, bl);
- ::encode(last_change, bl);
- ::encode(snap_seq, bl);
- ::encode(snap_epoch, bl);
- ::encode(snaps, bl, features);
- ::encode(removed_snaps, bl);
- ::encode(auid, bl);
- ::encode(flags, bl);
- ::encode((uint32_t)0, bl); // crash_replay_interval
+ encode(lpg_num, bl);
+ encode(lpgp_num, bl);
+ encode(last_change, bl);
+ encode(snap_seq, bl);
+ encode(snap_epoch, bl);
+ encode(snaps, bl, features);
+ encode(removed_snaps, bl);
+ encode(auid, bl);
+ encode(flags, bl);
+ encode((uint32_t)0, bl); // crash_replay_interval
return;
}
// they are decodable without the feature), so let's be pendantic
// about it.
ENCODE_START(14, 5, bl);
- ::encode(type, bl);
- ::encode(size, bl);
- ::encode(crush_rule, bl);
- ::encode(object_hash, bl);
- ::encode(pg_num, bl);
- ::encode(pgp_num, bl);
+ encode(type, bl);
+ encode(size, bl);
+ encode(crush_rule, bl);
+ encode(object_hash, bl);
+ encode(pg_num, bl);
+ encode(pgp_num, bl);
__u32 lpg_num = 0, lpgp_num = 0; // tell old code that there are no localized pgs.
- ::encode(lpg_num, bl);
- ::encode(lpgp_num, bl);
- ::encode(last_change, bl);
- ::encode(snap_seq, bl);
- ::encode(snap_epoch, bl);
- ::encode(snaps, bl, features);
- ::encode(removed_snaps, bl);
- ::encode(auid, bl);
- ::encode(flags, bl);
- ::encode((uint32_t)0, bl); // crash_replay_interval
- ::encode(min_size, bl);
- ::encode(quota_max_bytes, bl);
- ::encode(quota_max_objects, bl);
- ::encode(tiers, bl);
- ::encode(tier_of, bl);
+ encode(lpg_num, bl);
+ encode(lpgp_num, bl);
+ encode(last_change, bl);
+ encode(snap_seq, bl);
+ encode(snap_epoch, bl);
+ encode(snaps, bl, features);
+ encode(removed_snaps, bl);
+ encode(auid, bl);
+ encode(flags, bl);
+ encode((uint32_t)0, bl); // crash_replay_interval
+ encode(min_size, bl);
+ encode(quota_max_bytes, bl);
+ encode(quota_max_objects, bl);
+ encode(tiers, bl);
+ encode(tier_of, bl);
__u8 c = cache_mode;
- ::encode(c, bl);
- ::encode(read_tier, bl);
- ::encode(write_tier, bl);
- ::encode(properties, bl);
- ::encode(hit_set_params, bl);
- ::encode(hit_set_period, bl);
- ::encode(hit_set_count, bl);
- ::encode(stripe_width, bl);
- ::encode(target_max_bytes, bl);
- ::encode(target_max_objects, bl);
- ::encode(cache_target_dirty_ratio_micro, bl);
- ::encode(cache_target_full_ratio_micro, bl);
- ::encode(cache_min_flush_age, bl);
- ::encode(cache_min_evict_age, bl);
- ::encode(erasure_code_profile, bl);
+ encode(c, bl);
+ encode(read_tier, bl);
+ encode(write_tier, bl);
+ encode(properties, bl);
+ encode(hit_set_params, bl);
+ encode(hit_set_period, bl);
+ encode(hit_set_count, bl);
+ encode(stripe_width, bl);
+ encode(target_max_bytes, bl);
+ encode(target_max_objects, bl);
+ encode(cache_target_dirty_ratio_micro, bl);
+ encode(cache_target_full_ratio_micro, bl);
+ encode(cache_min_flush_age, bl);
+ encode(cache_min_evict_age, bl);
+ encode(erasure_code_profile, bl);
ENCODE_FINISH(bl);
return;
}
}
ENCODE_START(v, 5, bl);
- ::encode(type, bl);
- ::encode(size, bl);
- ::encode(crush_rule, bl);
- ::encode(object_hash, bl);
- ::encode(pg_num, bl);
- ::encode(pgp_num, bl);
+ encode(type, bl);
+ encode(size, bl);
+ encode(crush_rule, bl);
+ encode(object_hash, bl);
+ encode(pg_num, bl);
+ encode(pgp_num, bl);
__u32 lpg_num = 0, lpgp_num = 0; // tell old code that there are no localized pgs.
- ::encode(lpg_num, bl);
- ::encode(lpgp_num, bl);
- ::encode(last_change, bl);
- ::encode(snap_seq, bl);
- ::encode(snap_epoch, bl);
- ::encode(snaps, bl, features);
- ::encode(removed_snaps, bl);
- ::encode(auid, bl);
+ encode(lpg_num, bl);
+ encode(lpgp_num, bl);
+ encode(last_change, bl);
+ encode(snap_seq, bl);
+ encode(snap_epoch, bl);
+ encode(snaps, bl, features);
+ encode(removed_snaps, bl);
+ encode(auid, bl);
if (v >= 27) {
- ::encode(flags, bl);
+ encode(flags, bl);
} else {
auto tmp = flags;
tmp &= ~(FLAG_SELFMANAGED_SNAPS | FLAG_POOL_SNAPS);
- ::encode(tmp, bl);
- }
- ::encode((uint32_t)0, bl); // crash_replay_interval
- ::encode(min_size, bl);
- ::encode(quota_max_bytes, bl);
- ::encode(quota_max_objects, bl);
- ::encode(tiers, bl);
- ::encode(tier_of, bl);
+ encode(tmp, bl);
+ }
+ encode((uint32_t)0, bl); // crash_replay_interval
+ encode(min_size, bl);
+ encode(quota_max_bytes, bl);
+ encode(quota_max_objects, bl);
+ encode(tiers, bl);
+ encode(tier_of, bl);
__u8 c = cache_mode;
- ::encode(c, bl);
- ::encode(read_tier, bl);
- ::encode(write_tier, bl);
- ::encode(properties, bl);
- ::encode(hit_set_params, bl);
- ::encode(hit_set_period, bl);
- ::encode(hit_set_count, bl);
- ::encode(stripe_width, bl);
- ::encode(target_max_bytes, bl);
- ::encode(target_max_objects, bl);
- ::encode(cache_target_dirty_ratio_micro, bl);
- ::encode(cache_target_full_ratio_micro, bl);
- ::encode(cache_min_flush_age, bl);
- ::encode(cache_min_evict_age, bl);
- ::encode(erasure_code_profile, bl);
- ::encode(last_force_op_resend_preluminous, bl);
- ::encode(min_read_recency_for_promote, bl);
- ::encode(expected_num_objects, bl);
+ encode(c, bl);
+ encode(read_tier, bl);
+ encode(write_tier, bl);
+ encode(properties, bl);
+ encode(hit_set_params, bl);
+ encode(hit_set_period, bl);
+ encode(hit_set_count, bl);
+ encode(stripe_width, bl);
+ encode(target_max_bytes, bl);
+ encode(target_max_objects, bl);
+ encode(cache_target_dirty_ratio_micro, bl);
+ encode(cache_target_full_ratio_micro, bl);
+ encode(cache_min_flush_age, bl);
+ encode(cache_min_evict_age, bl);
+ encode(erasure_code_profile, bl);
+ encode(last_force_op_resend_preluminous, bl);
+ encode(min_read_recency_for_promote, bl);
+ encode(expected_num_objects, bl);
if (v >= 19) {
- ::encode(cache_target_dirty_high_ratio_micro, bl);
+ encode(cache_target_dirty_high_ratio_micro, bl);
}
if (v >= 20) {
- ::encode(min_write_recency_for_promote, bl);
+ encode(min_write_recency_for_promote, bl);
}
if (v >= 21) {
- ::encode(use_gmt_hitset, bl);
+ encode(use_gmt_hitset, bl);
}
if (v >= 22) {
- ::encode(fast_read, bl);
+ encode(fast_read, bl);
}
if (v >= 23) {
- ::encode(hit_set_grade_decay_rate, bl);
- ::encode(hit_set_search_last_n, bl);
+ encode(hit_set_grade_decay_rate, bl);
+ encode(hit_set_search_last_n, bl);
}
if (v >= 24) {
- ::encode(opts, bl);
+ encode(opts, bl);
}
if (v >= 25) {
- ::encode(last_force_op_resend, bl);
+ encode(last_force_op_resend, bl);
}
if (v >= 26) {
- ::encode(application_metadata, bl);
+ encode(application_metadata, bl);
}
ENCODE_FINISH(bl);
}
void pg_pool_t::decode(bufferlist::iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(26, 5, 5, bl);
- ::decode(type, bl);
- ::decode(size, bl);
- ::decode(crush_rule, bl);
- ::decode(object_hash, bl);
- ::decode(pg_num, bl);
- ::decode(pgp_num, bl);
+ decode(type, bl);
+ decode(size, bl);
+ decode(crush_rule, bl);
+ decode(object_hash, bl);
+ decode(pg_num, bl);
+ decode(pgp_num, bl);
{
__u32 lpg_num, lpgp_num;
- ::decode(lpg_num, bl);
- ::decode(lpgp_num, bl);
+ decode(lpg_num, bl);
+ decode(lpgp_num, bl);
}
- ::decode(last_change, bl);
- ::decode(snap_seq, bl);
- ::decode(snap_epoch, bl);
+ decode(last_change, bl);
+ decode(snap_seq, bl);
+ decode(snap_epoch, bl);
if (struct_v >= 3) {
- ::decode(snaps, bl);
- ::decode(removed_snaps, bl);
- ::decode(auid, bl);
+ decode(snaps, bl);
+ decode(removed_snaps, bl);
+ decode(auid, bl);
} else {
__u32 n, m;
- ::decode(n, bl);
- ::decode(m, bl);
- ::decode(auid, bl);
- ::decode_nohead(n, snaps, bl);
- ::decode_nohead(m, removed_snaps, bl);
+ decode(n, bl);
+ decode(m, bl);
+ decode(auid, bl);
+ decode_nohead(n, snaps, bl);
+ decode_nohead(m, removed_snaps, bl);
}
if (struct_v >= 4) {
- ::decode(flags, bl);
+ decode(flags, bl);
uint32_t crash_replay_interval;
- ::decode(crash_replay_interval, bl);
+ decode(crash_replay_interval, bl);
} else {
flags = 0;
}
}
}
if (struct_v >= 7) {
- ::decode(min_size, bl);
+ decode(min_size, bl);
} else {
min_size = size - size/2;
}
if (struct_v >= 8) {
- ::decode(quota_max_bytes, bl);
- ::decode(quota_max_objects, bl);
+ decode(quota_max_bytes, bl);
+ decode(quota_max_objects, bl);
}
if (struct_v >= 9) {
- ::decode(tiers, bl);
- ::decode(tier_of, bl);
+ decode(tiers, bl);
+ decode(tier_of, bl);
__u8 v;
- ::decode(v, bl);
+ decode(v, bl);
cache_mode = (cache_mode_t)v;
- ::decode(read_tier, bl);
- ::decode(write_tier, bl);
+ decode(read_tier, bl);
+ decode(write_tier, bl);
}
if (struct_v >= 10) {
- ::decode(properties, bl);
+ decode(properties, bl);
}
if (struct_v >= 11) {
- ::decode(hit_set_params, bl);
- ::decode(hit_set_period, bl);
- ::decode(hit_set_count, bl);
+ decode(hit_set_params, bl);
+ decode(hit_set_period, bl);
+ decode(hit_set_count, bl);
} else {
pg_pool_t def;
hit_set_period = def.hit_set_period;
hit_set_count = def.hit_set_count;
}
if (struct_v >= 12) {
- ::decode(stripe_width, bl);
+ decode(stripe_width, bl);
} else {
set_stripe_width(0);
}
if (struct_v >= 13) {
- ::decode(target_max_bytes, bl);
- ::decode(target_max_objects, bl);
- ::decode(cache_target_dirty_ratio_micro, bl);
- ::decode(cache_target_full_ratio_micro, bl);
- ::decode(cache_min_flush_age, bl);
- ::decode(cache_min_evict_age, bl);
+ decode(target_max_bytes, bl);
+ decode(target_max_objects, bl);
+ decode(cache_target_dirty_ratio_micro, bl);
+ decode(cache_target_full_ratio_micro, bl);
+ decode(cache_min_flush_age, bl);
+ decode(cache_min_evict_age, bl);
} else {
target_max_bytes = 0;
target_max_objects = 0;
cache_min_evict_age = 0;
}
if (struct_v >= 14) {
- ::decode(erasure_code_profile, bl);
+ decode(erasure_code_profile, bl);
}
if (struct_v >= 15) {
- ::decode(last_force_op_resend_preluminous, bl);
+ decode(last_force_op_resend_preluminous, bl);
} else {
last_force_op_resend_preluminous = 0;
}
if (struct_v >= 16) {
- ::decode(min_read_recency_for_promote, bl);
+ decode(min_read_recency_for_promote, bl);
} else {
min_read_recency_for_promote = 1;
}
if (struct_v >= 17) {
- ::decode(expected_num_objects, bl);
+ decode(expected_num_objects, bl);
} else {
expected_num_objects = 0;
}
if (struct_v >= 19) {
- ::decode(cache_target_dirty_high_ratio_micro, bl);
+ decode(cache_target_dirty_high_ratio_micro, bl);
} else {
cache_target_dirty_high_ratio_micro = cache_target_dirty_ratio_micro;
}
if (struct_v >= 20) {
- ::decode(min_write_recency_for_promote, bl);
+ decode(min_write_recency_for_promote, bl);
} else {
min_write_recency_for_promote = 1;
}
if (struct_v >= 21) {
- ::decode(use_gmt_hitset, bl);
+ decode(use_gmt_hitset, bl);
} else {
use_gmt_hitset = false;
}
if (struct_v >= 22) {
- ::decode(fast_read, bl);
+ decode(fast_read, bl);
} else {
fast_read = false;
}
if (struct_v >= 23) {
- ::decode(hit_set_grade_decay_rate, bl);
- ::decode(hit_set_search_last_n, bl);
+ decode(hit_set_grade_decay_rate, bl);
+ decode(hit_set_search_last_n, bl);
} else {
hit_set_grade_decay_rate = 0;
hit_set_search_last_n = 1;
}
if (struct_v >= 24) {
- ::decode(opts, bl);
+ decode(opts, bl);
}
if (struct_v >= 25) {
- ::decode(last_force_op_resend, bl);
+ decode(last_force_op_resend, bl);
} else {
last_force_op_resend = last_force_op_resend_preluminous;
}
if (struct_v >= 26) {
- ::decode(application_metadata, bl);
+ decode(application_metadata, bl);
}
DECODE_FINISH(bl);
calc_pg_masks();
#if defined(CEPH_LITTLE_ENDIAN)
bl.append((char *)(&num_bytes), sizeof(object_stat_sum_t));
#else
- ::encode(num_bytes, bl);
- ::encode(num_objects, bl);
- ::encode(num_object_clones, bl);
- ::encode(num_object_copies, bl);
- ::encode(num_objects_missing_on_primary, bl);
- ::encode(num_objects_degraded, bl);
- ::encode(num_objects_unfound, bl);
- ::encode(num_rd, bl);
- ::encode(num_rd_kb, bl);
- ::encode(num_wr, bl);
- ::encode(num_wr_kb, bl);
- ::encode(num_scrub_errors, bl);
- ::encode(num_objects_recovered, bl);
- ::encode(num_bytes_recovered, bl);
- ::encode(num_keys_recovered, bl);
- ::encode(num_shallow_scrub_errors, bl);
- ::encode(num_deep_scrub_errors, bl);
- ::encode(num_objects_dirty, bl);
- ::encode(num_whiteouts, bl);
- ::encode(num_objects_omap, bl);
- ::encode(num_objects_hit_set_archive, bl);
- ::encode(num_objects_misplaced, bl);
- ::encode(num_bytes_hit_set_archive, bl);
- ::encode(num_flush, bl);
- ::encode(num_flush_kb, bl);
- ::encode(num_evict, bl);
- ::encode(num_evict_kb, bl);
- ::encode(num_promote, bl);
- ::encode(num_flush_mode_high, bl);
- ::encode(num_flush_mode_low, bl);
- ::encode(num_evict_mode_some, bl);
- ::encode(num_evict_mode_full, bl);
- ::encode(num_objects_pinned, bl);
- ::encode(num_objects_missing, bl);
- ::encode(num_legacy_snapsets, bl);
- ::encode(num_large_omap_objects, bl);
+ encode(num_bytes, bl);
+ encode(num_objects, bl);
+ encode(num_object_clones, bl);
+ encode(num_object_copies, bl);
+ encode(num_objects_missing_on_primary, bl);
+ encode(num_objects_degraded, bl);
+ encode(num_objects_unfound, bl);
+ encode(num_rd, bl);
+ encode(num_rd_kb, bl);
+ encode(num_wr, bl);
+ encode(num_wr_kb, bl);
+ encode(num_scrub_errors, bl);
+ encode(num_objects_recovered, bl);
+ encode(num_bytes_recovered, bl);
+ encode(num_keys_recovered, bl);
+ encode(num_shallow_scrub_errors, bl);
+ encode(num_deep_scrub_errors, bl);
+ encode(num_objects_dirty, bl);
+ encode(num_whiteouts, bl);
+ encode(num_objects_omap, bl);
+ encode(num_objects_hit_set_archive, bl);
+ encode(num_objects_misplaced, bl);
+ encode(num_bytes_hit_set_archive, bl);
+ encode(num_flush, bl);
+ encode(num_flush_kb, bl);
+ encode(num_evict, bl);
+ encode(num_evict_kb, bl);
+ encode(num_promote, bl);
+ encode(num_flush_mode_high, bl);
+ encode(num_flush_mode_low, bl);
+ encode(num_evict_mode_some, bl);
+ encode(num_evict_mode_full, bl);
+ encode(num_objects_pinned, bl);
+ encode(num_objects_missing, bl);
+ encode(num_legacy_snapsets, bl);
+ encode(num_large_omap_objects, bl);
#endif
ENCODE_FINISH(bl);
}
}
#endif
if (!decode_finish) {
- ::decode(num_bytes, bl);
- ::decode(num_objects, bl);
- ::decode(num_object_clones, bl);
- ::decode(num_object_copies, bl);
- ::decode(num_objects_missing_on_primary, bl);
- ::decode(num_objects_degraded, bl);
- ::decode(num_objects_unfound, bl);
- ::decode(num_rd, bl);
- ::decode(num_rd_kb, bl);
- ::decode(num_wr, bl);
- ::decode(num_wr_kb, bl);
- ::decode(num_scrub_errors, bl);
- ::decode(num_objects_recovered, bl);
- ::decode(num_bytes_recovered, bl);
- ::decode(num_keys_recovered, bl);
- ::decode(num_shallow_scrub_errors, bl);
- ::decode(num_deep_scrub_errors, bl);
- ::decode(num_objects_dirty, bl);
- ::decode(num_whiteouts, bl);
- ::decode(num_objects_omap, bl);
- ::decode(num_objects_hit_set_archive, bl);
- ::decode(num_objects_misplaced, bl);
- ::decode(num_bytes_hit_set_archive, bl);
- ::decode(num_flush, bl);
- ::decode(num_flush_kb, bl);
- ::decode(num_evict, bl);
- ::decode(num_evict_kb, bl);
- ::decode(num_promote, bl);
- ::decode(num_flush_mode_high, bl);
- ::decode(num_flush_mode_low, bl);
- ::decode(num_evict_mode_some, bl);
- ::decode(num_evict_mode_full, bl);
- ::decode(num_objects_pinned, bl);
- ::decode(num_objects_missing, bl);
+ decode(num_bytes, bl);
+ decode(num_objects, bl);
+ decode(num_object_clones, bl);
+ decode(num_object_copies, bl);
+ decode(num_objects_missing_on_primary, bl);
+ decode(num_objects_degraded, bl);
+ decode(num_objects_unfound, bl);
+ decode(num_rd, bl);
+ decode(num_rd_kb, bl);
+ decode(num_wr, bl);
+ decode(num_wr_kb, bl);
+ decode(num_scrub_errors, bl);
+ decode(num_objects_recovered, bl);
+ decode(num_bytes_recovered, bl);
+ decode(num_keys_recovered, bl);
+ decode(num_shallow_scrub_errors, bl);
+ decode(num_deep_scrub_errors, bl);
+ decode(num_objects_dirty, bl);
+ decode(num_whiteouts, bl);
+ decode(num_objects_omap, bl);
+ decode(num_objects_hit_set_archive, bl);
+ decode(num_objects_misplaced, bl);
+ decode(num_bytes_hit_set_archive, bl);
+ decode(num_flush, bl);
+ decode(num_flush_kb, bl);
+ decode(num_evict, bl);
+ decode(num_evict_kb, bl);
+ decode(num_promote, bl);
+ decode(num_flush_mode_high, bl);
+ decode(num_flush_mode_low, bl);
+ decode(num_evict_mode_some, bl);
+ decode(num_evict_mode_full, bl);
+ decode(num_objects_pinned, bl);
+ decode(num_objects_missing, bl);
if (struct_v >= 16) {
- ::decode(num_legacy_snapsets, bl);
+ decode(num_legacy_snapsets, bl);
} else {
num_legacy_snapsets = num_object_clones; // upper bound
}
if (struct_v >= 17) {
- ::decode(num_large_omap_objects, bl);
+ decode(num_large_omap_objects, bl);
}
}
DECODE_FINISH(bl);
void object_stat_collection_t::encode(bufferlist& bl) const
{
ENCODE_START(2, 2, bl);
- ::encode(sum, bl);
- ::encode((__u32)0, bl);
+ encode(sum, bl);
+ encode((__u32)0, bl);
ENCODE_FINISH(bl);
}
void object_stat_collection_t::decode(bufferlist::iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
- ::decode(sum, bl);
+ decode(sum, bl);
{
map<string,object_stat_sum_t> cat_sum;
- ::decode(cat_sum, bl);
+ decode(cat_sum, bl);
}
DECODE_FINISH(bl);
}
void pg_stat_t::encode(bufferlist &bl) const
{
ENCODE_START(25, 22, bl);
- ::encode(version, bl);
- ::encode(reported_seq, bl);
- ::encode(reported_epoch, bl);
- ::encode((__u32)state, bl); // for older peers
- ::encode(log_start, bl);
- ::encode(ondisk_log_start, bl);
- ::encode(created, bl);
- ::encode(last_epoch_clean, bl);
- ::encode(parent, bl);
- ::encode(parent_split_bits, bl);
- ::encode(last_scrub, bl);
- ::encode(last_scrub_stamp, bl);
- ::encode(stats, bl);
- ::encode(log_size, bl);
- ::encode(ondisk_log_size, bl);
- ::encode(up, bl);
- ::encode(acting, bl);
- ::encode(last_fresh, bl);
- ::encode(last_change, bl);
- ::encode(last_active, bl);
- ::encode(last_clean, bl);
- ::encode(last_unstale, bl);
- ::encode(mapping_epoch, bl);
- ::encode(last_deep_scrub, bl);
- ::encode(last_deep_scrub_stamp, bl);
- ::encode(stats_invalid, bl);
- ::encode(last_clean_scrub_stamp, bl);
- ::encode(last_became_active, bl);
- ::encode(dirty_stats_invalid, bl);
- ::encode(up_primary, bl);
- ::encode(acting_primary, bl);
- ::encode(omap_stats_invalid, bl);
- ::encode(hitset_stats_invalid, bl);
- ::encode(blocked_by, bl);
- ::encode(last_undegraded, bl);
- ::encode(last_fullsized, bl);
- ::encode(hitset_bytes_stats_invalid, bl);
- ::encode(last_peered, bl);
- ::encode(last_became_peered, bl);
- ::encode(pin_stats_invalid, bl);
- ::encode(state, bl);
- ::encode(purged_snaps, bl);
- ::encode(snaptrimq_len, bl);
+ encode(version, bl);
+ encode(reported_seq, bl);
+ encode(reported_epoch, bl);
+ encode((__u32)state, bl); // for older peers
+ encode(log_start, bl);
+ encode(ondisk_log_start, bl);
+ encode(created, bl);
+ encode(last_epoch_clean, bl);
+ encode(parent, bl);
+ encode(parent_split_bits, bl);
+ encode(last_scrub, bl);
+ encode(last_scrub_stamp, bl);
+ encode(stats, bl);
+ encode(log_size, bl);
+ encode(ondisk_log_size, bl);
+ encode(up, bl);
+ encode(acting, bl);
+ encode(last_fresh, bl);
+ encode(last_change, bl);
+ encode(last_active, bl);
+ encode(last_clean, bl);
+ encode(last_unstale, bl);
+ encode(mapping_epoch, bl);
+ encode(last_deep_scrub, bl);
+ encode(last_deep_scrub_stamp, bl);
+ encode(stats_invalid, bl);
+ encode(last_clean_scrub_stamp, bl);
+ encode(last_became_active, bl);
+ encode(dirty_stats_invalid, bl);
+ encode(up_primary, bl);
+ encode(acting_primary, bl);
+ encode(omap_stats_invalid, bl);
+ encode(hitset_stats_invalid, bl);
+ encode(blocked_by, bl);
+ encode(last_undegraded, bl);
+ encode(last_fullsized, bl);
+ encode(hitset_bytes_stats_invalid, bl);
+ encode(last_peered, bl);
+ encode(last_became_peered, bl);
+ encode(pin_stats_invalid, bl);
+ encode(state, bl);
+ encode(purged_snaps, bl);
+ encode(snaptrimq_len, bl);
ENCODE_FINISH(bl);
}
bool tmp;
uint32_t old_state;
DECODE_START(24, bl);
- ::decode(version, bl);
- ::decode(reported_seq, bl);
- ::decode(reported_epoch, bl);
- ::decode(old_state, bl);
- ::decode(log_start, bl);
- ::decode(ondisk_log_start, bl);
- ::decode(created, bl);
- ::decode(last_epoch_clean, bl);
- ::decode(parent, bl);
- ::decode(parent_split_bits, bl);
- ::decode(last_scrub, bl);
- ::decode(last_scrub_stamp, bl);
- ::decode(stats, bl);
- ::decode(log_size, bl);
- ::decode(ondisk_log_size, bl);
- ::decode(up, bl);
- ::decode(acting, bl);
- ::decode(last_fresh, bl);
- ::decode(last_change, bl);
- ::decode(last_active, bl);
- ::decode(last_clean, bl);
- ::decode(last_unstale, bl);
- ::decode(mapping_epoch, bl);
- ::decode(last_deep_scrub, bl);
- ::decode(last_deep_scrub_stamp, bl);
- ::decode(tmp, bl);
+ decode(version, bl);
+ decode(reported_seq, bl);
+ decode(reported_epoch, bl);
+ decode(old_state, bl);
+ decode(log_start, bl);
+ decode(ondisk_log_start, bl);
+ decode(created, bl);
+ decode(last_epoch_clean, bl);
+ decode(parent, bl);
+ decode(parent_split_bits, bl);
+ decode(last_scrub, bl);
+ decode(last_scrub_stamp, bl);
+ decode(stats, bl);
+ decode(log_size, bl);
+ decode(ondisk_log_size, bl);
+ decode(up, bl);
+ decode(acting, bl);
+ decode(last_fresh, bl);
+ decode(last_change, bl);
+ decode(last_active, bl);
+ decode(last_clean, bl);
+ decode(last_unstale, bl);
+ decode(mapping_epoch, bl);
+ decode(last_deep_scrub, bl);
+ decode(last_deep_scrub_stamp, bl);
+ decode(tmp, bl);
stats_invalid = tmp;
- ::decode(last_clean_scrub_stamp, bl);
- ::decode(last_became_active, bl);
- ::decode(tmp, bl);
+ decode(last_clean_scrub_stamp, bl);
+ decode(last_became_active, bl);
+ decode(tmp, bl);
dirty_stats_invalid = tmp;
- ::decode(up_primary, bl);
- ::decode(acting_primary, bl);
- ::decode(tmp, bl);
+ decode(up_primary, bl);
+ decode(acting_primary, bl);
+ decode(tmp, bl);
omap_stats_invalid = tmp;
- ::decode(tmp, bl);
+ decode(tmp, bl);
hitset_stats_invalid = tmp;
- ::decode(blocked_by, bl);
- ::decode(last_undegraded, bl);
- ::decode(last_fullsized, bl);
- ::decode(tmp, bl);
+ decode(blocked_by, bl);
+ decode(last_undegraded, bl);
+ decode(last_fullsized, bl);
+ decode(tmp, bl);
hitset_bytes_stats_invalid = tmp;
- ::decode(last_peered, bl);
- ::decode(last_became_peered, bl);
- ::decode(tmp, bl);
+ decode(last_peered, bl);
+ decode(last_became_peered, bl);
+ decode(tmp, bl);
pin_stats_invalid = tmp;
if (struct_v >= 23) {
- ::decode(state, bl);
+ decode(state, bl);
} else {
state = old_state;
}
if (struct_v >= 24) {
- ::decode(purged_snaps, bl);
+ decode(purged_snaps, bl);
if (struct_v >= 25) {
- ::decode(snaptrimq_len, bl);
+ decode(snaptrimq_len, bl);
}
}
DECODE_FINISH(bl);
void pool_stat_t::encode(bufferlist &bl, uint64_t features) const
{
+ using ceph::encode;
if ((features & CEPH_FEATURE_OSDENC) == 0) {
__u8 v = 4;
- ::encode(v, bl);
- ::encode(stats, bl);
- ::encode(log_size, bl);
- ::encode(ondisk_log_size, bl);
+ encode(v, bl);
+ encode(stats, bl);
+ encode(log_size, bl);
+ encode(ondisk_log_size, bl);
return;
}
ENCODE_START(6, 5, bl);
- ::encode(stats, bl);
- ::encode(log_size, bl);
- ::encode(ondisk_log_size, bl);
- ::encode(up, bl);
- ::encode(acting, bl);
+ encode(stats, bl);
+ encode(log_size, bl);
+ encode(ondisk_log_size, bl);
+ encode(up, bl);
+ encode(acting, bl);
ENCODE_FINISH(bl);
}
{
DECODE_START_LEGACY_COMPAT_LEN(6, 5, 5, bl);
if (struct_v >= 4) {
- ::decode(stats, bl);
- ::decode(log_size, bl);
- ::decode(ondisk_log_size, bl);
+ decode(stats, bl);
+ decode(log_size, bl);
+ decode(ondisk_log_size, bl);
if (struct_v >= 6) {
- ::decode(up, bl);
- ::decode(acting, bl);
+ decode(up, bl);
+ decode(acting, bl);
} else {
up = 0;
acting = 0;
}
} else {
- ::decode(stats.sum.num_bytes, bl);
+ decode(stats.sum.num_bytes, bl);
uint64_t num_kb;
- ::decode(num_kb, bl);
- ::decode(stats.sum.num_objects, bl);
- ::decode(stats.sum.num_object_clones, bl);
- ::decode(stats.sum.num_object_copies, bl);
- ::decode(stats.sum.num_objects_missing_on_primary, bl);
- ::decode(stats.sum.num_objects_degraded, bl);
- ::decode(log_size, bl);
- ::decode(ondisk_log_size, bl);
+ decode(num_kb, bl);
+ decode(stats.sum.num_objects, bl);
+ decode(stats.sum.num_object_clones, bl);
+ decode(stats.sum.num_object_copies, bl);
+ decode(stats.sum.num_objects_missing_on_primary, bl);
+ decode(stats.sum.num_objects_degraded, bl);
+ decode(log_size, bl);
+ decode(ondisk_log_size, bl);
if (struct_v >= 2) {
- ::decode(stats.sum.num_rd, bl);
- ::decode(stats.sum.num_rd_kb, bl);
- ::decode(stats.sum.num_wr, bl);
- ::decode(stats.sum.num_wr_kb, bl);
+ decode(stats.sum.num_rd, bl);
+ decode(stats.sum.num_rd_kb, bl);
+ decode(stats.sum.num_wr, bl);
+ decode(stats.sum.num_wr_kb, bl);
}
if (struct_v >= 3) {
- ::decode(stats.sum.num_objects_unfound, bl);
+ decode(stats.sum.num_objects_unfound, bl);
}
}
DECODE_FINISH(bl);
void pg_history_t::encode(bufferlist &bl) const
{
ENCODE_START(9, 4, bl);
- ::encode(epoch_created, bl);
- ::encode(last_epoch_started, bl);
- ::encode(last_epoch_clean, bl);
- ::encode(last_epoch_split, bl);
- ::encode(same_interval_since, bl);
- ::encode(same_up_since, bl);
- ::encode(same_primary_since, bl);
- ::encode(last_scrub, bl);
- ::encode(last_scrub_stamp, bl);
- ::encode(last_deep_scrub, bl);
- ::encode(last_deep_scrub_stamp, bl);
- ::encode(last_clean_scrub_stamp, bl);
- ::encode(last_epoch_marked_full, bl);
- ::encode(last_interval_started, bl);
- ::encode(last_interval_clean, bl);
- ::encode(epoch_pool_created, bl);
+ encode(epoch_created, bl);
+ encode(last_epoch_started, bl);
+ encode(last_epoch_clean, bl);
+ encode(last_epoch_split, bl);
+ encode(same_interval_since, bl);
+ encode(same_up_since, bl);
+ encode(same_primary_since, bl);
+ encode(last_scrub, bl);
+ encode(last_scrub_stamp, bl);
+ encode(last_deep_scrub, bl);
+ encode(last_deep_scrub_stamp, bl);
+ encode(last_clean_scrub_stamp, bl);
+ encode(last_epoch_marked_full, bl);
+ encode(last_interval_started, bl);
+ encode(last_interval_clean, bl);
+ encode(epoch_pool_created, bl);
ENCODE_FINISH(bl);
}
void pg_history_t::decode(bufferlist::iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(9, 4, 4, bl);
- ::decode(epoch_created, bl);
- ::decode(last_epoch_started, bl);
+ decode(epoch_created, bl);
+ decode(last_epoch_started, bl);
if (struct_v >= 3)
- ::decode(last_epoch_clean, bl);
+ decode(last_epoch_clean, bl);
else
last_epoch_clean = last_epoch_started; // careful, it's a lie!
- ::decode(last_epoch_split, bl);
- ::decode(same_interval_since, bl);
- ::decode(same_up_since, bl);
- ::decode(same_primary_since, bl);
+ decode(last_epoch_split, bl);
+ decode(same_interval_since, bl);
+ decode(same_up_since, bl);
+ decode(same_primary_since, bl);
if (struct_v >= 2) {
- ::decode(last_scrub, bl);
- ::decode(last_scrub_stamp, bl);
+ decode(last_scrub, bl);
+ decode(last_scrub_stamp, bl);
}
if (struct_v >= 5) {
- ::decode(last_deep_scrub, bl);
- ::decode(last_deep_scrub_stamp, bl);
+ decode(last_deep_scrub, bl);
+ decode(last_deep_scrub_stamp, bl);
}
if (struct_v >= 6) {
- ::decode(last_clean_scrub_stamp, bl);
+ decode(last_clean_scrub_stamp, bl);
}
if (struct_v >= 7) {
- ::decode(last_epoch_marked_full, bl);
+ decode(last_epoch_marked_full, bl);
}
if (struct_v >= 8) {
- ::decode(last_interval_started, bl);
- ::decode(last_interval_clean, bl);
+ decode(last_interval_started, bl);
+ decode(last_interval_clean, bl);
} else {
if (last_epoch_started >= same_interval_since) {
last_interval_started = same_interval_since;
}
}
if (struct_v >= 9) {
- ::decode(epoch_pool_created, bl);
+ decode(epoch_pool_created, bl);
} else {
epoch_pool_created = epoch_created;
}
void pg_info_t::encode(bufferlist &bl) const
{
ENCODE_START(32, 26, bl);
- ::encode(pgid.pgid, bl);
- ::encode(last_update, bl);
- ::encode(last_complete, bl);
- ::encode(log_tail, bl);
+ encode(pgid.pgid, bl);
+ encode(last_update, bl);
+ encode(last_complete, bl);
+ encode(log_tail, bl);
if (last_backfill_bitwise && !last_backfill.is_max()) {
- ::encode(hobject_t(), bl);
+ encode(hobject_t(), bl);
} else {
- ::encode(last_backfill, bl);
+ encode(last_backfill, bl);
}
- ::encode(stats, bl);
+ encode(stats, bl);
history.encode(bl);
- ::encode(purged_snaps, bl);
- ::encode(last_epoch_started, bl);
- ::encode(last_user_version, bl);
- ::encode(hit_set, bl);
- ::encode(pgid.shard, bl);
- ::encode(last_backfill, bl);
- ::encode(last_backfill_bitwise, bl);
- ::encode(last_interval_started, bl);
+ encode(purged_snaps, bl);
+ encode(last_epoch_started, bl);
+ encode(last_user_version, bl);
+ encode(hit_set, bl);
+ encode(pgid.shard, bl);
+ encode(last_backfill, bl);
+ encode(last_backfill_bitwise, bl);
+ encode(last_interval_started, bl);
ENCODE_FINISH(bl);
}
void pg_info_t::decode(bufferlist::iterator &bl)
{
DECODE_START(32, bl);
- ::decode(pgid.pgid, bl);
- ::decode(last_update, bl);
- ::decode(last_complete, bl);
- ::decode(log_tail, bl);
+ decode(pgid.pgid, bl);
+ decode(last_update, bl);
+ decode(last_complete, bl);
+ decode(log_tail, bl);
{
hobject_t old_last_backfill;
- ::decode(old_last_backfill, bl);
+ decode(old_last_backfill, bl);
}
- ::decode(stats, bl);
+ decode(stats, bl);
history.decode(bl);
- ::decode(purged_snaps, bl);
- ::decode(last_epoch_started, bl);
- ::decode(last_user_version, bl);
- ::decode(hit_set, bl);
- ::decode(pgid.shard, bl);
- ::decode(last_backfill, bl);
- ::decode(last_backfill_bitwise, bl);
+ decode(purged_snaps, bl);
+ decode(last_epoch_started, bl);
+ decode(last_user_version, bl);
+ decode(hit_set, bl);
+ decode(pgid.shard, bl);
+ decode(last_backfill, bl);
+ decode(last_backfill_bitwise, bl);
if (struct_v >= 32) {
- ::decode(last_interval_started, bl);
+ decode(last_interval_started, bl);
} else {
last_interval_started = last_epoch_started;
}
void pg_notify_t::encode(bufferlist &bl) const
{
ENCODE_START(2, 2, bl);
- ::encode(query_epoch, bl);
- ::encode(epoch_sent, bl);
- ::encode(info, bl);
- ::encode(to, bl);
- ::encode(from, bl);
+ encode(query_epoch, bl);
+ encode(epoch_sent, bl);
+ encode(info, bl);
+ encode(to, bl);
+ encode(from, bl);
ENCODE_FINISH(bl);
}
void pg_notify_t::decode(bufferlist::iterator &bl)
{
DECODE_START(2, bl);
- ::decode(query_epoch, bl);
- ::decode(epoch_sent, bl);
- ::decode(info, bl);
- ::decode(to, bl);
- ::decode(from, bl);
+ decode(query_epoch, bl);
+ decode(epoch_sent, bl);
+ decode(info, bl);
+ decode(to, bl);
+ decode(from, bl);
DECODE_FINISH(bl);
}
void PastIntervals::pg_interval_t::encode(bufferlist& bl) const
{
ENCODE_START(4, 2, bl);
- ::encode(first, bl);
- ::encode(last, bl);
- ::encode(up, bl);
- ::encode(acting, bl);
- ::encode(maybe_went_rw, bl);
- ::encode(primary, bl);
- ::encode(up_primary, bl);
+ encode(first, bl);
+ encode(last, bl);
+ encode(up, bl);
+ encode(acting, bl);
+ encode(maybe_went_rw, bl);
+ encode(primary, bl);
+ encode(up_primary, bl);
ENCODE_FINISH(bl);
}
void PastIntervals::pg_interval_t::decode(bufferlist::iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
- ::decode(first, bl);
- ::decode(last, bl);
- ::decode(up, bl);
- ::decode(acting, bl);
- ::decode(maybe_went_rw, bl);
+ decode(first, bl);
+ decode(last, bl);
+ decode(up, bl);
+ decode(acting, bl);
+ decode(maybe_went_rw, bl);
if (struct_v >= 3) {
- ::decode(primary, bl);
+ decode(primary, bl);
} else {
if (acting.size())
primary = acting[0];
}
if (struct_v >= 4) {
- ::decode(up_primary, bl);
+ decode(up_primary, bl);
} else {
if (up.size())
up_primary = up[0];
}
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(first, bl);
- ::encode(last, bl);
- ::encode(acting, bl);
+ encode(first, bl);
+ encode(last, bl);
+ encode(acting, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(first, bl);
- ::decode(last, bl);
- ::decode(acting, bl);
+ decode(first, bl);
+ decode(last, bl);
+ decode(acting, bl);
DECODE_FINISH(bl);
}
static void generate_test_instances(list<compact_interval_t*> & o) {
}
void encode(bufferlist &bl) const override {
ENCODE_START(1, 1, bl);
- ::encode(first, bl);
- ::encode(last, bl);
- ::encode(all_participants, bl);
- ::encode(intervals, bl);
+ encode(first, bl);
+ encode(last, bl);
+ encode(all_participants, bl);
+ encode(intervals, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) override {
DECODE_START(1, bl);
- ::decode(first, bl);
- ::decode(last, bl);
- ::decode(all_participants, bl);
- ::decode(intervals, bl);
+ decode(first, bl);
+ decode(last, bl);
+ decode(all_participants, bl);
+ decode(intervals, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const override {
{
DECODE_START(1, bl);
__u8 type = 0;
- ::decode(type, bl);
+ decode(type, bl);
switch (type) {
case 0:
break;
void pg_query_t::encode(bufferlist &bl, uint64_t features) const {
ENCODE_START(3, 3, bl);
- ::encode(type, bl);
- ::encode(since, bl);
+ encode(type, bl);
+ encode(since, bl);
history.encode(bl);
- ::encode(epoch_sent, bl);
- ::encode(to, bl);
- ::encode(from, bl);
+ encode(epoch_sent, bl);
+ encode(to, bl);
+ encode(from, bl);
ENCODE_FINISH(bl);
}
void pg_query_t::decode(bufferlist::iterator &bl) {
DECODE_START(3, bl);
- ::decode(type, bl);
- ::decode(since, bl);
+ decode(type, bl);
+ decode(since, bl);
history.decode(bl);
- ::decode(epoch_sent, bl);
- ::decode(to, bl);
- ::decode(from, bl);
+ decode(epoch_sent, bl);
+ decode(to, bl);
+ decode(from, bl);
DECODE_FINISH(bl);
}
while (!bp.end()) {
DECODE_START(max_required_version, bp);
uint8_t code;
- ::decode(code, bp);
+ decode(code, bp);
switch (code) {
case APPEND: {
uint64_t size;
- ::decode(size, bp);
+ decode(size, bp);
visitor->append(size);
break;
}
case SETATTRS: {
map<string, boost::optional<bufferlist> > attrs;
- ::decode(attrs, bp);
+ decode(attrs, bp);
visitor->setattrs(attrs);
break;
}
case DELETE: {
version_t old_version;
- ::decode(old_version, bp);
+ decode(old_version, bp);
visitor->rmobject(old_version);
break;
}
}
case UPDATE_SNAPS: {
set<snapid_t> snaps;
- ::decode(snaps, bp);
+ decode(snaps, bp);
visitor->update_snaps(snaps);
break;
}
case TRY_DELETE: {
version_t old_version;
- ::decode(old_version, bp);
+ decode(old_version, bp);
visitor->try_rmobject(old_version);
break;
}
case ROLLBACK_EXTENTS: {
vector<pair<uint64_t, uint64_t> > extents;
version_t gen;
- ::decode(gen, bp);
- ::decode(extents, bp);
+ decode(gen, bp);
+ decode(extents, bp);
visitor->rollback_extents(gen,extents);
break;
}
void ObjectModDesc::encode(bufferlist &_bl) const
{
ENCODE_START(max_required_version, max_required_version, _bl);
- ::encode(can_local_rollback, _bl);
- ::encode(rollback_info_completed, _bl);
- ::encode(bl, _bl);
+ encode(can_local_rollback, _bl);
+ encode(rollback_info_completed, _bl);
+ encode(bl, _bl);
ENCODE_FINISH(_bl);
}
void ObjectModDesc::decode(bufferlist::iterator &_bl)
{
DECODE_START(2, _bl);
max_required_version = struct_v;
- ::decode(can_local_rollback, _bl);
- ::decode(rollback_info_completed, _bl);
- ::decode(bl, _bl);
+ decode(can_local_rollback, _bl);
+ decode(rollback_info_completed, _bl);
+ decode(bl, _bl);
// ensure bl does not pin a larger buffer in memory
bl.rebuild();
bl.reassign_to_mempool(mempool::mempool_osd_pglog);
void pg_log_entry_t::encode_with_checksum(bufferlist& bl) const
{
+ using ceph::encode;
bufferlist ebl(sizeof(*this)*2);
- encode(ebl);
+ this->encode(ebl);
__u32 crc = ebl.crc32c(0);
- ::encode(ebl, bl);
- ::encode(crc, bl);
+ encode(ebl, bl);
+ encode(crc, bl);
}
void pg_log_entry_t::decode_with_checksum(bufferlist::iterator& p)
{
+ using ceph::decode;
bufferlist bl;
- ::decode(bl, p);
+ decode(bl, p);
__u32 crc;
- ::decode(crc, p);
+ decode(crc, p);
if (crc != bl.crc32c(0))
throw buffer::malformed_input("bad checksum on pg_log_entry_t");
bufferlist::iterator q = bl.begin();
- decode(q);
+ this->decode(q);
}
void pg_log_entry_t::encode(bufferlist &bl) const
{
ENCODE_START(11, 4, bl);
- ::encode(op, bl);
- ::encode(soid, bl);
- ::encode(version, bl);
+ encode(op, bl);
+ encode(soid, bl);
+ encode(version, bl);
/**
* Added with reverting_to:
* into prior_version as expected.
*/
if (op == LOST_REVERT)
- ::encode(reverting_to, bl);
+ encode(reverting_to, bl);
else
- ::encode(prior_version, bl);
+ encode(prior_version, bl);
- ::encode(reqid, bl);
- ::encode(mtime, bl);
+ encode(reqid, bl);
+ encode(mtime, bl);
if (op == LOST_REVERT)
- ::encode(prior_version, bl);
- ::encode(snaps, bl);
- ::encode(user_version, bl);
- ::encode(mod_desc, bl);
- ::encode(extra_reqids, bl);
+ encode(prior_version, bl);
+ encode(snaps, bl);
+ encode(user_version, bl);
+ encode(mod_desc, bl);
+ encode(extra_reqids, bl);
if (op == ERROR)
- ::encode(return_code, bl);
+ encode(return_code, bl);
ENCODE_FINISH(bl);
}
void pg_log_entry_t::decode(bufferlist::iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(11, 4, 4, bl);
- ::decode(op, bl);
+ decode(op, bl);
if (struct_v < 2) {
sobject_t old_soid;
- ::decode(old_soid, bl);
+ decode(old_soid, bl);
soid.oid = old_soid.oid;
soid.snap = old_soid.snap;
invalid_hash = true;
} else {
- ::decode(soid, bl);
+ decode(soid, bl);
}
if (struct_v < 3)
invalid_hash = true;
- ::decode(version, bl);
+ decode(version, bl);
if (struct_v >= 6 && op == LOST_REVERT)
- ::decode(reverting_to, bl);
+ decode(reverting_to, bl);
else
- ::decode(prior_version, bl);
+ decode(prior_version, bl);
- ::decode(reqid, bl);
+ decode(reqid, bl);
- ::decode(mtime, bl);
+ decode(mtime, bl);
if (struct_v < 5)
invalid_pool = true;
if (op == LOST_REVERT) {
if (struct_v >= 6) {
- ::decode(prior_version, bl);
+ decode(prior_version, bl);
} else {
reverting_to = prior_version;
}
}
if (struct_v >= 7 || // for v >= 7, this is for all ops.
op == CLONE) { // for v < 7, it's only present for CLONE.
- ::decode(snaps, bl);
+ decode(snaps, bl);
// ensure snaps does not pin a larger buffer in memory
snaps.rebuild();
snaps.reassign_to_mempool(mempool::mempool_osd_pglog);
}
if (struct_v >= 8)
- ::decode(user_version, bl);
+ decode(user_version, bl);
else
user_version = version.version;
if (struct_v >= 9)
- ::decode(mod_desc, bl);
+ decode(mod_desc, bl);
else
mod_desc.mark_unrollbackable();
if (struct_v >= 10)
- ::decode(extra_reqids, bl);
+ decode(extra_reqids, bl);
if (struct_v >= 11 && op == ERROR)
- ::decode(return_code, bl);
+ decode(return_code, bl);
DECODE_FINISH(bl);
}
bufferlist c = snaps;
bufferlist::iterator p = c.begin();
try {
- ::decode(v, p);
+ using ceph::decode;
+ decode(v, p);
} catch (...) {
v.clear();
}
bufferlist c = e.snaps;
bufferlist::iterator p = c.begin();
try {
- ::decode(snaps, p);
+ decode(snaps, p);
} catch (...) {
snaps.clear();
}
void pg_log_dup_t::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(reqid, bl);
- ::encode(version, bl);
- ::encode(user_version, bl);
- ::encode(return_code, bl);
+ encode(reqid, bl);
+ encode(version, bl);
+ encode(user_version, bl);
+ encode(return_code, bl);
ENCODE_FINISH(bl);
}
void pg_log_dup_t::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(reqid, bl);
- ::decode(version, bl);
- ::decode(user_version, bl);
- ::decode(return_code, bl);
+ decode(reqid, bl);
+ decode(version, bl);
+ decode(user_version, bl);
+ decode(return_code, bl);
DECODE_FINISH(bl);
}
void pg_log_t::encode(bufferlist& bl) const
{
ENCODE_START(7, 3, bl);
- ::encode(head, bl);
- ::encode(tail, bl);
- ::encode(log, bl);
- ::encode(can_rollback_to, bl);
- ::encode(rollback_info_trimmed_to, bl);
- ::encode(dups, bl);
+ encode(head, bl);
+ encode(tail, bl);
+ encode(log, bl);
+ encode(can_rollback_to, bl);
+ encode(rollback_info_trimmed_to, bl);
+ encode(dups, bl);
ENCODE_FINISH(bl);
}
void pg_log_t::decode(bufferlist::iterator &bl, int64_t pool)
{
DECODE_START_LEGACY_COMPAT_LEN(7, 3, 3, bl);
- ::decode(head, bl);
- ::decode(tail, bl);
+ decode(head, bl);
+ decode(tail, bl);
if (struct_v < 2) {
bool backlog;
- ::decode(backlog, bl);
+ decode(backlog, bl);
}
- ::decode(log, bl);
+ decode(log, bl);
if (struct_v >= 5)
- ::decode(can_rollback_to, bl);
+ decode(can_rollback_to, bl);
if (struct_v >= 6)
- ::decode(rollback_info_trimmed_to, bl);
+ decode(rollback_info_trimmed_to, bl);
else
rollback_info_trimmed_to = tail;
if (struct_v >= 7)
- ::decode(dups, bl);
+ decode(dups, bl);
DECODE_FINISH(bl);
void object_copy_cursor_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(attr_complete, bl);
- ::encode(data_offset, bl);
- ::encode(data_complete, bl);
- ::encode(omap_offset, bl);
- ::encode(omap_complete, bl);
+ encode(attr_complete, bl);
+ encode(data_offset, bl);
+ encode(data_complete, bl);
+ encode(omap_offset, bl);
+ encode(omap_complete, bl);
ENCODE_FINISH(bl);
}
void object_copy_cursor_t::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(attr_complete, bl);
- ::decode(data_offset, bl);
- ::decode(data_complete, bl);
- ::decode(omap_offset, bl);
- ::decode(omap_complete, bl);
+ decode(attr_complete, bl);
+ decode(data_offset, bl);
+ decode(data_complete, bl);
+ decode(omap_offset, bl);
+ decode(omap_complete, bl);
DECODE_FINISH(bl);
}
void object_copy_data_t::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(7, 5, bl);
- ::encode(size, bl);
- ::encode(mtime, bl);
- ::encode(attrs, bl);
- ::encode(data, bl);
- ::encode(omap_data, bl);
- ::encode(cursor, bl);
- ::encode(omap_header, bl);
- ::encode(snaps, bl);
- ::encode(snap_seq, bl);
- ::encode(flags, bl);
- ::encode(data_digest, bl);
- ::encode(omap_digest, bl);
- ::encode(reqids, bl);
- ::encode(truncate_seq, bl);
- ::encode(truncate_size, bl);
+ encode(size, bl);
+ encode(mtime, bl);
+ encode(attrs, bl);
+ encode(data, bl);
+ encode(omap_data, bl);
+ encode(cursor, bl);
+ encode(omap_header, bl);
+ encode(snaps, bl);
+ encode(snap_seq, bl);
+ encode(flags, bl);
+ encode(data_digest, bl);
+ encode(omap_digest, bl);
+ encode(reqids, bl);
+ encode(truncate_seq, bl);
+ encode(truncate_size, bl);
ENCODE_FINISH(bl);
}
DECODE_START(7, bl);
if (struct_v < 5) {
// old
- ::decode(size, bl);
- ::decode(mtime, bl);
+ decode(size, bl);
+ decode(mtime, bl);
{
string category;
- ::decode(category, bl); // no longer used
+ decode(category, bl); // no longer used
}
- ::decode(attrs, bl);
- ::decode(data, bl);
+ decode(attrs, bl);
+ decode(data, bl);
{
map<string,bufferlist> omap;
- ::decode(omap, bl);
+ decode(omap, bl);
omap_data.clear();
- if (!omap.empty())
- ::encode(omap, omap_data);
+ if (!omap.empty()) {
+ using ceph::encode;
+ encode(omap, omap_data);
+ }
}
- ::decode(cursor, bl);
+ decode(cursor, bl);
if (struct_v >= 2)
- ::decode(omap_header, bl);
+ decode(omap_header, bl);
if (struct_v >= 3) {
- ::decode(snaps, bl);
- ::decode(snap_seq, bl);
+ decode(snaps, bl);
+ decode(snap_seq, bl);
} else {
snaps.clear();
snap_seq = 0;
}
if (struct_v >= 4) {
- ::decode(flags, bl);
- ::decode(data_digest, bl);
- ::decode(omap_digest, bl);
+ decode(flags, bl);
+ decode(data_digest, bl);
+ decode(omap_digest, bl);
}
} else {
// current
- ::decode(size, bl);
- ::decode(mtime, bl);
- ::decode(attrs, bl);
- ::decode(data, bl);
- ::decode(omap_data, bl);
- ::decode(cursor, bl);
- ::decode(omap_header, bl);
- ::decode(snaps, bl);
- ::decode(snap_seq, bl);
+ decode(size, bl);
+ decode(mtime, bl);
+ decode(attrs, bl);
+ decode(data, bl);
+ decode(omap_data, bl);
+ decode(cursor, bl);
+ decode(omap_header, bl);
+ decode(snaps, bl);
+ decode(snap_seq, bl);
if (struct_v >= 4) {
- ::decode(flags, bl);
- ::decode(data_digest, bl);
- ::decode(omap_digest, bl);
+ decode(flags, bl);
+ decode(data_digest, bl);
+ decode(omap_digest, bl);
}
if (struct_v >= 6) {
- ::decode(reqids, bl);
+ decode(reqids, bl);
}
if (struct_v >= 7) {
- ::decode(truncate_seq, bl);
- ::decode(truncate_size, bl);
+ decode(truncate_seq, bl);
+ decode(truncate_size, bl);
}
}
DECODE_FINISH(bl);
bl2.push_back(bp2);
map<string,bufferlist> omap;
omap["why"] = bl2;
- ::encode(omap, o.back()->omap_data);
+ using ceph::encode;
+ encode(omap, o.back()->omap_data);
bufferptr databp("iamsomedatatocontain", 20);
o.back()->data.push_back(databp);
o.back()->omap_header.append("this is an omap header");
void pg_create_t::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(created, bl);
- ::encode(parent, bl);
- ::encode(split_bits, bl);
+ encode(created, bl);
+ encode(parent, bl);
+ encode(split_bits, bl);
ENCODE_FINISH(bl);
}
void pg_create_t::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(created, bl);
- ::decode(parent, bl);
- ::decode(split_bits, bl);
+ decode(created, bl);
+ decode(parent, bl);
+ decode(split_bits, bl);
DECODE_FINISH(bl);
}
void pg_hit_set_info_t::encode(bufferlist& bl) const
{
ENCODE_START(2, 1, bl);
- ::encode(begin, bl);
- ::encode(end, bl);
- ::encode(version, bl);
- ::encode(using_gmt, bl);
+ encode(begin, bl);
+ encode(end, bl);
+ encode(version, bl);
+ encode(using_gmt, bl);
ENCODE_FINISH(bl);
}
void pg_hit_set_info_t::decode(bufferlist::iterator& p)
{
DECODE_START(2, p);
- ::decode(begin, p);
- ::decode(end, p);
- ::decode(version, p);
+ decode(begin, p);
+ decode(end, p);
+ decode(version, p);
if (struct_v >= 2) {
- ::decode(using_gmt, p);
+ decode(using_gmt, p);
} else {
using_gmt = false;
}
void pg_hit_set_history_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(current_last_update, bl);
+ encode(current_last_update, bl);
{
utime_t dummy_stamp;
- ::encode(dummy_stamp, bl);
+ encode(dummy_stamp, bl);
}
{
pg_hit_set_info_t dummy_info;
- ::encode(dummy_info, bl);
+ encode(dummy_info, bl);
}
- ::encode(history, bl);
+ encode(history, bl);
ENCODE_FINISH(bl);
}
void pg_hit_set_history_t::decode(bufferlist::iterator& p)
{
DECODE_START(1, p);
- ::decode(current_last_update, p);
+ decode(current_last_update, p);
{
utime_t dummy_stamp;
- ::decode(dummy_stamp, p);
+ decode(dummy_stamp, p);
}
{
pg_hit_set_info_t dummy_info;
- ::decode(dummy_info, p);
+ decode(dummy_info, p);
}
- ::decode(history, p);
+ decode(history, p);
DECODE_FINISH(p);
}
void OSDSuperblock::encode(bufferlist &bl) const
{
ENCODE_START(8, 5, bl);
- ::encode(cluster_fsid, bl);
- ::encode(whoami, bl);
- ::encode(current_epoch, bl);
- ::encode(oldest_map, bl);
- ::encode(newest_map, bl);
- ::encode(weight, bl);
+ encode(cluster_fsid, bl);
+ encode(whoami, bl);
+ encode(current_epoch, bl);
+ encode(oldest_map, bl);
+ encode(newest_map, bl);
+ encode(weight, bl);
compat_features.encode(bl);
- ::encode(clean_thru, bl);
- ::encode(mounted, bl);
- ::encode(osd_fsid, bl);
- ::encode((epoch_t)0, bl); // epoch_t last_epoch_marked_full
- ::encode((uint32_t)0, bl); // map<int64_t,epoch_t> pool_last_epoch_marked_full
+ encode(clean_thru, bl);
+ encode(mounted, bl);
+ encode(osd_fsid, bl);
+ encode((epoch_t)0, bl); // epoch_t last_epoch_marked_full
+ encode((uint32_t)0, bl); // map<int64_t,epoch_t> pool_last_epoch_marked_full
ENCODE_FINISH(bl);
}
DECODE_START_LEGACY_COMPAT_LEN(8, 5, 5, bl);
if (struct_v < 3) {
string magic;
- ::decode(magic, bl);
- }
- ::decode(cluster_fsid, bl);
- ::decode(whoami, bl);
- ::decode(current_epoch, bl);
- ::decode(oldest_map, bl);
- ::decode(newest_map, bl);
- ::decode(weight, bl);
+ decode(magic, bl);
+ }
+ decode(cluster_fsid, bl);
+ decode(whoami, bl);
+ decode(current_epoch, bl);
+ decode(oldest_map, bl);
+ decode(newest_map, bl);
+ decode(weight, bl);
if (struct_v >= 2) {
compat_features.decode(bl);
} else { //upgrade it!
compat_features.incompat.insert(CEPH_OSD_FEATURE_INCOMPAT_BASE);
}
- ::decode(clean_thru, bl);
- ::decode(mounted, bl);
+ decode(clean_thru, bl);
+ decode(mounted, bl);
if (struct_v >= 4)
- ::decode(osd_fsid, bl);
+ decode(osd_fsid, bl);
if (struct_v >= 6) {
epoch_t last_map_marked_full;
- ::decode(last_map_marked_full, bl);
+ decode(last_map_marked_full, bl);
}
if (struct_v >= 7) {
map<int64_t,epoch_t> pool_last_map_marked_full;
- ::decode(pool_last_map_marked_full, bl);
+ decode(pool_last_map_marked_full, bl);
}
DECODE_FINISH(bl);
}
void SnapSet::encode(bufferlist& bl) const
{
ENCODE_START(3, 2, bl);
- ::encode(seq, bl);
- ::encode(true, bl); // head_exists
- ::encode(snaps, bl);
- ::encode(clones, bl);
- ::encode(clone_overlap, bl);
- ::encode(clone_size, bl);
- ::encode(clone_snaps, bl);
+ encode(seq, bl);
+ encode(true, bl); // head_exists
+ encode(snaps, bl);
+ encode(clones, bl);
+ encode(clone_overlap, bl);
+ encode(clone_size, bl);
+ encode(clone_snaps, bl);
ENCODE_FINISH(bl);
}
void SnapSet::decode(bufferlist::iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
- ::decode(seq, bl);
+ decode(seq, bl);
bl.advance(1); // skip legacy head_exists (always true)
- ::decode(snaps, bl);
- ::decode(clones, bl);
- ::decode(clone_overlap, bl);
- ::decode(clone_size, bl);
+ decode(snaps, bl);
+ decode(clones, bl);
+ decode(clone_overlap, bl);
+ decode(clone_size, bl);
if (struct_v >= 3) {
- ::decode(clone_snaps, bl);
+ decode(clone_snaps, bl);
} else {
clone_snaps.clear();
}
void watch_info_t::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(4, 3, bl);
- ::encode(cookie, bl);
- ::encode(timeout_seconds, bl);
- ::encode(addr, bl, features);
+ encode(cookie, bl);
+ encode(timeout_seconds, bl);
+ encode(addr, bl, features);
ENCODE_FINISH(bl);
}
void watch_info_t::decode(bufferlist::iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 3, 3, bl);
- ::decode(cookie, bl);
+ decode(cookie, bl);
if (struct_v < 2) {
uint64_t ver;
- ::decode(ver, bl);
+ decode(ver, bl);
}
- ::decode(timeout_seconds, bl);
+ decode(timeout_seconds, bl);
if (struct_v >= 4) {
- ::decode(addr, bl);
+ decode(addr, bl);
}
DECODE_FINISH(bl);
}
void chunk_info_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(offset, bl);
- ::encode(length, bl);
- ::encode(oid, bl);
- ::encode(flags, bl);
+ encode(offset, bl);
+ encode(length, bl);
+ encode(oid, bl);
+ encode(flags, bl);
ENCODE_FINISH(bl);
}
void chunk_info_t::decode(bufferlist::iterator& bl)
{
DECODE_START(1, bl);
- ::decode(offset, bl);
- ::decode(length, bl);
- ::decode(oid, bl);
- ::decode(flags, bl);
+ decode(offset, bl);
+ decode(length, bl);
+ decode(oid, bl);
+ decode(flags, bl);
DECODE_FINISH(bl);
}
void object_manifest_t::encode(bufferlist& bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(type, bl);
+ encode(type, bl);
switch (type) {
case TYPE_NONE: break;
case TYPE_REDIRECT:
- ::encode(redirect_target, bl);
+ encode(redirect_target, bl);
break;
case TYPE_CHUNKED:
- ::encode(chunk_map, bl);
+ encode(chunk_map, bl);
break;
default:
ceph_abort();
void object_manifest_t::decode(bufferlist::iterator& bl)
{
DECODE_START(1, bl);
- ::decode(type, bl);
+ decode(type, bl);
switch (type) {
case TYPE_NONE: break;
case TYPE_REDIRECT:
- ::decode(redirect_target, bl);
+ decode(redirect_target, bl);
break;
case TYPE_CHUNKED:
- ::decode(chunk_map, bl);
+ decode(chunk_map, bl);
break;
default:
ceph_abort();
old_watchers.insert(make_pair(i->first.second, i->second));
}
ENCODE_START(17, 8, bl);
- ::encode(soid, bl);
- ::encode(myoloc, bl); //Retained for compatibility
- ::encode((__u32)0, bl); // was category, no longer used
- ::encode(version, bl);
- ::encode(prior_version, bl);
- ::encode(last_reqid, bl);
- ::encode(size, bl);
- ::encode(mtime, bl);
+ encode(soid, bl);
+ encode(myoloc, bl); //Retained for compatibility
+ encode((__u32)0, bl); // was category, no longer used
+ encode(version, bl);
+ encode(prior_version, bl);
+ encode(last_reqid, bl);
+ encode(size, bl);
+ encode(mtime, bl);
if (soid.snap == CEPH_NOSNAP)
- ::encode(osd_reqid_t(), bl); // used to be wrlock_by
+ encode(osd_reqid_t(), bl); // used to be wrlock_by
else
- ::encode((uint32_t)0, bl); // was legacy_snaps
- ::encode(truncate_seq, bl);
- ::encode(truncate_size, bl);
- ::encode(is_lost(), bl);
- ::encode(old_watchers, bl, features);
+ encode((uint32_t)0, bl); // was legacy_snaps
+ encode(truncate_seq, bl);
+ encode(truncate_size, bl);
+ encode(is_lost(), bl);
+ encode(old_watchers, bl, features);
/* shenanigans to avoid breaking backwards compatibility in the disk format.
* When we can, switch this out for simply putting the version_t on disk. */
eversion_t user_eversion(0, user_version);
- ::encode(user_eversion, bl);
- ::encode(test_flag(FLAG_USES_TMAP), bl);
- ::encode(watchers, bl, features);
+ encode(user_eversion, bl);
+ encode(test_flag(FLAG_USES_TMAP), bl);
+ encode(watchers, bl, features);
__u32 _flags = flags;
- ::encode(_flags, bl);
- ::encode(local_mtime, bl);
- ::encode(data_digest, bl);
- ::encode(omap_digest, bl);
- ::encode(expected_object_size, bl);
- ::encode(expected_write_size, bl);
- ::encode(alloc_hint_flags, bl);
+ encode(_flags, bl);
+ encode(local_mtime, bl);
+ encode(data_digest, bl);
+ encode(omap_digest, bl);
+ encode(expected_object_size, bl);
+ encode(expected_write_size, bl);
+ encode(alloc_hint_flags, bl);
if (has_manifest()) {
- ::encode(manifest, bl);
+ encode(manifest, bl);
}
ENCODE_FINISH(bl);
}
object_locator_t myoloc;
DECODE_START_LEGACY_COMPAT_LEN(17, 8, 8, bl);
map<entity_name_t, watch_info_t> old_watchers;
- ::decode(soid, bl);
- ::decode(myoloc, bl);
+ decode(soid, bl);
+ decode(myoloc, bl);
{
string category;
- ::decode(category, bl); // no longer used
+ decode(category, bl); // no longer used
}
- ::decode(version, bl);
- ::decode(prior_version, bl);
- ::decode(last_reqid, bl);
- ::decode(size, bl);
- ::decode(mtime, bl);
+ decode(version, bl);
+ decode(prior_version, bl);
+ decode(last_reqid, bl);
+ decode(size, bl);
+ decode(mtime, bl);
if (soid.snap == CEPH_NOSNAP) {
osd_reqid_t wrlock_by;
- ::decode(wrlock_by, bl);
+ decode(wrlock_by, bl);
} else {
vector<snapid_t> legacy_snaps;
- ::decode(legacy_snaps, bl);
+ decode(legacy_snaps, bl);
}
- ::decode(truncate_seq, bl);
- ::decode(truncate_size, bl);
+ decode(truncate_seq, bl);
+ decode(truncate_size, bl);
// if this is struct_v >= 13, we will overwrite this
// below since this field is just here for backwards
// compatibility
__u8 lo;
- ::decode(lo, bl);
+ decode(lo, bl);
flags = (flag_t)lo;
- ::decode(old_watchers, bl);
+ decode(old_watchers, bl);
eversion_t user_eversion;
- ::decode(user_eversion, bl);
+ decode(user_eversion, bl);
user_version = user_eversion.version;
if (struct_v >= 9) {
bool uses_tmap = false;
- ::decode(uses_tmap, bl);
+ decode(uses_tmap, bl);
if (uses_tmap)
set_flag(FLAG_USES_TMAP);
} else {
if (struct_v < 10)
soid.pool = myoloc.pool;
if (struct_v >= 11) {
- ::decode(watchers, bl);
+ decode(watchers, bl);
} else {
for (map<entity_name_t, watch_info_t>::iterator i = old_watchers.begin();
i != old_watchers.end();
}
if (struct_v >= 13) {
__u32 _flags;
- ::decode(_flags, bl);
+ decode(_flags, bl);
flags = (flag_t)_flags;
}
if (struct_v >= 14) {
- ::decode(local_mtime, bl);
+ decode(local_mtime, bl);
} else {
local_mtime = utime_t();
}
if (struct_v >= 15) {
- ::decode(data_digest, bl);
- ::decode(omap_digest, bl);
+ decode(data_digest, bl);
+ decode(omap_digest, bl);
} else {
data_digest = omap_digest = -1;
clear_flag(FLAG_DATA_DIGEST);
clear_flag(FLAG_OMAP_DIGEST);
}
if (struct_v >= 16) {
- ::decode(expected_object_size, bl);
- ::decode(expected_write_size, bl);
- ::decode(alloc_hint_flags, bl);
+ decode(expected_object_size, bl);
+ decode(expected_write_size, bl);
+ decode(alloc_hint_flags, bl);
} else {
expected_object_size = 0;
expected_write_size = 0;
}
if (struct_v >= 17) {
if (has_manifest()) {
- ::decode(manifest, bl);
+ decode(manifest, bl);
}
}
DECODE_FINISH(bl);
void ObjectRecoveryProgress::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(first, bl);
- ::encode(data_complete, bl);
- ::encode(data_recovered_to, bl);
- ::encode(omap_recovered_to, bl);
- ::encode(omap_complete, bl);
+ encode(first, bl);
+ encode(data_complete, bl);
+ encode(data_recovered_to, bl);
+ encode(omap_recovered_to, bl);
+ encode(omap_complete, bl);
ENCODE_FINISH(bl);
}
void ObjectRecoveryProgress::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(first, bl);
- ::decode(data_complete, bl);
- ::decode(data_recovered_to, bl);
- ::decode(omap_recovered_to, bl);
- ::decode(omap_complete, bl);
+ decode(first, bl);
+ decode(data_complete, bl);
+ decode(data_recovered_to, bl);
+ decode(omap_recovered_to, bl);
+ decode(omap_complete, bl);
DECODE_FINISH(bl);
}
void ObjectRecoveryInfo::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(2, 1, bl);
- ::encode(soid, bl);
- ::encode(version, bl);
- ::encode(size, bl);
- ::encode(oi, bl, features);
- ::encode(ss, bl);
- ::encode(copy_subset, bl);
- ::encode(clone_subset, bl);
+ encode(soid, bl);
+ encode(version, bl);
+ encode(size, bl);
+ encode(oi, bl, features);
+ encode(ss, bl);
+ encode(copy_subset, bl);
+ encode(clone_subset, bl);
ENCODE_FINISH(bl);
}
int64_t pool)
{
DECODE_START(2, bl);
- ::decode(soid, bl);
- ::decode(version, bl);
- ::decode(size, bl);
- ::decode(oi, bl);
- ::decode(ss, bl);
- ::decode(copy_subset, bl);
- ::decode(clone_subset, bl);
+ decode(soid, bl);
+ decode(version, bl);
+ decode(size, bl);
+ decode(oi, bl);
+ decode(ss, bl);
+ decode(copy_subset, bl);
+ decode(clone_subset, bl);
DECODE_FINISH(bl);
if (struct_v < 2) {
void PushReplyOp::encode(bufferlist &bl) const
{
ENCODE_START(1, 1, bl);
- ::encode(soid, bl);
+ encode(soid, bl);
ENCODE_FINISH(bl);
}
void PushReplyOp::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(soid, bl);
+ decode(soid, bl);
DECODE_FINISH(bl);
}
void PullOp::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(1, 1, bl);
- ::encode(soid, bl);
- ::encode(recovery_info, bl, features);
- ::encode(recovery_progress, bl);
+ encode(soid, bl);
+ encode(recovery_info, bl, features);
+ encode(recovery_progress, bl);
ENCODE_FINISH(bl);
}
void PullOp::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(soid, bl);
- ::decode(recovery_info, bl);
- ::decode(recovery_progress, bl);
+ decode(soid, bl);
+ decode(recovery_info, bl);
+ decode(recovery_progress, bl);
DECODE_FINISH(bl);
}
void PushOp::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(1, 1, bl);
- ::encode(soid, bl);
- ::encode(version, bl);
- ::encode(data, bl);
- ::encode(data_included, bl);
- ::encode(omap_header, bl);
- ::encode(omap_entries, bl);
- ::encode(attrset, bl);
- ::encode(recovery_info, bl, features);
- ::encode(after_progress, bl);
- ::encode(before_progress, bl);
+ encode(soid, bl);
+ encode(version, bl);
+ encode(data, bl);
+ encode(data_included, bl);
+ encode(omap_header, bl);
+ encode(omap_entries, bl);
+ encode(attrset, bl);
+ encode(recovery_info, bl, features);
+ encode(after_progress, bl);
+ encode(before_progress, bl);
ENCODE_FINISH(bl);
}
void PushOp::decode(bufferlist::iterator &bl)
{
DECODE_START(1, bl);
- ::decode(soid, bl);
- ::decode(version, bl);
- ::decode(data, bl);
- ::decode(data_included, bl);
- ::decode(omap_header, bl);
- ::decode(omap_entries, bl);
- ::decode(attrset, bl);
- ::decode(recovery_info, bl);
- ::decode(after_progress, bl);
- ::decode(before_progress, bl);
+ decode(soid, bl);
+ decode(version, bl);
+ decode(data, bl);
+ decode(data_included, bl);
+ decode(omap_header, bl);
+ decode(omap_entries, bl);
+ decode(attrset, bl);
+ decode(recovery_info, bl);
+ decode(after_progress, bl);
+ decode(before_progress, bl);
DECODE_FINISH(bl);
}
void ScrubMap::encode(bufferlist& bl) const
{
ENCODE_START(3, 2, bl);
- ::encode(objects, bl);
- ::encode((__u32)0, bl); // used to be attrs; now deprecated
+ encode(objects, bl);
+ encode((__u32)0, bl); // used to be attrs; now deprecated
bufferlist old_logbl; // not used
- ::encode(old_logbl, bl);
- ::encode(valid_through, bl);
- ::encode(incr_since, bl);
+ encode(old_logbl, bl);
+ encode(valid_through, bl);
+ encode(incr_since, bl);
ENCODE_FINISH(bl);
}
void ScrubMap::decode(bufferlist::iterator& bl, int64_t pool)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
- ::decode(objects, bl);
+ decode(objects, bl);
{
map<string,string> attrs; // deprecated
- ::decode(attrs, bl);
+ decode(attrs, bl);
}
bufferlist old_logbl; // not used
- ::decode(old_logbl, bl);
- ::decode(valid_through, bl);
- ::decode(incr_since, bl);
+ decode(old_logbl, bl);
+ decode(valid_through, bl);
+ decode(incr_since, bl);
DECODE_FINISH(bl);
// handle hobject_t upgrade
{
bool compat_read_error = read_error || ec_hash_mismatch || ec_size_mismatch;
ENCODE_START(9, 7, bl);
- ::encode(size, bl);
- ::encode(negative, bl);
- ::encode(attrs, bl);
- ::encode(digest, bl);
- ::encode(digest_present, bl);
- ::encode((uint32_t)0, bl); // obsolete nlinks
- ::encode((uint32_t)0, bl); // snapcolls
- ::encode(omap_digest, bl);
- ::encode(omap_digest_present, bl);
- ::encode(compat_read_error, bl);
- ::encode(stat_error, bl);
- ::encode(read_error, bl);
- ::encode(ec_hash_mismatch, bl);
- ::encode(ec_size_mismatch, bl);
- ::encode(large_omap_object_found, bl);
- ::encode(large_omap_object_key_count, bl);
- ::encode(large_omap_object_value_size, bl);
+ encode(size, bl);
+ encode(negative, bl);
+ encode(attrs, bl);
+ encode(digest, bl);
+ encode(digest_present, bl);
+ encode((uint32_t)0, bl); // obsolete nlinks
+ encode((uint32_t)0, bl); // snapcolls
+ encode(omap_digest, bl);
+ encode(omap_digest_present, bl);
+ encode(compat_read_error, bl);
+ encode(stat_error, bl);
+ encode(read_error, bl);
+ encode(ec_hash_mismatch, bl);
+ encode(ec_size_mismatch, bl);
+ encode(large_omap_object_found, bl);
+ encode(large_omap_object_key_count, bl);
+ encode(large_omap_object_value_size, bl);
ENCODE_FINISH(bl);
}
void ScrubMap::object::decode(bufferlist::iterator& bl)
{
DECODE_START(9, bl);
- ::decode(size, bl);
+ decode(size, bl);
bool tmp, compat_read_error = false;
- ::decode(tmp, bl);
+ decode(tmp, bl);
negative = tmp;
- ::decode(attrs, bl);
- ::decode(digest, bl);
- ::decode(tmp, bl);
+ decode(attrs, bl);
+ decode(digest, bl);
+ decode(tmp, bl);
digest_present = tmp;
{
uint32_t nlinks;
- ::decode(nlinks, bl);
+ decode(nlinks, bl);
set<snapid_t> snapcolls;
- ::decode(snapcolls, bl);
+ decode(snapcolls, bl);
}
- ::decode(omap_digest, bl);
- ::decode(tmp, bl);
+ decode(omap_digest, bl);
+ decode(tmp, bl);
omap_digest_present = tmp;
- ::decode(compat_read_error, bl);
- ::decode(tmp, bl);
+ decode(compat_read_error, bl);
+ decode(tmp, bl);
stat_error = tmp;
if (struct_v >= 8) {
- ::decode(tmp, bl);
+ decode(tmp, bl);
read_error = tmp;
- ::decode(tmp, bl);
+ decode(tmp, bl);
ec_hash_mismatch = tmp;
- ::decode(tmp, bl);
+ decode(tmp, bl);
ec_size_mismatch = tmp;
}
// If older encoder found a read_error, set read_error
if (compat_read_error && !read_error && !ec_hash_mismatch && !ec_size_mismatch)
read_error = true;
if (struct_v >= 9) {
- ::decode(tmp, bl);
+ decode(tmp, bl);
large_omap_object_found = tmp;
- ::decode(large_omap_object_key_count, bl);
- ::decode(large_omap_object_value_size, bl);
+ decode(large_omap_object_key_count, bl);
+ decode(large_omap_object_value_size, bl);
}
DECODE_FINISH(bl);
}
hobject_t get_hobj_end(unsigned pg_num) const;
void encode(bufferlist& bl) const {
+ using ceph::encode;
__u8 v = 1;
- ::encode(v, bl);
- ::encode(m_pool, bl);
- ::encode(m_seed, bl);
- ::encode(m_preferred, bl);
+ encode(v, bl);
+ encode(m_pool, bl);
+ encode(m_seed, bl);
+ encode(m_preferred, bl);
}
void decode(bufferlist::iterator& bl) {
+ using ceph::decode;
__u8 v;
- ::decode(v, bl);
- ::decode(m_pool, bl);
- ::decode(m_seed, bl);
- ::decode(m_preferred, bl);
+ decode(v, bl);
+ decode(m_pool, bl);
+ decode(m_seed, bl);
+ decode(m_preferred, bl);
}
void decode_old(bufferlist::iterator& bl) {
+ using ceph::decode;
old_pg_t opg;
- ::decode(opg, bl);
+ decode(opg, bl);
*this = opg;
}
void dump(Formatter *f) const;
void encode(bufferlist &bl) const {
ENCODE_START(1, 1, bl);
- ::encode(pgid, bl);
- ::encode(shard, bl);
+ encode(pgid, bl);
+ encode(shard, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(1, bl);
- ::decode(pgid, bl);
- ::decode(shard, bl);
+ decode(pgid, bl);
+ decode(shard, bl);
DECODE_FINISH(bl);
}
#if defined(CEPH_LITTLE_ENDIAN)
bl.append((char *)this, sizeof(version_t) + sizeof(epoch_t));
#else
- ::encode(version, bl);
- ::encode(epoch, bl);
+ encode(version, bl);
+ encode(epoch, bl);
#endif
}
void decode(bufferlist::iterator &bl) {
#if defined(CEPH_LITTLE_ENDIAN)
bl.copy(sizeof(version_t) + sizeof(epoch_t), (char *)this);
#else
- ::decode(version, bl);
- ::decode(epoch, bl);
+ decode(version, bl);
+ decode(epoch, bl);
#endif
}
void decode(bufferlist& bl) {
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(last_update, bl);
- ::encode(last_complete, bl);
- ::encode(last_user_version, bl);
- ::encode(stats.version, bl);
- ::encode(stats.reported_seq, bl);
- ::encode(stats.last_fresh, bl);
- ::encode(stats.last_active, bl);
- ::encode(stats.last_peered, bl);
- ::encode(stats.last_clean, bl);
- ::encode(stats.last_unstale, bl);
- ::encode(stats.last_undegraded, bl);
- ::encode(stats.last_fullsized, bl);
- ::encode(stats.log_size, bl);
- ::encode(stats.stats.sum.num_bytes, bl);
- ::encode(stats.stats.sum.num_objects, bl);
- ::encode(stats.stats.sum.num_object_copies, bl);
- ::encode(stats.stats.sum.num_rd, bl);
- ::encode(stats.stats.sum.num_rd_kb, bl);
- ::encode(stats.stats.sum.num_wr, bl);
- ::encode(stats.stats.sum.num_wr_kb, bl);
- ::encode(stats.stats.sum.num_objects_dirty, bl);
+ encode(last_update, bl);
+ encode(last_complete, bl);
+ encode(last_user_version, bl);
+ encode(stats.version, bl);
+ encode(stats.reported_seq, bl);
+ encode(stats.last_fresh, bl);
+ encode(stats.last_active, bl);
+ encode(stats.last_peered, bl);
+ encode(stats.last_clean, bl);
+ encode(stats.last_unstale, bl);
+ encode(stats.last_undegraded, bl);
+ encode(stats.last_fullsized, bl);
+ encode(stats.log_size, bl);
+ encode(stats.stats.sum.num_bytes, bl);
+ encode(stats.stats.sum.num_objects, bl);
+ encode(stats.stats.sum.num_object_copies, bl);
+ encode(stats.stats.sum.num_rd, bl);
+ encode(stats.stats.sum.num_rd_kb, bl);
+ encode(stats.stats.sum.num_wr, bl);
+ encode(stats.stats.sum.num_wr_kb, bl);
+ encode(stats.stats.sum.num_objects_dirty, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& p) {
DECODE_START(1, p);
- ::decode(last_update, p);
- ::decode(last_complete, p);
- ::decode(last_user_version, p);
- ::decode(stats.version, p);
- ::decode(stats.reported_seq, p);
- ::decode(stats.last_fresh, p);
- ::decode(stats.last_active, p);
- ::decode(stats.last_peered, p);
- ::decode(stats.last_clean, p);
- ::decode(stats.last_unstale, p);
- ::decode(stats.last_undegraded, p);
- ::decode(stats.last_fullsized, p);
- ::decode(stats.log_size, p);
- ::decode(stats.stats.sum.num_bytes, p);
- ::decode(stats.stats.sum.num_objects, p);
- ::decode(stats.stats.sum.num_object_copies, p);
- ::decode(stats.stats.sum.num_rd, p);
- ::decode(stats.stats.sum.num_rd_kb, p);
- ::decode(stats.stats.sum.num_wr, p);
- ::decode(stats.stats.sum.num_wr_kb, p);
- ::decode(stats.stats.sum.num_objects_dirty, p);
+ decode(last_update, p);
+ decode(last_complete, p);
+ decode(last_user_version, p);
+ decode(stats.version, p);
+ decode(stats.reported_seq, p);
+ decode(stats.last_fresh, p);
+ decode(stats.last_active, p);
+ decode(stats.last_peered, p);
+ decode(stats.last_clean, p);
+ decode(stats.last_unstale, p);
+ decode(stats.last_undegraded, p);
+ decode(stats.last_fullsized, p);
+ decode(stats.log_size, p);
+ decode(stats.stats.sum.num_bytes, p);
+ decode(stats.stats.sum.num_objects, p);
+ decode(stats.stats.sum.num_object_copies, p);
+ decode(stats.stats.sum.num_rd, p);
+ decode(stats.stats.sum.num_rd_kb, p);
+ decode(stats.stats.sum.num_wr, p);
+ decode(stats.stats.sum.num_wr_kb, p);
+ decode(stats.stats.sum.num_objects_dirty, p);
DECODE_FINISH(p);
}
};
ENCODE_START(1, 1, bl);
if (past_intervals) {
__u8 type = 2;
- ::encode(type, bl);
+ encode(type, bl);
past_intervals->encode(bl);
} else {
- ::encode((__u8)0, bl);
+ encode((__u8)0, bl);
}
ENCODE_FINISH(bl);
}
swap(other.max_required_version, max_required_version);
}
void append_id(ModID id) {
+ using ceph::encode;
uint8_t _id(id);
- ::encode(_id, bl);
+ encode(_id, bl);
}
void append(uint64_t old_size) {
if (!can_local_rollback || rollback_info_completed)
return;
ENCODE_START(1, 1, bl);
append_id(APPEND);
- ::encode(old_size, bl);
+ encode(old_size, bl);
ENCODE_FINISH(bl);
}
void setattrs(map<string, boost::optional<bufferlist> > &old_attrs) {
return;
ENCODE_START(1, 1, bl);
append_id(SETATTRS);
- ::encode(old_attrs, bl);
+ encode(old_attrs, bl);
ENCODE_FINISH(bl);
}
bool rmobject(version_t deletion_version) {
return false;
ENCODE_START(1, 1, bl);
append_id(DELETE);
- ::encode(deletion_version, bl);
+ encode(deletion_version, bl);
ENCODE_FINISH(bl);
rollback_info_completed = true;
return true;
return false;
ENCODE_START(1, 1, bl);
append_id(TRY_DELETE);
- ::encode(deletion_version, bl);
+ encode(deletion_version, bl);
ENCODE_FINISH(bl);
rollback_info_completed = true;
return true;
return;
ENCODE_START(1, 1, bl);
append_id(UPDATE_SNAPS);
- ::encode(old_snaps, bl);
+ encode(old_snaps, bl);
ENCODE_FINISH(bl);
}
void rollback_extents(
max_required_version = 2;
ENCODE_START(2, 2, bl);
append_id(ROLLBACK_EXTENTS);
- ::encode(gen, bl);
- ::encode(extents, bl);
+ encode(gen, bl);
+ encode(extents, bl);
ENCODE_FINISH(bl);
}
}
void encode(bufferlist& bl, uint64_t features) const {
+ using ceph::encode;
if (HAVE_FEATURE(features, OSD_RECOVERY_DELETES)) {
// encoding a zeroed eversion_t to differentiate between this and
// legacy unversioned encoding - a need value of 0'0 is not
// possible. This can be replaced with the legacy encoding
// macros post-luminous.
eversion_t e;
- ::encode(e, bl);
- ::encode(need, bl);
- ::encode(have, bl);
- ::encode(static_cast<uint8_t>(flags), bl);
+ encode(e, bl);
+ encode(need, bl);
+ encode(have, bl);
+ encode(static_cast<uint8_t>(flags), bl);
} else {
// legacy unversioned encoding
- ::encode(need, bl);
- ::encode(have, bl);
+ encode(need, bl);
+ encode(have, bl);
}
}
void decode(bufferlist::iterator& bl) {
+ using ceph::decode;
eversion_t e;
- ::decode(e, bl);
+ decode(e, bl);
if (e != eversion_t()) {
// legacy encoding, this is the need value
need = e;
- ::decode(have, bl);
+ decode(have, bl);
} else {
- ::decode(need, bl);
- ::decode(have, bl);
+ decode(need, bl);
+ decode(have, bl);
uint8_t f;
- ::decode(f, bl);
+ decode(f, bl);
flags = static_cast<missing_flags_t>(f);
}
}
void encode(bufferlist &bl) const {
ENCODE_START(4, 2, bl);
- ::encode(missing, bl, may_include_deletes ? CEPH_FEATURE_OSD_RECOVERY_DELETES : 0);
- ::encode(may_include_deletes, bl);
+ encode(missing, bl, may_include_deletes ? CEPH_FEATURE_OSD_RECOVERY_DELETES : 0);
+ encode(may_include_deletes, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl, int64_t pool = -1) {
for (auto const &i: missing)
tracker.changed(i.first);
DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
- ::decode(missing, bl);
+ decode(missing, bl);
if (struct_v >= 4) {
- ::decode(may_include_deletes, bl);
+ decode(may_include_deletes, bl);
}
DECODE_FINISH(bl);
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(handle, bl);
+ encode(handle, bl);
__u32 n = (__u32)entries.size();
- ::encode(n, bl);
+ encode(n, bl);
for (list<librados::ListObjectImpl>::const_iterator i = entries.begin(); i != entries.end(); ++i) {
- ::encode(i->nspace, bl);
- ::encode(i->oid, bl);
- ::encode(i->locator, bl);
+ encode(i->nspace, bl);
+ encode(i->oid, bl);
+ encode(i->locator, bl);
}
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(handle, bl);
+ decode(handle, bl);
__u32 n;
- ::decode(n, bl);
+ decode(n, bl);
entries.clear();
while (n--) {
librados::ListObjectImpl i;
- ::decode(i.nspace, bl);
- ::decode(i.oid, bl);
- ::decode(i.locator, bl);
+ decode(i.nspace, bl);
+ decode(i.oid, bl);
+ decode(i.locator, bl);
entries.push_back(i);
}
DECODE_FINISH(bl);
list<pair<object_t, string> > entries;
void encode(bufferlist& bl) const {
+ using ceph::encode;
__u8 v = 1;
- ::encode(v, bl);
- ::encode(handle, bl);
- ::encode(entries, bl);
+ encode(v, bl);
+ encode(handle, bl);
+ encode(entries, bl);
}
void decode(bufferlist::iterator& bl) {
+ using ceph::decode;
__u8 v;
- ::decode(v, bl);
+ decode(v, bl);
assert(v == 1);
- ::decode(handle, bl);
- ::decode(entries, bl);
+ decode(handle, bl);
+ decode(entries, bl);
}
void dump(Formatter *f) const {
f->dump_stream("handle") << handle;
void encode(bufferlist &bl, uint64_t features) const {
ENCODE_START(2, 1, bl);
- ::encode(name, bl);
- ::encode(cookie, bl);
- ::encode(timeout_seconds, bl);
- ::encode(addr, bl, features);
+ encode(name, bl);
+ encode(cookie, bl);
+ encode(timeout_seconds, bl);
+ encode(addr, bl, features);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &bl) {
DECODE_START(2, bl);
- ::decode(name, bl);
- ::decode(cookie, bl);
- ::decode(timeout_seconds, bl);
+ decode(name, bl);
+ decode(cookie, bl);
+ decode(timeout_seconds, bl);
if (struct_v >= 2) {
- ::decode(addr, bl);
+ decode(addr, bl);
}
DECODE_FINISH(bl);
}
void encode(bufferlist& bl, uint64_t features) const {
ENCODE_START(1, 1, bl);
- ::encode(entries, bl, features);
+ encode(entries, bl, features);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(entries, bl);
+ decode(entries, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const {
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(cloneid, bl);
- ::encode(snaps, bl);
- ::encode(overlap, bl);
- ::encode(size, bl);
+ encode(cloneid, bl);
+ encode(snaps, bl);
+ encode(overlap, bl);
+ encode(size, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(cloneid, bl);
- ::decode(snaps, bl);
- ::decode(overlap, bl);
- ::decode(size, bl);
+ decode(cloneid, bl);
+ decode(snaps, bl);
+ decode(overlap, bl);
+ decode(size, bl);
DECODE_FINISH(bl);
}
void dump(Formatter *f) const {
void encode(bufferlist& bl) const {
ENCODE_START(2, 1, bl);
- ::encode(clones, bl);
- ::encode(seq, bl);
+ encode(clones, bl);
+ encode(seq, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(2, bl);
- ::decode(clones, bl);
+ decode(clones, bl);
if (struct_v >= 2)
- ::decode(seq, bl);
+ decode(seq, bl);
else
seq = CEPH_NOSNAP;
DECODE_FINISH(bl);
projects / ceph.git / commitdiff