From 271a8a8dd1a83fca2dc485a3ed158a5457a8363b Mon Sep 17 00:00:00 2001 From: "Adam C. Emerson" Date: Fri, 22 Dec 2017 02:19:58 -0500 Subject: [PATCH] common: Use unqualified encoding in the rest of the files And now we're done with this directory, for now. Signed-off-by: Adam C. Emerson --- src/common/DecayCounter.cc | 16 ++--- src/common/LogEntry.cc | 50 +++++++------- src/common/SloppyCRCMap.cc | 8 +-- src/common/entity_name.h | 10 +-- src/common/fs_types.cc | 26 +++---- src/common/histogram.cc | 4 +- src/common/hobject.cc | 68 +++++++++--------- src/common/mClockCommon.h | 4 +- src/common/obj_bencher.cc | 16 ++--- src/common/scrub_types.cc | 137 +++++++++++++++++++------------------ src/common/scrub_types.h | 4 +- src/common/snap_types.cc | 14 ++-- src/common/snap_types.h | 10 +-- src/common/zipkin_trace.h | 12 ++-- 14 files changed, 196 insertions(+), 183 deletions(-) diff --git a/src/common/DecayCounter.cc b/src/common/DecayCounter.cc index 67a129ccd09..139332237f2 100644 --- a/src/common/DecayCounter.cc +++ b/src/common/DecayCounter.cc @@ -18,9 +18,9 @@ void DecayCounter::encode(bufferlist& bl) const { ENCODE_START(4, 4, bl); - ::encode(val, bl); - ::encode(delta, bl); - ::encode(vel, bl); + encode(val, bl); + encode(delta, bl); + encode(vel, bl); ENCODE_FINISH(bl); } @@ -29,15 +29,15 @@ void DecayCounter::decode(const utime_t &t, bufferlist::iterator &p) DECODE_START_LEGACY_COMPAT_LEN(4, 4, 4, p); if (struct_v < 2) { double half_life; - ::decode(half_life, p); + decode(half_life, p); } if (struct_v < 3) { double k; - ::decode(k, p); + decode(k, p); } - ::decode(val, p); - ::decode(delta, p); - ::decode(vel, p); + decode(val, p); + decode(delta, p); + decode(vel, p); DECODE_FINISH(p); } diff --git a/src/common/LogEntry.cc b/src/common/LogEntry.cc index d9100fc46a2..72ec66413ae 100644 --- a/src/common/LogEntry.cc +++ b/src/common/LogEntry.cc @@ -13,16 +13,18 @@ void LogEntryKey::encode(bufferlist& bl, uint64_t features) const { - ::encode(who, bl, features); - ::encode(stamp, bl); - ::encode(seq, bl); + using ceph::encode; + encode(who, bl, features); + encode(stamp, bl); + encode(seq, bl); } void LogEntryKey::decode(bufferlist::iterator& bl) { - ::decode(who, bl); - ::decode(stamp, bl); - ::decode(seq, bl); + using ceph::decode; + decode(who, bl); + decode(stamp, bl); + decode(seq, bl); _calc_hash(); } @@ -208,13 +210,13 @@ void LogEntry::encode(bufferlist& bl, uint64_t features) const { ENCODE_START(4, 2, bl); __u16 t = prio; - ::encode(who, bl, features); - ::encode(stamp, bl); - ::encode(seq, bl); - ::encode(t, bl); - ::encode(msg, bl); - ::encode(channel, bl); - ::encode(name, bl); + encode(who, bl, features); + encode(stamp, bl); + encode(seq, bl); + encode(t, bl); + encode(msg, bl); + encode(channel, bl); + encode(name, bl); ENCODE_FINISH(bl); } @@ -222,14 +224,14 @@ void LogEntry::decode(bufferlist::iterator& bl) { DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl); __u16 t; - ::decode(who, bl); - ::decode(stamp, bl); - ::decode(seq, bl); - ::decode(t, bl); + decode(who, bl); + decode(stamp, bl); + decode(seq, bl); + decode(t, bl); prio = (clog_type)t; - ::decode(msg, bl); + decode(msg, bl); if (struct_v >= 3) { - ::decode(channel, bl); + decode(channel, bl); } else { // prior to having logging channels we only had a cluster log. // Ensure we keep that appearance when the other party has no @@ -237,7 +239,7 @@ void LogEntry::decode(bufferlist::iterator& bl) channel = CLOG_CHANNEL_CLUSTER; } if (struct_v >= 4) { - ::decode(name, bl); + decode(name, bl); } DECODE_FINISH(bl); } @@ -264,16 +266,16 @@ void LogEntry::generate_test_instances(list& o) void LogSummary::encode(bufferlist& bl, uint64_t features) const { ENCODE_START(2, 2, bl); - ::encode(version, bl); - ::encode(tail, bl, features); + encode(version, bl); + encode(tail, bl, features); ENCODE_FINISH(bl); } void LogSummary::decode(bufferlist::iterator& bl) { DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl); - ::decode(version, bl); - ::decode(tail, bl); + decode(version, bl); + decode(tail, bl); DECODE_FINISH(bl); keys.clear(); for (auto& p : tail) { diff --git a/src/common/SloppyCRCMap.cc b/src/common/SloppyCRCMap.cc index c637f7a257a..0868325bb4a 100644 --- a/src/common/SloppyCRCMap.cc +++ b/src/common/SloppyCRCMap.cc @@ -141,8 +141,8 @@ void SloppyCRCMap::clone_range(uint64_t offset, uint64_t len, void SloppyCRCMap::encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); - ::encode(block_size, bl); - ::encode(crc_map, bl); + encode(block_size, bl); + encode(crc_map, bl); ENCODE_FINISH(bl); } @@ -150,9 +150,9 @@ void SloppyCRCMap::decode(bufferlist::iterator& bl) { DECODE_START(1, bl); uint32_t bs; - ::decode(bs, bl); + decode(bs, bl); set_block_size(bs); - ::decode(crc_map, bl); + decode(crc_map, bl); DECODE_FINISH(bl); } diff --git a/src/common/entity_name.h b/src/common/entity_name.h index e30b75f701f..44edebb0486 100644 --- a/src/common/entity_name.h +++ b/src/common/entity_name.h @@ -29,14 +29,16 @@ struct EntityName EntityName(); void encode(bufferlist& bl) const { - ::encode(type, bl); - ::encode(id, bl); + using ceph::encode; + encode(type, bl); + encode(id, bl); } void decode(bufferlist::iterator& bl) { + using ceph::decode; uint32_t type_; std::string id_; - ::decode(type_, bl); - ::decode(id_, bl); + decode(type_, bl); + decode(id_, bl); set(type_, id_); } diff --git a/src/common/fs_types.cc b/src/common/fs_types.cc index 929f3f28806..2a19ab85b1f 100644 --- a/src/common/fs_types.cc +++ b/src/common/fs_types.cc @@ -70,37 +70,39 @@ void file_layout_t::to_legacy(ceph_file_layout *fl) const void file_layout_t::encode(bufferlist& bl, uint64_t features) const { + using ceph::encode; if ((features & CEPH_FEATURE_FS_FILE_LAYOUT_V2) == 0) { ceph_file_layout fl; assert((stripe_unit & 0xff) == 0); // first byte must be 0 to_legacy(&fl); - ::encode(fl, bl); + encode(fl, bl); return; } ENCODE_START(2, 2, bl); - ::encode(stripe_unit, bl); - ::encode(stripe_count, bl); - ::encode(object_size, bl); - ::encode(pool_id, bl); - ::encode(pool_ns, bl); + encode(stripe_unit, bl); + encode(stripe_count, bl); + encode(object_size, bl); + encode(pool_id, bl); + encode(pool_ns, bl); ENCODE_FINISH(bl); } void file_layout_t::decode(bufferlist::iterator& p) { + using ceph::decode; if (*p == 0) { ceph_file_layout fl; - ::decode(fl, p); + decode(fl, p); from_legacy(fl); return; } DECODE_START(2, p); - ::decode(stripe_unit, p); - ::decode(stripe_count, p); - ::decode(object_size, p); - ::decode(pool_id, p); - ::decode(pool_ns, p); + decode(stripe_unit, p); + decode(stripe_count, p); + decode(object_size, p); + decode(pool_id, p); + decode(pool_ns, p); DECODE_FINISH(p); } diff --git a/src/common/histogram.cc b/src/common/histogram.cc index e1422923956..4959c4d5815 100644 --- a/src/common/histogram.cc +++ b/src/common/histogram.cc @@ -28,14 +28,14 @@ void pow2_hist_t::dump(Formatter *f) const void pow2_hist_t::encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); - ::encode(h, bl); + encode(h, bl); ENCODE_FINISH(bl); } void pow2_hist_t::decode(bufferlist::iterator& p) { DECODE_START(1, p); - ::decode(h, p); + decode(h, p); DECODE_FINISH(p); } diff --git a/src/common/hobject.cc b/src/common/hobject.cc index d3f554f7a57..99b8b944097 100644 --- a/src/common/hobject.cc +++ b/src/common/hobject.cc @@ -104,13 +104,13 @@ string hobject_t::to_str() const void hobject_t::encode(bufferlist& bl) const { ENCODE_START(4, 3, bl); - ::encode(key, bl); - ::encode(oid, bl); - ::encode(snap, bl); - ::encode(hash, bl); - ::encode(max, bl); - ::encode(nspace, bl); - ::encode(pool, bl); + encode(key, bl); + encode(oid, bl); + encode(snap, bl); + encode(hash, bl); + encode(max, bl); + encode(nspace, bl); + encode(pool, bl); assert(!max || (*this == hobject_t(hobject_t::get_max()))); ENCODE_FINISH(bl); } @@ -119,17 +119,17 @@ void hobject_t::decode(bufferlist::iterator& bl) { DECODE_START_LEGACY_COMPAT_LEN(4, 3, 3, bl); if (struct_v >= 1) - ::decode(key, bl); - ::decode(oid, bl); - ::decode(snap, bl); - ::decode(hash, bl); + decode(key, bl); + decode(oid, bl); + decode(snap, bl); + decode(hash, bl); if (struct_v >= 2) - ::decode(max, bl); + decode(max, bl); else max = false; if (struct_v >= 4) { - ::decode(nspace, bl); - ::decode(pool, bl); + decode(nspace, bl); + decode(pool, bl); // for compat with hammer, which did not handle the transition // from pool -1 -> pool INT64_MIN for MIN properly. this object // name looks a bit like a pgmeta object for the meta collection, @@ -359,16 +359,16 @@ void ghobject_t::encode(bufferlist& bl) const { // when changing this, remember to update encoded_size() too. ENCODE_START(6, 3, bl); - ::encode(hobj.key, bl); - ::encode(hobj.oid, bl); - ::encode(hobj.snap, bl); - ::encode(hobj.hash, bl); - ::encode(hobj.max, bl); - ::encode(hobj.nspace, bl); - ::encode(hobj.pool, bl); - ::encode(generation, bl); - ::encode(shard_id, bl); - ::encode(max, bl); + encode(hobj.key, bl); + encode(hobj.oid, bl); + encode(hobj.snap, bl); + encode(hobj.hash, bl); + encode(hobj.max, bl); + encode(hobj.nspace, bl); + encode(hobj.pool, bl); + encode(generation, bl); + encode(shard_id, bl); + encode(max, bl); ENCODE_FINISH(bl); } @@ -417,17 +417,17 @@ void ghobject_t::decode(bufferlist::iterator& bl) { DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, bl); if (struct_v >= 1) - ::decode(hobj.key, bl); - ::decode(hobj.oid, bl); - ::decode(hobj.snap, bl); - ::decode(hobj.hash, bl); + decode(hobj.key, bl); + decode(hobj.oid, bl); + decode(hobj.snap, bl); + decode(hobj.hash, bl); if (struct_v >= 2) - ::decode(hobj.max, bl); + decode(hobj.max, bl); else hobj.max = false; if (struct_v >= 4) { - ::decode(hobj.nspace, bl); - ::decode(hobj.pool, bl); + decode(hobj.nspace, bl); + decode(hobj.pool, bl); // for compat with hammer, which did not handle the transition from // pool -1 -> pool INT64_MIN for MIN properly (see hobject_t::decode()). if (hobj.pool == -1 && @@ -440,14 +440,14 @@ void ghobject_t::decode(bufferlist::iterator& bl) } } if (struct_v >= 5) { - ::decode(generation, bl); - ::decode(shard_id, bl); + decode(generation, bl); + decode(shard_id, bl); } else { generation = ghobject_t::NO_GEN; shard_id = shard_id_t::NO_SHARD; } if (struct_v >= 6) { - ::decode(max, bl); + decode(max, bl); } else { max = false; } diff --git a/src/common/mClockCommon.h b/src/common/mClockCommon.h index f8bf4b37243..c7f64da7ec1 100644 --- a/src/common/mClockCommon.h +++ b/src/common/mClockCommon.h @@ -30,12 +30,12 @@ WRITE_RAW_ENCODER(dmc::ReqParams) inline void encode(const dmc::PhaseType &phase, bufferlist& bl, uint64_t features=0) { - ::encode(static_cast(phase), bl); + encode(static_cast(phase), bl); } inline void decode(dmc::PhaseType &phase, bufferlist::iterator& p) { uint8_t int_phase; - ::decode((uint8_t&)int_phase, p); + decode((uint8_t&)int_phase, p); phase = static_cast(int_phase); } diff --git a/src/common/obj_bencher.cc b/src/common/obj_bencher.cc index 97cf7bf8ad3..9a7547b01be 100644 --- a/src/common/obj_bencher.cc +++ b/src/common/obj_bencher.cc @@ -367,11 +367,11 @@ int ObjBencher::fetch_bench_metadata(const std::string& metadata_file, return r; } bufferlist::iterator p = object_data.begin(); - ::decode(*object_size, p); - ::decode(*num_objects, p); - ::decode(*prevPid, p); + decode(*object_size, p); + decode(*num_objects, p); + decode(*prevPid, p); if (!p.end()) { - ::decode(*op_size, p); + decode(*op_size, p); } else { *op_size = *object_size; } @@ -607,11 +607,11 @@ int ObjBencher::write_bench(int secondsToRun, formatter->dump_format("min_latency", "%f", data.min_latency); } //write object size/number data for read benchmarks - ::encode(data.object_size, b_write); + encode(data.object_size, b_write); num_objects = (data.finished + writes_per_object - 1) / writes_per_object; - ::encode(num_objects, b_write); - ::encode(getpid(), b_write); - ::encode(data.op_size, b_write); + encode(num_objects, b_write); + encode(getpid(), b_write); + encode(data.op_size, b_write); // persist meta-data for further cleanup or read sync_write(run_name_meta, b_write, sizeof(int)*3); diff --git a/src/common/scrub_types.cc b/src/common/scrub_types.cc index abc575d7a0d..fc59c38b8ce 100644 --- a/src/common/scrub_types.cc +++ b/src/common/scrub_types.cc @@ -5,49 +5,50 @@ using namespace librados; void object_id_wrapper::encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); - ::encode(name, bl); - ::encode(nspace, bl); - ::encode(locator, bl); - ::encode(snap, bl); + encode(name, bl); + encode(nspace, bl); + encode(locator, bl); + encode(snap, bl); ENCODE_FINISH(bl); } void object_id_wrapper::decode(bufferlist::iterator& bp) { DECODE_START(1, bp); - ::decode(name, bp); - ::decode(nspace, bp); - ::decode(locator, bp); - ::decode(snap, bp); + decode(name, bp); + decode(nspace, bp); + decode(locator, bp); + decode(snap, bp); DECODE_FINISH(bp); } +namespace librados { static void encode(const object_id_t& obj, bufferlist& bl) { reinterpret_cast(obj).encode(bl); } +} void osd_shard_wrapper::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 osd_shard_wrapper::decode(bufferlist::iterator& bp) { DECODE_START(1, bp); - ::decode(osd, bp); - ::decode(shard, bp); + decode(osd, bp); + decode(shard, bp); DECODE_FINISH(bp); } namespace librados { - static void encode(const osd_shard_t& shard, bufferlist& bl) - { - reinterpret_cast(shard).encode(bl); - } +static void encode(const osd_shard_t& shard, bufferlist& bl) { + reinterpret_cast(shard).encode(bl); +} } void shard_info_wrapper::set_object(const ScrubMap::object& object) @@ -71,36 +72,36 @@ void shard_info_wrapper::set_object(const ScrubMap::object& object) void shard_info_wrapper::encode(bufferlist& bl) const { ENCODE_START(3, 3, bl); - ::encode(errors, bl); - ::encode(primary, bl); + encode(errors, bl); + encode(primary, bl); if (has_shard_missing()) { return; } - ::encode(attrs, bl); - ::encode(size, bl); - ::encode(omap_digest_present, bl); - ::encode(omap_digest, bl); - ::encode(data_digest_present, bl); - ::encode(data_digest, bl); - ::encode(selected_oi, bl); + encode(attrs, bl); + encode(size, bl); + encode(omap_digest_present, bl); + encode(omap_digest, bl); + encode(data_digest_present, bl); + encode(data_digest, bl); + encode(selected_oi, bl); ENCODE_FINISH(bl); } void shard_info_wrapper::decode(bufferlist::iterator& bp) { DECODE_START(3, bp); - ::decode(errors, bp); - ::decode(primary, bp); + decode(errors, bp); + decode(primary, bp); if (has_shard_missing()) { return; } - ::decode(attrs, bp); - ::decode(size, bp); - ::decode(omap_digest_present, bp); - ::decode(omap_digest, bp); - ::decode(data_digest_present, bp); - ::decode(data_digest, bp); - ::decode(selected_oi, bp); + decode(attrs, bp); + decode(size, bp); + decode(omap_digest_present, bp); + decode(omap_digest, bp); + decode(data_digest_present, bp); + decode(data_digest, bp); + decode(selected_oi, bp); DECODE_FINISH(bp); } @@ -150,11 +151,11 @@ namespace librados { void inconsistent_obj_wrapper::encode(bufferlist& bl) const { ENCODE_START(2, 2, bl); - ::encode(errors, bl); - ::encode(object, bl); - ::encode(version, bl); - ::encode(shards, bl); - ::encode(union_shards.errors, bl); + encode(errors, bl); + encode(object, bl); + encode(version, bl); + encode(shards, bl); + encode(union_shards.errors, bl); ENCODE_FINISH(bl); } @@ -162,11 +163,11 @@ void inconsistent_obj_wrapper::decode(bufferlist::iterator& bp) { DECODE_START(2, bp); DECODE_OLDEST(2); - ::decode(errors, bp); - ::decode(object, bp); - ::decode(version, bp); - ::decode(shards, bp); - ::decode(union_shards.errors, bp); + decode(errors, bp); + decode(object, bp); + decode(version, bp); + decode(shards, bp); + decode(union_shards.errors, bp); DECODE_FINISH(bp); } @@ -234,59 +235,59 @@ void inconsistent_snapset_wrapper::set_size_mismatch() void inconsistent_snapset_wrapper::encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); - ::encode(errors, bl); - ::encode(object, bl); - ::encode(clones, bl); - ::encode(missing, bl); + encode(errors, bl); + encode(object, bl); + encode(clones, bl); + encode(missing, bl); ENCODE_FINISH(bl); } void inconsistent_snapset_wrapper::decode(bufferlist::iterator& bp) { DECODE_START(1, bp); - ::decode(errors, bp); - ::decode(object, bp); - ::decode(clones, bp); - ::decode(missing, bp); + decode(errors, bp); + decode(object, bp); + decode(clones, bp); + decode(missing, bp); DECODE_FINISH(bp); } void scrub_ls_arg_t::encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); - ::encode(interval, bl); - ::encode(get_snapsets, bl); - ::encode(start_after.name, bl); - ::encode(start_after.nspace, bl); - ::encode(start_after.snap, bl); - ::encode(max_return, bl); + encode(interval, bl); + encode(get_snapsets, bl); + encode(start_after.name, bl); + encode(start_after.nspace, bl); + encode(start_after.snap, bl); + encode(max_return, bl); ENCODE_FINISH(bl); } void scrub_ls_arg_t::decode(bufferlist::iterator& bp) { DECODE_START(1, bp); - ::decode(interval, bp); - ::decode(get_snapsets, bp); - ::decode(start_after.name, bp); - ::decode(start_after.nspace, bp); - ::decode(start_after.snap, bp); - ::decode(max_return, bp); + decode(interval, bp); + decode(get_snapsets, bp); + decode(start_after.name, bp); + decode(start_after.nspace, bp); + decode(start_after.snap, bp); + decode(max_return, bp); DECODE_FINISH(bp); } void scrub_ls_result_t::encode(bufferlist& bl) const { ENCODE_START(1, 1, bl); - ::encode(interval, bl); - ::encode(vals, bl); + encode(interval, bl); + encode(vals, bl); ENCODE_FINISH(bl); } void scrub_ls_result_t::decode(bufferlist::iterator& bp) { DECODE_START(1, bp); - ::decode(interval, bp); - ::decode(vals, bp); + decode(interval, bp); + decode(vals, bp); DECODE_FINISH(bp); } diff --git a/src/common/scrub_types.h b/src/common/scrub_types.h index 9e30fbd9aa2..1f4b9fb84f3 100644 --- a/src/common/scrub_types.h +++ b/src/common/scrub_types.h @@ -18,9 +18,11 @@ struct object_id_wrapper : public librados::object_id_t { WRITE_CLASS_ENCODER(object_id_wrapper) -inline void decode(librados::object_id_t& obj, bufferlist::iterator& bp) { +namespace librados { +inline void decode(object_id_t& obj, bufferlist::iterator& bp) { reinterpret_cast(obj).decode(bp); } +} struct osd_shard_wrapper : public librados::osd_shard_t { void encode(bufferlist& bl) const; diff --git a/src/common/snap_types.cc b/src/common/snap_types.cc index 6b65d7cbea2..23937633961 100644 --- a/src/common/snap_types.cc +++ b/src/common/snap_types.cc @@ -6,16 +6,18 @@ void SnapRealmInfo::encode(bufferlist& bl) const { h.num_snaps = my_snaps.size(); h.num_prior_parent_snaps = prior_parent_snaps.size(); - ::encode(h, bl); - ::encode_nohead(my_snaps, bl); - ::encode_nohead(prior_parent_snaps, bl); + using ceph::encode; + encode(h, bl); + encode_nohead(my_snaps, bl); + encode_nohead(prior_parent_snaps, bl); } void SnapRealmInfo::decode(bufferlist::iterator& bl) { - ::decode(h, bl); - ::decode_nohead(h.num_snaps, my_snaps, bl); - ::decode_nohead(h.num_prior_parent_snaps, prior_parent_snaps, bl); + using ceph::decode; + decode(h, bl); + decode_nohead(h.num_snaps, my_snaps, bl); + decode_nohead(h.num_prior_parent_snaps, prior_parent_snaps, bl); } void SnapRealmInfo::dump(Formatter *f) const diff --git a/src/common/snap_types.h b/src/common/snap_types.h index af0d0252761..1bbb023103e 100644 --- a/src/common/snap_types.h +++ b/src/common/snap_types.h @@ -54,12 +54,14 @@ struct SnapContext { bool empty() { return seq == 0; } void encode(bufferlist& bl) const { - ::encode(seq, bl); - ::encode(snaps, bl); + using ceph::encode; + encode(seq, bl); + encode(snaps, bl); } void decode(bufferlist::iterator& bl) { - ::decode(seq, bl); - ::decode(snaps, bl); + using ceph::decode; + decode(seq, bl); + decode(snaps, bl); } void dump(Formatter *f) const; static void generate_test_instances(list& o); diff --git a/src/common/zipkin_trace.h b/src/common/zipkin_trace.h index 86624715c29..4ec615c2bf3 100644 --- a/src/common/zipkin_trace.h +++ b/src/common/zipkin_trace.h @@ -74,16 +74,16 @@ class Trace { static inline void encode(const blkin_trace_info& b, bufferlist& bl) { - ::encode(b.trace_id, bl); - ::encode(b.span_id, bl); - ::encode(b.parent_span_id, bl); + encode(b.trace_id, bl); + encode(b.span_id, bl); + encode(b.parent_span_id, bl); } static inline void decode(blkin_trace_info& b, bufferlist::iterator& p) { - ::decode(b.trace_id, p); - ::decode(b.span_id, p); - ::decode(b.parent_span_id, p); + decode(b.trace_id, p); + decode(b.span_id, p); + decode(b.parent_span_id, p); } -- 2.39.5