From 46de629c3d0bfae5eba3f6b810808938b5a9af1f Mon Sep 17 00:00:00 2001 From: "Adam C. Emerson" Date: Tue, 26 Dec 2017 03:29:25 -0500 Subject: [PATCH] osd: Use unqualified encode/decode This is a portion of Part 1 of the namespace project: using ADL properly in encode and decode so we can use namespaces easily in Ceph. Signed-off-by: Adam C. Emerson --- src/ceph_osd.cc | 2 +- src/osd/ECBackend.cc | 6 +- src/osd/ECMsgTypes.cc | 128 +-- src/osd/ECTransaction.cc | 6 +- src/osd/ECUtil.cc | 8 +- src/osd/ECUtil.h | 2 +- src/osd/HitSet.cc | 16 +- src/osd/HitSet.h | 32 +- src/osd/OSD.cc | 10 +- src/osd/OSDMap.cc | 799 +++++++-------- src/osd/OSDMap.h | 19 +- src/osd/PG.cc | 42 +- src/osd/PGBackend.cc | 4 +- src/osd/PGLog.cc | 20 +- src/osd/PGLog.h | 12 +- src/osd/PGTransaction.h | 4 +- src/osd/PrimaryLogPG.cc | 266 ++--- src/osd/ReplicatedBackend.cc | 20 +- src/osd/SnapMapper.cc | 24 +- src/osd/Watch.cc | 4 +- src/osd/osd_types.cc | 1835 +++++++++++++++++----------------- src/osd/osd_types.h | 252 ++--- 22 files changed, 1773 insertions(+), 1738 deletions(-) diff --git a/src/ceph_osd.cc b/src/ceph_osd.cc index c6fa76a96b088..4d7daf62d1333 100644 --- a/src/ceph_osd.cc +++ b/src/ceph_osd.cc @@ -209,7 +209,7 @@ int main(int argc, const char **argv) 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; diff --git a/src/osd/ECBackend.cc b/src/osd/ECBackend.cc index 89b928c3a9415..47b4d799a8976 100644 --- a/src/osd/ECBackend.cc +++ b/src/osd/ECBackend.cc @@ -443,7 +443,7 @@ void ECBackend::handle_recovery_read_complete( 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); } @@ -552,7 +552,7 @@ void ECBackend::continue_recovery_op( 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>> to_read; @@ -1775,7 +1775,7 @@ ECUtil::HashInfoRef ECBackend::get_hash_info( } 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; diff --git a/src/osd/ECMsgTypes.cc b/src/osd/ECMsgTypes.cc index e119bb86c8a31..62b83eedc1ba4 100644 --- a/src/osd/ECMsgTypes.cc +++ b/src/osd/ECMsgTypes.cc @@ -17,47 +17,47 @@ 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(); @@ -114,22 +114,22 @@ void ECSubWrite::generate_test_instances(list &o) 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); } @@ -167,8 +167,8 @@ void ECSubRead::encode(bufferlist &bl, uint64_t features) const { 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 >> tmp; for (map >>::const_iterator m = to_read.begin(); m != to_read.end(); ++m) { @@ -179,30 +179,30 @@ void ECSubRead::encode(bufferlist &bl, uint64_t features) const } 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 >>tmp; - ::decode(tmp, bl); + decode(tmp, bl); for (map >>::const_iterator m = tmp.begin(); m != tmp.end(); ++m) { list > tlist; @@ -213,11 +213,11 @@ void ECSubRead::decode(bufferlist::iterator &bl) 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)); @@ -296,22 +296,22 @@ void ECSubRead::generate_test_instances(list& o) 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); } diff --git a/src/osd/ECTransaction.cc b/src/osd/ECTransaction.cc index 8facdd130fba5..eaa5e75c39e4a 100644 --- a/src/osd/ECTransaction.cc +++ b/src/osd/ECTransaction.cc @@ -166,7 +166,7 @@ void ECTransaction::generate_transactions( 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); } @@ -192,7 +192,7 @@ void ECTransaction::generate_transactions( map > 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) { @@ -644,7 +644,7 @@ void ECTransaction::generate_transactions( 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)), diff --git a/src/osd/ECUtil.cc b/src/osd/ECUtil.cc index 361963268fb2e..6d538f0003404 100644 --- a/src/osd/ECUtil.cc +++ b/src/osd/ECUtil.cc @@ -179,16 +179,16 @@ void ECUtil::HashInfo::append(uint64_t old_size, 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); } diff --git a/src/osd/ECUtil.h b/src/osd/ECUtil.h index 1b00a095f6816..7daf1cfa6892b 100644 --- a/src/osd/ECUtil.h +++ b/src/osd/ECUtil.h @@ -167,6 +167,6 @@ typedef ceph::shared_ptr HashInfoRef; bool is_hinfo_key_string(const std::string &key); const std::string &get_hinfo_key(); -} WRITE_CLASS_ENCODER(ECUtil::HashInfo) +} #endif diff --git a/src/osd/HitSet.cc b/src/osd/HitSet.cc index c5f7cd5bf3969..7578be520afe6 100644 --- a/src/osd/HitSet.cc +++ b/src/osd/HitSet.cc @@ -45,12 +45,12 @@ HitSet::HitSet(const HitSet::Params& params) 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); } @@ -58,9 +58,9 @@ void HitSet::encode(bufferlist &bl) const 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); @@ -138,10 +138,10 @@ void HitSet::Params::encode(bufferlist &bl) const { 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); } @@ -171,7 +171,7 @@ void HitSet::Params::decode(bufferlist::iterator &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) diff --git a/src/osd/HitSet.h b/src/osd/HitSet.h index 4a578f7824db0..a846cb4a72aad 100644 --- a/src/osd/HitSet.h +++ b/src/osd/HitSet.h @@ -223,14 +223,14 @@ public: } 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; @@ -294,14 +294,14 @@ public: } 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; @@ -358,16 +358,16 @@ public: 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; @@ -431,12 +431,12 @@ public: 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; diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc index dc40e29a2b1a1..07cc701eb7fdd 100644 --- a/src/osd/OSD.cc +++ b/src/osd/OSD.cc @@ -1814,7 +1814,7 @@ int OSD::mkfs(CephContext *cct, ObjectStore *store, const string &dev, 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; @@ -1835,7 +1835,7 @@ int OSD::mkfs(CephContext *cct, ObjectStore *store, const string &dev, 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); @@ -3615,7 +3615,7 @@ void OSD::write_superblock(ObjectStore::Transaction& t) 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); } @@ -3627,7 +3627,7 @@ int OSD::read_superblock() return r; bufferlist::iterator p = bl.begin(); - ::decode(superblock, p); + decode(superblock, p); dout(10) << "read_superblock " << superblock << dendl; @@ -6743,7 +6743,7 @@ bool OSD::ms_verify_authorizer(Connection *con, int peer_type, bufferlist::iterator p = caps_info.caps.begin(); string str; try { - ::decode(str, p); + decode(str, p); } catch (buffer::error& e) { isvalid = false; diff --git a/src/osd/OSDMap.cc b/src/osd/OSDMap.cc index 25beae4ced03c..0d4059d4639b8 100644 --- a/src/osd/OSDMap.cc +++ b/src/osd/OSDMap.cc @@ -54,26 +54,28 @@ void osd_info_t::dump(Formatter *f) const 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& o) @@ -114,29 +116,29 @@ void osd_xinfo_t::dump(Formatter *f) const 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); @@ -348,66 +350,68 @@ bool OSDMap::subtree_type_is_down( 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 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; @@ -415,49 +419,50 @@ void OSDMap::Incremental::encode_classic(bufferlist& bl, uint64_t features) cons // 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; @@ -486,44 +491,44 @@ void OSDMap::Incremental::encode(bufferlist& bl, uint64_t features) const 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 } @@ -534,37 +539,37 @@ void OSDMap::Incremental::encode(bufferlist& bl, uint64_t features) const 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 @@ -583,73 +588,74 @@ void OSDMap::Incremental::encode(bufferlist& bl, uint64_t features) const 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 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. @@ -659,29 +665,30 @@ void OSDMap::Incremental::decode_classic(bufferlist::iterator &p) // 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 @@ -707,94 +714,94 @@ void OSDMap::Incremental::decode(bufferlist::iterator& bl) } { 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 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 @@ -814,9 +821,9 @@ void OSDMap::Incremental::decode(bufferlist::iterator& bl) 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; @@ -1470,6 +1477,7 @@ uint64_t OSDMap::get_up_osd_features() const void OSDMap::dedup(const OSDMap *o, OSDMap *n) { + using ceph::encode; if (o->epoch == n->epoch) return; @@ -1507,8 +1515,8 @@ void OSDMap::dedup(const OSDMap *o, OSDMap *n) // 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; } @@ -2238,120 +2246,123 @@ bool OSDMap::primary_changed( // 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; @@ -2381,14 +2392,14 @@ void OSDMap::encode(bufferlist& bl, uint64_t features) const } 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; @@ -2398,52 +2409,52 @@ void OSDMap::encode(bufferlist& bl, uint64_t features) const 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 } @@ -2457,39 +2468,39 @@ void OSDMap::encode(bufferlist& bl, uint64_t features) const 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 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(); @@ -2519,116 +2530,117 @@ void OSDMap::decode(bufferlist& bl) 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 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 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()); @@ -2639,6 +2651,7 @@ void OSDMap::decode_classic(bufferlist::iterator& p) 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 @@ -2663,36 +2676,36 @@ void OSDMap::decode(bufferlist::iterator& bl) { 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 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 { @@ -2701,63 +2714,63 @@ void OSDMap::decode(bufferlist::iterator& bl) // 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; @@ -2777,14 +2790,14 @@ void OSDMap::decode(bufferlist::iterator& bl) } } 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 { diff --git a/src/osd/OSDMap.h b/src/osd/OSDMap.h index 08bc57d00d24d..125ea0f4d830a 100644 --- a/src/osd/OSDMap.h +++ b/src/osd/OSDMap.h @@ -110,18 +110,20 @@ struct PGTempMap { 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; @@ -130,11 +132,11 @@ struct PGTempMap { offsets.resize(n); for (unsigned i=0; i& 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 get(pg_t pgid) { @@ -255,10 +258,10 @@ struct PGTempMap { mempool::osdmap::map > 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 diff --git a/src/osd/PG.cc b/src/osd/PG.cc index abc3ed36c9ddb..cfa5e73ee4c9c 100644 --- a/src/osd/PG.cc +++ b/src/osd/PG.cc @@ -3002,7 +3002,7 @@ void PG::upgrade(ObjectStore *store) if (info_struct_v < latest_struct_v) { map v; __u8 ver = latest_struct_v; - ::encode(ver, v[infover_key]); + encode(ver, v[infover_key]); t.omap_setkeys(coll, pgmeta_oid, v); } @@ -3040,7 +3040,7 @@ int PG::_prepare_write_info(CephContext* cct, PerfCounters *logger) { if (dirty_epoch) { - ::encode(epoch, (*km)[epoch_key]); + encode(epoch, (*km)[epoch_key]); } if (logger) @@ -3054,7 +3054,7 @@ int PG::_prepare_write_info(CephContext* cct, 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; @@ -3078,14 +3078,14 @@ int PG::_prepare_write_info(CephContext* cct, // info. store purged_snaps separately. interval_set 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); @@ -3109,8 +3109,8 @@ void PG::_init(ObjectStore::Transaction& t, spg_t pgid, const pg_pool_t *pool) 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); } @@ -3119,7 +3119,7 @@ void PG::_init(ObjectStore::Transaction& t, spg_t pgid, const pg_pool_t *pool) t.touch(coll, pgmeta_oid); map 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); } @@ -3190,12 +3190,12 @@ int PG::peek_map_epoch(ObjectStore *store, // 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; @@ -3402,20 +3402,20 @@ int PG::read_info( 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; @@ -3528,7 +3528,7 @@ void PG::update_snap_map( bufferlist snapbl = i->snaps; bufferlist::iterator p = snapbl.begin(); try { - ::decode(snaps, p); + decode(snaps, p); } catch (...) { snaps.clear(); } @@ -4076,7 +4076,7 @@ void PG::_scan_snaps(ScrubMap &smap) bl.push_back(o.attrs[SS_ATTR]); auto p = bl.begin(); try { - ::decode(snapset, p); + decode(snapset, p); } catch(...) { continue; } @@ -4173,7 +4173,7 @@ void PG::_repair_oinfo_oid(ScrubMap &smap) // 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; @@ -4259,7 +4259,7 @@ void PG::repair_object( 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); @@ -4340,7 +4340,7 @@ void PG::replica_scrub( 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()); } diff --git a/src/osd/PGBackend.cc b/src/osd/PGBackend.cc index 3221799dc1815..d3759a4b266e5 100644 --- a/src/osd/PGBackend.cc +++ b/src/osd/PGBackend.cc @@ -830,7 +830,7 @@ map::const_iterator 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(); @@ -849,7 +849,7 @@ map::const_iterator 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(); diff --git a/src/osd/PGLog.cc b/src/osd/PGLog.cc index fbaf952331457..39c35b50bcfde 100644 --- a/src/osd/PGLog.cc +++ b/src/osd/PGLog.cc @@ -753,7 +753,7 @@ void PGLog::_write_log_and_missing_wo_missing( if (entry.version > dirty_to_dups) break; bufferlist bl; - ::encode(entry, bl); + encode(entry, bl); (*km)[entry.get_key_name()].claim(bl); } @@ -763,19 +763,19 @@ void PGLog::_write_log_and_missing_wo_missing( 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"]); } @@ -883,7 +883,7 @@ void PGLog::_write_log_and_missing( if (entry.version > dirty_to_dups) break; bufferlist bl; - ::encode(entry, bl); + encode(entry, bl); (*km)[entry.get_key_name()].claim(bl); } @@ -893,7 +893,7 @@ void PGLog::_write_log_and_missing( p->version >= dirty_to_dups; ++p) { bufferlist bl; - ::encode(*p, bl); + encode(*p, bl); (*km)[p->get_key_name()].claim(bl); } @@ -915,14 +915,14 @@ void PGLog::_write_log_and_missing( 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"]); } diff --git a/src/osd/PGLog.h b/src/osd/PGLog.h index e9c3f126eb165..eea57c2fa3056 100644 --- a/src/osd/PGLog.h +++ b/src/osd/PGLog.h @@ -1310,29 +1310,29 @@ public: 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); } diff --git a/src/osd/PGTransaction.h b/src/osd/PGTransaction.h index 68a68b36b7397..2e0fdfbb702c5 100644 --- a/src/osd/PGTransaction.h +++ b/src/osd/PGTransaction.h @@ -454,7 +454,7 @@ public: map &keys ///< [in] omap keys, may be cleared ) { bufferlist bl; - ::encode(keys, bl); + encode(keys, bl); omap_setkeys(hoid, bl); } void omap_rmkeys( @@ -472,7 +472,7 @@ public: set &keys ///< [in] omap keys, may be cleared ) { bufferlist bl; - ::encode(keys, bl); + encode(keys, bl); omap_rmkeys(hoid, bl); } void omap_setheader( diff --git a/src/osd/PrimaryLogPG.cc b/src/osd/PrimaryLogPG.cc index f10998200dee7..b0e769433f5d0 100644 --- a/src/osd/PrimaryLogPG.cc +++ b/src/osd/PrimaryLogPG.cc @@ -393,7 +393,7 @@ void PrimaryLogPG::on_local_recover( 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); @@ -779,8 +779,8 @@ public: 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; } @@ -802,7 +802,7 @@ public: int init(bufferlist::iterator ¶ms) override { try { - ::decode(parent_ino, params); + decode(parent_ino, params); } catch (buffer::error &e) { return -EINVAL; } @@ -823,13 +823,13 @@ bool PGLSParentFilter::filter(const hobject_t &obj, generic_dout(0) << "PGLSParentFilter::filter" << dendl; - ::decode(bt, iter); + decode(bt, iter); vector::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; } } @@ -876,7 +876,7 @@ int PrimaryLogPG::get_pgls_filter(bufferlist::iterator& iter, PGLSFilter **pfilt PGLSFilter *filter; try { - ::decode(type, iter); + decode(type, iter); } catch (buffer::error& e) { return -EINVAL; @@ -1144,8 +1144,8 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) 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; @@ -1182,7 +1182,7 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) vector 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; @@ -1304,9 +1304,9 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) 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; } @@ -1314,8 +1314,8 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) 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; @@ -1352,7 +1352,7 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) vector 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; @@ -1438,9 +1438,9 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) 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; } @@ -1455,7 +1455,7 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) 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; @@ -1469,7 +1469,7 @@ void PrimaryLogPG::do_pg_op(OpRequestRef op) 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. @@ -1556,7 +1556,7 @@ int PrimaryLogPG::do_scrub_ls(MOSDOp *m, OSDOp *osd_op) arg.start_after, arg.max_return); } - ::encode(result, osd_op->outdata); + encode(result, osd_op->outdata); return r; } @@ -3976,7 +3976,7 @@ void PrimaryLogPG::do_scan( 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; @@ -4246,7 +4246,7 @@ int PrimaryLogPG::trim_object( 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( @@ -4331,11 +4331,11 @@ int PrimaryLogPG::trim_object( map 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); @@ -4506,8 +4506,8 @@ int PrimaryLogPG::do_tmapup_slow(OpContext *ctx, bufferlist::iterator& bp, OSDOp map m; if (bl.length()) { bufferlist::iterator p = bl.begin(); - ::decode(header, p); - ::decode(m, p); + decode(header, p); + decode(m, p); assert(p.end()); } @@ -4515,31 +4515,31 @@ int PrimaryLogPG::do_tmapup_slow(OpContext *ctx, bufferlist::iterator& bp, OSDOp 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: @@ -4549,8 +4549,8 @@ int PrimaryLogPG::do_tmapup_slow(OpContext *ctx, bufferlist::iterator& bp, OSDOp // reencode bufferlist obl; - ::encode(header, obl); - ::encode(m, obl); + encode(header, obl); + encode(m, obl); // write it out vector nops(1); @@ -4596,18 +4596,18 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd 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; @@ -4618,15 +4618,15 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd 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; @@ -4649,8 +4649,8 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd 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. @@ -4659,8 +4659,8 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd nkeys--; } if (!ip.end()) { - ::decode(nextkey, ip); - ::decode(nextval, ip); + decode(nextkey, ip); + decode(nextval, ip); } else { have_next = false; } @@ -4669,13 +4669,13 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd 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) { @@ -4684,13 +4684,13 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd } 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) { @@ -4708,8 +4708,8 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd // 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()) { @@ -4722,7 +4722,7 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd // 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) { @@ -4733,9 +4733,9 @@ int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd // sanity check bufferlist::iterator tp = obl.begin(); bufferlist h; - ::decode(h, tp); + decode(h, tp); map d; - ::decode(d, tp); + decode(d, tp); assert(tp.end()); dout(0) << " **** debug sanity check, looks ok ****" << dendl; } @@ -4824,7 +4824,7 @@ struct ToSparseReadResult : public Context { *len = r; bufferlist outdata; map extents = {{data_offset, r}}; - ::encode(extents, outdata); + encode(extents, outdata); ::encode_destructively(*data_bl, outdata); data_bl->swap(outdata); } @@ -5065,7 +5065,7 @@ int PrimaryLogPG::finish_checksum(OSDOp& osd_op, 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( init_value, csum_chunk_size, 0, read_bl.length(), read_bl, &csum_data); @@ -5074,7 +5074,7 @@ int PrimaryLogPG::finish_checksum(OSDOp& osd_op, 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( init_value, csum_chunk_size, 0, read_bl.length(), read_bl, &csum_data); @@ -5083,7 +5083,7 @@ int PrimaryLogPG::finish_checksum(OSDOp& osd_op, 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( init_value, csum_chunk_size, 0, read_bl.length(), read_bl, &csum_data); @@ -5094,7 +5094,7 @@ int PrimaryLogPG::finish_checksum(OSDOp& osd_op, } } - ::encode(csum_count, osd_op.outdata); + encode(csum_count, osd_op.outdata); osd_op.outdata.claim_append(csum); return 0; } @@ -5335,7 +5335,7 @@ int PrimaryLogPG::do_sparse_read(OpContext *ctx, OSDOp& osd_op) { } else { dout(10) << " sparse read ended up empty for " << soid << dendl; map extents; - ::encode(extents, osd_op.outdata); + encode(extents, osd_op.outdata); } } else { // read into a buffer @@ -5426,7 +5426,7 @@ int PrimaryLogPG::do_sparse_read(OpContext *ctx, OSDOp& osd_op) { 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 " @@ -5678,8 +5678,8 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -5695,7 +5695,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) { 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; } @@ -5859,7 +5859,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) &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); @@ -5902,7 +5902,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) { uint64_t u64val; try { - ::decode(u64val, bp); + decode(u64val, bp); } catch (buffer::error& e) { result = -EINVAL; @@ -6072,9 +6072,9 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; } @@ -6090,7 +6090,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -6100,11 +6100,11 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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); @@ -6330,7 +6330,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) bufferlist::iterator p = osd_op.indata.begin(); string category; try { - ::decode(category, p); + decode(category, p); } catch (buffer::error& e) { result = -EINVAL; @@ -6561,8 +6561,8 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -6629,11 +6629,11 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -6782,16 +6782,16 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -6813,12 +6813,12 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) bp = osd_op.indata.begin(); bufferlist header; map 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); @@ -6849,8 +6849,8 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -6877,12 +6877,12 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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++; } @@ -6895,9 +6895,9 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -6932,13 +6932,13 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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++; } @@ -6963,7 +6963,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) { set keys_to_get; try { - ::decode(keys_to_get, bp); + decode(keys_to_get, bp); } catch (buffer::error& e) { result = -EINVAL; @@ -6975,7 +6975,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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++; } @@ -6991,7 +6991,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) } map > assertions; try { - ::decode(assertions, bp); + decode(assertions, bp); } catch (buffer::error& e) { result = -EINVAL; @@ -7080,7 +7080,7 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) dout(20) << "setting vals: " << dendl; map to_set; bufferlist::iterator pt = to_set_bl.begin(); - ::decode(to_set, pt); + decode(to_set, pt); for (map::iterator i = to_set.begin(); i != to_set.end(); ++i) { @@ -7180,8 +7180,8 @@ int PrimaryLogPG::do_osd_ops(OpContext *ctx, vector& ops) 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; @@ -7274,7 +7274,7 @@ int PrimaryLogPG::_get_tmap(OpContext *ctx, bufferlist *header, bufferlist *vals 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 @@ -7562,7 +7562,7 @@ void PrimaryLogPG::_make_clone( 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); @@ -7695,7 +7695,7 @@ void PrimaryLogPG::make_writeable(OpContext *ctx) 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++; } @@ -8003,7 +8003,7 @@ void PrimaryLogPG::finish_ctx(OpContext *ctx, int log_op_type) // object_info_t map 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); @@ -8012,7 +8012,7 @@ void PrimaryLogPG::finish_ctx(OpContext *ctx, int log_op_type) 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; @@ -8035,7 +8035,7 @@ void PrimaryLogPG::finish_ctx(OpContext *ctx, int log_op_type) 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; @@ -8173,7 +8173,7 @@ struct C_CopyFrom_AsyncReadCb : public Context { 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); } }; @@ -8209,8 +8209,8 @@ int PrimaryLogPG::do_copy_get(OpContext *ctx, bufferlist::iterator& bp, 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; @@ -8319,14 +8319,14 @@ int PrimaryLogPG::do_copy_get(OpContext *ctx, bufferlist::iterator& bp, 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()) { @@ -8355,7 +8355,7 @@ int PrimaryLogPG::do_copy_get(OpContext *ctx, bufferlist::iterator& bp, << 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; @@ -8379,7 +8379,7 @@ void PrimaryLogPG::fill_in_copy_get_noent(OpRequestRef& op, hobject_t oid, 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); @@ -8950,7 +8950,7 @@ void PrimaryLogPG::_write_copy_chunk(CopyOpRef cop, PGTransaction *t) if (cop->omap_data.length()) { map 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(); } @@ -10413,7 +10413,7 @@ void PrimaryLogPG::handle_watch_timeout(WatchRef watch) 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. @@ -10497,7 +10497,7 @@ ObjectContextRef PrimaryLogPG::get_object_context( 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! @@ -13258,7 +13258,7 @@ void PrimaryLogPG::hit_set_persist() return; hit_set->seal(); - ::encode(*hit_set, bl); + encode(*hit_set, bl); dout(20) << __func__ << " archive " << oid << dendl; if (agent_state) { @@ -13301,9 +13301,9 @@ void PrimaryLogPG::hit_set_persist() 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); @@ -13626,7 +13626,7 @@ void PrimaryLogPG::agent_load_hit_sets() } HitSetRef hs(new HitSet); bufferlist::iterator pbl = bl.begin(); - ::decode(*hs, pbl); + decode(*hs, pbl); agent_state->add_hit_set(p->begin.sec(), hs); } } @@ -14417,7 +14417,7 @@ void PrimaryLogPG::scrub_snapshot_metadata( 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 @@ -14673,7 +14673,7 @@ int PrimaryLogPG::rep_repair_primary_object(const hobject_t& soid, OpRequestRef << 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 diff --git a/src/osd/ReplicatedBackend.cc b/src/osd/ReplicatedBackend.cc index 2a05348eecca9..a4b30a0980e56 100644 --- a/src/osd/ReplicatedBackend.cc +++ b/src/osd/ReplicatedBackend.cc @@ -311,7 +311,7 @@ void generate_transaction( 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); } @@ -712,7 +712,7 @@ void ReplicatedBackend::be_deep_scrub( if (seed == 0) { // legacy bufferlist bl; - ::encode(hdrbl, bl); + encode(hdrbl, bl); oh << bl; } else { oh << hdrbl; @@ -742,8 +742,8 @@ void ReplicatedBackend::be_deep_scrub( 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(); } @@ -968,13 +968,13 @@ Message * ReplicatedBackend::generate_subop( << ", 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 @@ -1082,7 +1082,7 @@ void ReplicatedBackend::do_repop(OpRequestRef op) vector log; bufferlist::iterator p = const_cast(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; @@ -1099,7 +1099,7 @@ void ReplicatedBackend::do_repop(OpRequestRef op) } p = const_cast(m->logbl).begin(); - ::decode(log, p); + decode(log, p); rm->opt.set_fadvise_flag(CEPH_OSD_OP_FLAG_FADVISE_DONTNEED); bool update_snaps = false; @@ -1915,7 +1915,7 @@ int ReplicatedBackend::build_push_op(const ObjectRecoveryInfo &recovery_info, 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; diff --git a/src/osd/SnapMapper.cc b/src/osd/SnapMapper.cc index ab1affb8f25e5..03e54c3f03743 100644 --- a/src/osd/SnapMapper.cc +++ b/src/osd/SnapMapper.cc @@ -59,14 +59,14 @@ struct Mapping { 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); } }; @@ -92,7 +92,7 @@ pair SnapMapper::to_raw( const pair &in) { bufferlist bl; - ::encode(Mapping(in), bl); + encode(Mapping(in), bl); return make_pair( to_raw_key(in), bl); @@ -104,7 +104,7 @@ pair SnapMapper::from_raw( Mapping map; bufferlist bl(image.second); bufferlist::iterator bp(bl.begin()); - ::decode(map, bp); + decode(map, bp); return make_pair(map.snap, map.hoid); } @@ -121,16 +121,16 @@ string SnapMapper::to_object_key(const hobject_t &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); } @@ -153,7 +153,7 @@ int SnapMapper::get_snaps( } 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 { @@ -186,7 +186,7 @@ void SnapMapper::set_snaps( assert(check(oid)); map 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)) { diff --git a/src/osd/Watch.cc b/src/osd/Watch.cc index 4579b8a2b299e..3d6985567e06a 100644 --- a/src/osd/Watch.cc +++ b/src/osd/Watch.cc @@ -185,13 +185,13 @@ void Notify::maybe_complete_notify() if (watchers.empty() || timed_out) { // prepare reply bufferlist bl; - ::encode(notify_replies, bl); + encode(notify_replies, bl); list > missed; for (set::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, diff --git a/src/osd/osd_types.cc b/src/osd/osd_types.cc index 191418020b809..98f12fe404169 100644 --- a/src/osd/osd_types.cc +++ b/src/osd/osd_types.cc @@ -140,15 +140,15 @@ string ceph_osd_alloc_hint_flag_string(unsigned flags) 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); } @@ -183,12 +183,12 @@ void object_locator_t::encode(bufferlist& bl) const 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); @@ -199,20 +199,20 @@ void object_locator_t::decode(bufferlist::iterator& p) 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); @@ -242,18 +242,18 @@ void object_locator_t::generate_test_instances(list& o) 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); } @@ -283,16 +283,16 @@ void objectstore_perf_stat_t::dump(Formatter *f) const 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); } @@ -330,42 +330,42 @@ void osd_stat_t::dump(Formatter *f) const 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 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); } @@ -656,19 +656,20 @@ bool coll_t::parse(const std::string& s) 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); } } @@ -701,14 +702,15 @@ size_t coll_t::encoded_size() const 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) { @@ -724,9 +726,9 @@ void coll_t::decode(bufferlist::iterator& bl) { __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; } @@ -735,7 +737,7 @@ void coll_t::decode(bufferlist::iterator& bl) 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); @@ -940,27 +942,28 @@ void pool_snap_info_t::dump(Formatter *f) const 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); } @@ -1081,16 +1084,16 @@ public: explicit pool_opts_encoder_t(bufferlist& bl_) : bl(bl_) {} void operator()(std::string s) const { - ::encode(static_cast(pool_opts_t::STR), bl); - ::encode(s, bl); + encode(static_cast(pool_opts_t::STR), bl); + encode(s, bl); } void operator()(int i) const { - ::encode(static_cast(pool_opts_t::INT), bl); - ::encode(i, bl); + encode(static_cast(pool_opts_t::INT), bl); + encode(i, bl); } void operator()(double d) const { - ::encode(static_cast(pool_opts_t::DOUBLE), bl); - ::encode(d, bl); + encode(static_cast(pool_opts_t::DOUBLE), bl); + encode(d, bl); } private: @@ -1100,9 +1103,9 @@ private: void pool_opts_t::encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); uint32_t n = static_cast(opts.size()); - ::encode(n, bl); + encode(n, bl); for (opts_t::const_iterator i = opts.begin(); i != opts.end(); ++i) { - ::encode(static_cast(i->first), bl); + encode(static_cast(i->first), bl); boost::apply_visitor(pool_opts_encoder_t(bl), i->second); } ENCODE_FINISH(bl); @@ -1111,23 +1114,23 @@ void pool_opts_t::encode(bufferlist& bl) const { 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(k)] = s; } else if (t == INT) { int i; - ::decode(i, bl); + decode(i, bl); opts[static_cast(k)] = i; } else if (t == DOUBLE) { double d; - ::decode(d, bl); + decode(d, bl); opts[static_cast(k)] = d; } else { assert(!"invalid type"); @@ -1446,55 +1449,56 @@ uint32_t pg_pool_t::get_random_pg_position(pg_t pg, uint32_t seed) const 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; } @@ -1505,44 +1509,44 @@ void pg_pool_t::encode(bufferlist& bl, uint64_t features) const // 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; } @@ -1558,77 +1562,77 @@ void pg_pool_t::encode(bufferlist& bl, uint64_t features) const } 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); } @@ -1636,38 +1640,38 @@ void pg_pool_t::encode(bufferlist& bl, uint64_t features) const 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; } @@ -1680,47 +1684,47 @@ void pg_pool_t::decode(bufferlist::iterator& bl) } } 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; @@ -1730,60 +1734,60 @@ void pg_pool_t::decode(bufferlist::iterator& bl) 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(); @@ -1968,42 +1972,42 @@ void object_stat_sum_t::encode(bufferlist& bl) const #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); } @@ -2019,47 +2023,47 @@ void object_stat_sum_t::decode(bufferlist::iterator& 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); @@ -2237,18 +2241,18 @@ void object_stat_collection_t::dump(Formatter *f) const 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 cat_sum; - ::decode(cat_sum, bl); + decode(cat_sum, bl); } DECODE_FINISH(bl); } @@ -2366,49 +2370,49 @@ void pg_stat_t::dump_brief(Formatter *f) const 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); } @@ -2417,61 +2421,61 @@ void pg_stat_t::decode(bufferlist::iterator &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); @@ -2586,21 +2590,22 @@ void pool_stat_t::dump(Formatter *f) const 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); } @@ -2608,35 +2613,35 @@ void pool_stat_t::decode(bufferlist::iterator &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); @@ -2663,55 +2668,55 @@ void pool_stat_t::generate_test_instances(list& o) 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; @@ -2725,7 +2730,7 @@ void pg_history_t::decode(bufferlist::iterator &bl) } } if (struct_v >= 9) { - ::decode(epoch_pool_created, bl); + decode(epoch_pool_created, bl); } else { epoch_pool_created = epoch_created; } @@ -2780,50 +2785,50 @@ void pg_history_t::generate_test_instances(list& o) 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; } @@ -2898,22 +2903,22 @@ void pg_info_t::generate_test_instances(list& o) 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); } @@ -2953,32 +2958,32 @@ ostream &operator<<(ostream &lhs, const pg_notify_t ¬ify) 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]; @@ -3055,16 +3060,16 @@ struct compact_interval_t { } 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 & o) { @@ -3149,18 +3154,18 @@ public: } 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 { @@ -3262,7 +3267,7 @@ void PastIntervals::decode(bufferlist::iterator &bl) { DECODE_START(1, bl); __u8 type = 0; - ::decode(type, bl); + decode(type, bl); switch (type) { case 0: break; @@ -3585,23 +3590,23 @@ ostream& operator<<(ostream& out, const PastIntervals::pg_interval_t& i) 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); } @@ -3638,23 +3643,23 @@ void ObjectModDesc::visit(Visitor *visitor) const 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 > 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; } @@ -3664,21 +3669,21 @@ void ObjectModDesc::visit(Visitor *visitor) const } case UPDATE_SNAPS: { set 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 > extents; version_t gen; - ::decode(gen, bp); - ::decode(extents, bp); + decode(gen, bp); + decode(extents, bp); visitor->rollback_extents(gen,extents); break; } @@ -3785,18 +3790,18 @@ void ObjectModDesc::generate_test_instances(list& o) 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); @@ -3812,31 +3817,33 @@ string pg_log_entry_t::get_key_name() const 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: @@ -3846,79 +3853,79 @@ void pg_log_entry_t::encode(bufferlist &bl) const * 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); } @@ -3946,7 +3953,8 @@ void pg_log_entry_t::dump(Formatter *f) const bufferlist c = snaps; bufferlist::iterator p = c.begin(); try { - ::decode(v, p); + using ceph::decode; + decode(v, p); } catch (...) { v.clear(); } @@ -3985,7 +3993,7 @@ ostream& operator<<(ostream& out, const pg_log_entry_t& e) bufferlist c = e.snaps; bufferlist::iterator p = c.begin(); try { - ::decode(snaps, p); + decode(snaps, p); } catch (...) { snaps.clear(); } @@ -4009,20 +4017,20 @@ std::string pg_log_dup_t::get_key_name() const 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); } @@ -4096,35 +4104,35 @@ void pg_log_t::filter_log(spg_t import_pgid, const OSDMap &curmap, 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); @@ -4257,22 +4265,22 @@ ostream& operator<<(ostream& out, const pg_missing_item& i) 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); } @@ -4306,21 +4314,21 @@ void object_copy_cursor_t::generate_test_instances(list& 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); } @@ -4329,58 +4337,60 @@ void object_copy_data_t::decode(bufferlist::iterator& 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 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); @@ -4410,7 +4420,8 @@ void object_copy_data_t::generate_test_instances(list& o) bl2.push_back(bp2); map 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"); @@ -4456,18 +4467,18 @@ void object_copy_data_t::dump(Formatter *f) const 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); } @@ -4490,21 +4501,21 @@ void pg_create_t::generate_test_instances(list& o) 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; } @@ -4533,32 +4544,32 @@ void pg_hit_set_info_t::generate_test_instances(list& ls) 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); } @@ -4588,18 +4599,18 @@ void pg_hit_set_history_t::generate_test_instances(list& 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 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 pool_last_epoch_marked_full ENCODE_FINISH(bl); } @@ -4608,30 +4619,30 @@ void OSDSuperblock::decode(bufferlist::iterator &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 pool_last_map_marked_full; - ::decode(pool_last_map_marked_full, bl); + decode(pool_last_map_marked_full, bl); } DECODE_FINISH(bl); } @@ -4673,27 +4684,27 @@ void OSDSuperblock::generate_test_instances(list& o) 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(); } @@ -4829,23 +4840,23 @@ SnapSet SnapSet::get_filtered(const pg_pool_t &pinfo) const 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); } @@ -4882,20 +4893,20 @@ void watch_info_t::generate_test_instances(list& o) 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); } @@ -4920,14 +4931,14 @@ ostream& operator<<(ostream& out, const chunk_info_t& ci) 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(); @@ -4938,14 +4949,14 @@ void object_manifest_t::encode(bufferlist& bl) const 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(); @@ -5018,38 +5029,38 @@ void object_info_t::encode(bufferlist& bl, uint64_t features) const 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); } @@ -5059,42 +5070,42 @@ void object_info_t::decode(bufferlist::iterator& bl) object_locator_t myoloc; DECODE_START_LEGACY_COMPAT_LEN(17, 8, 8, bl); map 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 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 { @@ -5103,7 +5114,7 @@ void object_info_t::decode(bufferlist::iterator& bl) if (struct_v < 10) soid.pool = myoloc.pool; if (struct_v >= 11) { - ::decode(watchers, bl); + decode(watchers, bl); } else { for (map::iterator i = old_watchers.begin(); i != old_watchers.end(); @@ -5115,26 +5126,26 @@ void object_info_t::decode(bufferlist::iterator& bl) } 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; @@ -5142,7 +5153,7 @@ void object_info_t::decode(bufferlist::iterator& bl) } if (struct_v >= 17) { if (has_manifest()) { - ::decode(manifest, bl); + decode(manifest, bl); } } DECODE_FINISH(bl); @@ -5215,22 +5226,22 @@ ostream& operator<<(ostream& out, const object_info_t& oi) 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); } @@ -5279,13 +5290,13 @@ void ObjectRecoveryProgress::dump(Formatter *f) const 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); } @@ -5293,13 +5304,13 @@ void ObjectRecoveryInfo::decode(bufferlist::iterator &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) { @@ -5376,14 +5387,14 @@ void PushReplyOp::generate_test_instances(list &o) 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); } @@ -5426,18 +5437,18 @@ void PullOp::generate_test_instances(list &o) 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); } @@ -5491,32 +5502,32 @@ void PushOp::generate_test_instances(list &o) 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); } @@ -5604,27 +5615,27 @@ void ScrubMap::merge_incr(const ScrubMap &l) 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 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 @@ -5678,65 +5689,65 @@ void ScrubMap::object::encode(bufferlist& bl) const { 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 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); } diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h index d6f1b5b4ff689..2eb347eabaae7 100644 --- a/src/osd/osd_types.h +++ b/src/osd/osd_types.h @@ -425,22 +425,25 @@ struct pg_t { 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; @@ -545,14 +548,14 @@ struct spg_t { 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); } @@ -822,16 +825,16 @@ public: #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) { @@ -2516,52 +2519,52 @@ struct pg_fast_info_t { 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); } }; @@ -2688,10 +2691,10 @@ public: 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); } @@ -3197,15 +3200,16 @@ public: 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 > &old_attrs) { @@ -3213,7 +3217,7 @@ public: 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) { @@ -3221,7 +3225,7 @@ public: 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; @@ -3231,7 +3235,7 @@ public: 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; @@ -3249,7 +3253,7 @@ public: return; ENCODE_START(1, 1, bl); append_id(UPDATE_SNAPS); - ::encode(old_snaps, bl); + encode(old_snaps, bl); ENCODE_FINISH(bl); } void rollback_extents( @@ -3260,8 +3264,8 @@ public: 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); } @@ -3689,34 +3693,36 @@ struct pg_missing_item { } 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(flags), bl); + encode(e, bl); + encode(need, bl); + encode(have, bl); + encode(static_cast(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(f); } } @@ -3989,17 +3995,17 @@ public: 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); @@ -4152,27 +4158,27 @@ struct pg_nls_response_t { 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::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); @@ -4220,17 +4226,19 @@ struct pg_ls_response_t { list > 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; @@ -5022,19 +5030,19 @@ struct watch_item_t { 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); } @@ -5055,12 +5063,12 @@ struct obj_list_watch_response_t { 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 { @@ -5108,18 +5116,18 @@ struct clone_info { 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 { @@ -5170,15 +5178,15 @@ struct obj_list_snap_response_t { 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); -- 2.39.5