#pragma once
+#include <cstdint>
+#include "include/encoding.h"
#include "dmclock/src/dmclock_recs.h"
// the following is done to unclobber _ASSERT_H so it returns to the
namespace ceph {
- namespace dmc = crimson::dmclock;
+namespace dmc = ::crimson::dmclock;
}
-WRITE_RAW_ENCODER(dmc::ReqParams)
+namespace crimson {
+namespace dmclock {
-inline void encode(const dmc::PhaseType &phase, bufferlist& bl,
+WRITE_RAW_ENCODER(ReqParams)
+
+inline void encode(const PhaseType &phase, bufferlist& bl,
uint64_t features=0)
{
- encode(static_cast<uint8_t>(phase), bl);
+ using ceph::encode;
+ encode(static_cast<std::uint8_t>(phase), bl);
}
-inline void decode(dmc::PhaseType &phase, bufferlist::iterator& p)
+inline void decode(PhaseType &phase, bufferlist::iterator& p)
{
- uint8_t int_phase;
- decode((uint8_t&)int_phase, p);
+ using ceph::decode;
+ std::uint8_t int_phase;
+ decode((std::uint8_t&)int_phase, p);
phase = static_cast<dmc::PhaseType>(int_phase);
}
+}
+}
}
void decode_payload() override {
+ using ceph::encode;
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(protocol, p);
- ::decode(auth_payload, p);
+ decode(protocol, p);
+ decode(auth_payload, p);
if (!p.end())
- ::decode(monmap_epoch, p);
+ decode(monmap_epoch, p);
else
monmap_epoch = 0;
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(protocol, payload);
- ::encode(auth_payload, payload);
- ::encode(monmap_epoch, payload);
+ encode(protocol, payload);
+ encode(auth_payload, payload);
+ encode(monmap_epoch, payload);
}
bufferlist& get_auth_payload() { return auth_payload; }
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(protocol, p);
- ::decode(result, p);
- ::decode(global_id, p);
- ::decode(result_bl, p);
- ::decode(result_msg, p);
+ decode(protocol, p);
+ decode(result, p);
+ decode(global_id, p);
+ decode(result_bl, p);
+ decode(result_msg, p);
}
void encode_payload(uint64_t features) override {
- ::encode(protocol, payload);
- ::encode(result, payload);
- ::encode(global_id, payload);
- ::encode(result_bl, payload);
- ::encode(result_msg, payload);
+ using ceph::encode;
+ encode(protocol, payload);
+ encode(result, payload);
+ encode(global_id, payload);
+ encode(result_bl, payload);
+ encode(result_msg, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid.pgid, p);
- ::decode(query_epoch, p);
- ::decode(type, p);
- ::decode(priority, p);
- ::decode(pgid.shard, p);
+ decode(pgid.pgid, p);
+ decode(query_epoch, p);
+ decode(type, p);
+ decode(priority, p);
+ decode(pgid.shard, p);
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
if (!HAVE_FEATURE(features, RECOVERY_RESERVATION_2)) {
header.version = 3;
header.compat_version = 3;
- ::encode(pgid.pgid, payload);
- ::encode(query_epoch, payload);
- ::encode((type == RELEASE || type == TOOFULL || type == REVOKE) ?
+ encode(pgid.pgid, payload);
+ encode(query_epoch, payload);
+ encode((type == RELEASE || type == TOOFULL || type == REVOKE) ?
REJECT : type, payload);
- ::encode(priority, payload);
- ::encode(pgid.shard, payload);
+ encode(priority, payload);
+ encode(pgid.shard, payload);
return;
}
header.version = HEAD_VERSION;
header.compat_version = COMPAT_VERSION;
- ::encode(pgid.pgid, payload);
- ::encode(query_epoch, payload);
- ::encode(type, payload);
- ::encode(priority, payload);
- ::encode(pgid.shard, payload);
+ encode(pgid.pgid, payload);
+ encode(query_epoch, payload);
+ encode(type, payload);
+ encode(priority, payload);
+ encode(pgid.shard, payload);
}
};
}
void encode(bufferlist &bl) const {
- ::encode(inodes, bl);
- ::encode(dirs, bl);
- ::encode(dentries, bl);
+ using ceph::encode;
+ encode(inodes, bl);
+ encode(dirs, bl);
+ encode(dentries, bl);
}
void decode(bufferlist::iterator &bl) {
- ::decode(inodes, bl);
- ::decode(dirs, bl);
- ::decode(dentries, bl);
+ using ceph::decode;
+ decode(inodes, bl);
+ decode(dirs, bl);
+ decode(dentries, bl);
}
};
WRITE_CLASS_ENCODER(realm)
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(from, p);
- ::decode(realms, p);
+ decode(from, p);
+ decode(realms, p);
}
void encode_payload(uint64_t features) override {
- ::encode(from, payload);
- ::encode(realms, payload);
+ using ceph::encode;
+ encode(from, payload);
+ encode(realms, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(head, p);
- ::decode_nohead(head.num, caps, p);
+ decode(head, p);
+ decode_nohead(head.num, caps, p);
if (header.version >= 2) {
- ::decode(osd_epoch_barrier, p);
+ decode(osd_epoch_barrier, p);
}
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
head.num = caps.size();
- ::encode(head, payload);
- ::encode_nohead(caps, payload);
- ::encode(osd_epoch_barrier, payload);
+ encode(head, payload);
+ encode_nohead(caps, payload);
+ encode(osd_epoch_barrier, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(head, p);
+ decode(head, p);
ceph_mds_caps_body_legacy body;
- ::decode(body, p);
+ decode(body, p);
if (head.op == CEPH_CAP_OP_EXPORT) {
peer = body.peer;
} else {
layout.from_legacy(body.layout);
time_warp_seq = body.time_warp_seq;
}
- ::decode_nohead(head.snap_trace_len, snapbl, p);
+ decode_nohead(head.snap_trace_len, snapbl, p);
assert(middle.length() == head.xattr_len);
if (head.xattr_len)
// conditionally decode flock metadata
if (header.version >= 2)
- ::decode(flockbl, p);
+ decode(flockbl, p);
if (header.version >= 3) {
if (head.op == CEPH_CAP_OP_IMPORT)
- ::decode(peer, p);
+ decode(peer, p);
}
if (header.version >= 4) {
- ::decode(inline_version, p);
- ::decode(inline_data, p);
+ decode(inline_version, p);
+ decode(inline_data, p);
} else {
inline_version = CEPH_INLINE_NONE;
}
if (header.version >= 5) {
- ::decode(osd_epoch_barrier, p);
+ decode(osd_epoch_barrier, p);
}
if (header.version >= 6) {
- ::decode(oldest_flush_tid, p);
+ decode(oldest_flush_tid, p);
}
if (header.version >= 7) {
- ::decode(caller_uid, p);
- ::decode(caller_gid, p);
+ decode(caller_uid, p);
+ decode(caller_gid, p);
}
if (header.version >= 8) {
- ::decode(layout.pool_ns, p);
+ decode(layout.pool_ns, p);
}
if (header.version >= 9) {
- ::decode(btime, p);
- ::decode(change_attr, p);
+ decode(btime, p);
+ decode(change_attr, p);
}
if (header.version >= 10) {
- ::decode(flags, p);
+ decode(flags, p);
}
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
header.version = HEAD_VERSION;
head.snap_trace_len = snapbl.length();
head.xattr_len = xattrbl.length();
- ::encode(head, payload);
+ encode(head, payload);
ceph_mds_caps_body_legacy body;
if (head.op == CEPH_CAP_OP_EXPORT) {
memset(&body, 0, sizeof(body));
layout.to_legacy(&body.layout);
body.time_warp_seq = time_warp_seq;
}
- ::encode(body, payload);
- ::encode_nohead(snapbl, payload);
+ encode(body, payload);
+ encode_nohead(snapbl, payload);
middle = xattrbl;
// conditionally include flock metadata
if (features & CEPH_FEATURE_FLOCK) {
- ::encode(flockbl, payload);
+ encode(flockbl, payload);
} else {
header.version = 1;
return;
if (features & CEPH_FEATURE_EXPORT_PEER) {
if (head.op == CEPH_CAP_OP_IMPORT)
- ::encode(peer, payload);
+ encode(peer, payload);
} else {
header.version = 2;
return;
}
if (features & CEPH_FEATURE_MDS_INLINE_DATA) {
- ::encode(inline_version, payload);
- ::encode(inline_data, payload);
+ encode(inline_version, payload);
+ encode(inline_data, payload);
} else {
- ::encode(inline_version, payload);
- ::encode(bufferlist(), payload);
+ encode(inline_version, payload);
+ encode(bufferlist(), payload);
}
- ::encode(osd_epoch_barrier, payload);
- ::encode(oldest_flush_tid, payload);
- ::encode(caller_uid, payload);
- ::encode(caller_gid, payload);
+ encode(osd_epoch_barrier, payload);
+ encode(oldest_flush_tid, payload);
+ encode(caller_uid, payload);
+ encode(caller_gid, payload);
- ::encode(layout.pool_ns, payload);
- ::encode(btime, payload);
- ::encode(change_attr, payload);
- ::encode(flags, payload);
+ encode(layout.pool_ns, payload);
+ encode(btime, payload);
+ encode(change_attr, payload);
+ encode(flags, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(h, p);
- ::decode(dname, p);
+ decode(h, p);
+ decode(dname, p);
}
void encode_payload(uint64_t features) override {
- ::encode(h, payload);
- ::encode(dname, payload);
+ using ceph::encode;
+ encode(h, payload);
+ encode(dname, payload);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
- ::encode(rstat.rctime, payload);
- ::encode(rstat.rbytes, payload);
- ::encode(rstat.rfiles, payload);
- ::encode(rstat.rsubdirs, payload);
- ::encode(quota, payload);
+ using ceph::encode;
+ encode(ino, payload);
+ encode(rstat.rctime, payload);
+ encode(rstat.rbytes, payload);
+ encode(rstat.rfiles, payload);
+ encode(rstat.rsubdirs, payload);
+ encode(quota, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
- ::decode(rstat.rctime, p);
- ::decode(rstat.rbytes, p);
- ::decode(rstat.rfiles, p);
- ::decode(rstat.rsubdirs, p);
- ::decode(quota, p);
+ decode(ino, p);
+ decode(rstat.rctime, p);
+ decode(rstat.rbytes, p);
+ decode(rstat.rfiles, p);
+ decode(rstat.rsubdirs, p);
+ decode(quota, p);
assert(p.end());
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
data.clear();
if (features & CEPH_FEATURE_MDSENC) {
- ::encode(caps, data);
+ encode(caps, data);
header.version = HEAD_VERSION;
} else if (features & CEPH_FEATURE_FLOCK) {
// encode with old cap_reconnect_t encoding
__u32 n = caps.size();
- ::encode(n, data);
+ encode(n, data);
for (map<inodeno_t,cap_reconnect_t>::iterator p = caps.begin(); p != caps.end(); ++p) {
- ::encode(p->first, data);
+ encode(p->first, data);
p->second.encode_old(data);
}
header.version = 2;
map<inodeno_t, old_cap_reconnect_t> ocaps;
for (map<inodeno_t,cap_reconnect_t>::iterator p = caps.begin(); p != caps.end(); p++)
ocaps[p->first] = p->second;
- ::encode(ocaps, data);
+ encode(ocaps, data);
}
- ::encode_nohead(realms, data);
+ encode_nohead(realms, data);
}
void decode_payload() override {
bufferlist::iterator p = data.begin();
if (header.version >= 3) {
// new protocol
- ::decode(caps, p);
+ decode(caps, p);
} else if (header.version == 2) {
__u32 n;
- ::decode(n, p);
+ decode(n, p);
inodeno_t ino;
while (n--) {
- ::decode(ino, p);
+ decode(ino, p);
caps[ino].decode_old(p);
}
} else {
// compat crap
map<inodeno_t, old_cap_reconnect_t> ocaps;
- ::decode(ocaps, p);
+ decode(ocaps, p);
for (map<inodeno_t,old_cap_reconnect_t>::iterator q = ocaps.begin(); q != ocaps.end(); q++)
caps[q->first] = q->second;
}
while (!p.end()) {
realms.push_back(ceph_mds_snaprealm_reconnect());
- ::decode(realms.back(), p);
+ decode(realms.back(), p);
}
}
LeaseStat() : mask(0), duration_ms(0), seq(0) {}
void encode(bufferlist &bl) const {
- ::encode(mask, bl);
- ::encode(duration_ms, bl);
- ::encode(seq, bl);
+ using ceph::encode;
+ encode(mask, bl);
+ encode(duration_ms, bl);
+ encode(seq, bl);
}
void decode(bufferlist::iterator &bl) {
- ::decode(mask, bl);
- ::decode(duration_ms, bl);
- ::decode(seq, bl);
+ using ceph::decode;
+ decode(mask, bl);
+ decode(duration_ms, bl);
+ decode(seq, bl);
}
};
WRITE_CLASS_ENCODER(LeaseStat)
}
void encode(bufferlist& bl) {
- ::encode(frag, bl);
- ::encode(auth, bl);
- ::encode(dist, bl);
+ using ceph::encode;
+ encode(frag, bl);
+ encode(auth, bl);
+ encode(dist, bl);
}
void decode(bufferlist::iterator& p) {
- ::decode(frag, p);
- ::decode(auth, p);
- ::decode(dist, p);
+ using ceph::decode;
+ decode(frag, p);
+ decode(auth, p);
+ decode(dist, p);
}
// see CDir::encode_dirstat for encoder.
}
void decode(bufferlist::iterator &p, uint64_t features) {
- ::decode(vino.ino, p);
- ::decode(vino.snapid, p);
- ::decode(rdev, p);
- ::decode(version, p);
- ::decode(xattr_version, p);
- ::decode(cap, p);
+ using ceph::decode;
+ decode(vino.ino, p);
+ decode(vino.snapid, p);
+ decode(rdev, p);
+ decode(version, p);
+ decode(xattr_version, p);
+ decode(cap, p);
{
ceph_file_layout legacy_layout;
- ::decode(legacy_layout, p);
+ decode(legacy_layout, p);
layout.from_legacy(legacy_layout);
}
- ::decode(ctime, p);
- ::decode(mtime, p);
- ::decode(atime, p);
- ::decode(time_warp_seq, p);
- ::decode(size, p);
- ::decode(max_size, p);
- ::decode(truncate_size, p);
- ::decode(truncate_seq, p);
- ::decode(mode, p);
- ::decode(uid, p);
- ::decode(gid, p);
- ::decode(nlink, p);
- ::decode(dirstat.nfiles, p);
- ::decode(dirstat.nsubdirs, p);
- ::decode(rstat.rbytes, p);
- ::decode(rstat.rfiles, p);
- ::decode(rstat.rsubdirs, p);
- ::decode(rstat.rctime, p);
-
- ::decode(dirfragtree, p);
-
- ::decode(symlink, p);
+ decode(ctime, p);
+ decode(mtime, p);
+ decode(atime, p);
+ decode(time_warp_seq, p);
+ decode(size, p);
+ decode(max_size, p);
+ decode(truncate_size, p);
+ decode(truncate_seq, p);
+ decode(mode, p);
+ decode(uid, p);
+ decode(gid, p);
+ decode(nlink, p);
+ decode(dirstat.nfiles, p);
+ decode(dirstat.nsubdirs, p);
+ decode(rstat.rbytes, p);
+ decode(rstat.rfiles, p);
+ decode(rstat.rsubdirs, p);
+ decode(rstat.rctime, p);
+
+ decode(dirfragtree, p);
+
+ decode(symlink, p);
if (features & CEPH_FEATURE_DIRLAYOUTHASH)
- ::decode(dir_layout, p);
+ decode(dir_layout, p);
else
memset(&dir_layout, 0, sizeof(dir_layout));
- ::decode(xattrbl, p);
+ decode(xattrbl, p);
if (features & CEPH_FEATURE_MDS_INLINE_DATA) {
- ::decode(inline_version, p);
- ::decode(inline_data, p);
+ decode(inline_version, p);
+ decode(inline_data, p);
} else {
inline_version = CEPH_INLINE_NONE;
}
if (features & CEPH_FEATURE_MDS_QUOTA)
- ::decode(quota, p);
+ decode(quota, p);
else
memset("a, 0, sizeof(quota));
if ((features & CEPH_FEATURE_FS_FILE_LAYOUT_V2))
- ::decode(layout.pool_ns, p);
+ decode(layout.pool_ns, p);
if ((features & CEPH_FEATURE_FS_BTIME)) {
- ::decode(btime, p);
- ::decode(change_attr, p);
+ decode(btime, p);
+ decode(change_attr, p);
} else {
btime = utime_t();
change_attr = 0;
// serialization
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(head, p);
- ::decode(trace_bl, p);
- ::decode(extra_bl, p);
- ::decode(snapbl, p);
+ decode(head, p);
+ decode(trace_bl, p);
+ decode(extra_bl, p);
+ decode(snapbl, p);
assert(p.end());
}
void encode_payload(uint64_t features) override {
- ::encode(head, payload);
- ::encode(trace_bl, payload);
- ::encode(extra_bl, payload);
- ::encode(snapbl, payload);
+ using ceph::encode;
+ encode(head, payload);
+ encode(trace_bl, payload);
+ encode(extra_bl, payload);
+ encode(snapbl, payload);
}
item(rel), dname(name) {}
void encode(bufferlist& bl) const {
+ using ceph::encode;
item.dname_len = dname.length();
- ::encode(item, bl);
- ::encode_nohead(dname, bl);
+ encode(item, bl);
+ encode_nohead(dname, bl);
}
void decode(bufferlist::iterator& bl) {
- ::decode(item, bl);
- ::decode_nohead(item.dname_len, dname, bl);
+ using ceph::decode;
+ decode(item, bl);
+ decode_nohead(item.dname_len, dname, bl);
}
};
vector<Release> releases;
bufferlist::iterator p = payload.begin();
if (header.version >= 4) {
- ::decode(head, p);
+ decode(head, p);
} else {
struct ceph_mds_request_head_legacy old_mds_head;
- ::decode(old_mds_head, p);
+ decode(old_mds_head, p);
copy_from_legacy_head(&head, &old_mds_head);
head.version = 0;
}
}
- ::decode(path, p);
- ::decode(path2, p);
- ::decode_nohead(head.num_releases, releases, p);
+ decode(path, p);
+ decode(path2, p);
+ decode_nohead(head.num_releases, releases, p);
if (header.version >= 2)
- ::decode(stamp, p);
+ decode(stamp, p);
if (header.version >= 4) // epoch 3 was for a ceph_mds_request_args change
- ::decode(gid_list, p);
+ decode(gid_list, p);
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
head.num_releases = releases.size();
head.version = CEPH_MDS_REQUEST_HEAD_VERSION;
if (features & CEPH_FEATURE_FS_BTIME) {
- ::encode(head, payload);
+ encode(head, payload);
} else {
struct ceph_mds_request_head_legacy old_mds_head;
copy_to_legacy_head(&old_mds_head, &head);
- ::encode(old_mds_head, payload);
+ encode(old_mds_head, payload);
}
- ::encode(path, payload);
- ::encode(path2, payload);
- ::encode_nohead(releases, payload);
- ::encode(stamp, payload);
- ::encode(gid_list, payload);
+ encode(path, payload);
+ encode(path2, payload);
+ encode_nohead(releases, payload);
+ encode(stamp, payload);
+ encode(gid_list, payload);
}
const char *get_type_name() const override { return "creq"; }
}
void encode_payload(uint64_t features) override {
- ::encode(dest_mds, payload);
- ::encode(num_fwd, payload);
- ::encode(client_must_resend, payload);
+ using ceph::encode;
+ encode(dest_mds, payload);
+ encode(num_fwd, payload);
+ encode(client_must_resend, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(dest_mds, p);
- ::decode(num_fwd, p);
- ::decode(client_must_resend, p);
+ decode(dest_mds, p);
+ decode(num_fwd, p);
+ decode(client_must_resend, p);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(head, p);
+ decode(head, p);
if (header.version >= 2) {
- ::decode(client_meta, p);
+ decode(client_meta, p);
}
}
void encode_payload(uint64_t features) override {
- ::encode(head, payload);
+ using ceph::encode;
+ encode(head, payload);
if (client_meta.empty()) {
// If we're not trying to send any metadata (always the case if
// we are a server) then send older-format message to avoid upsetting
// old kernel clients.
header.version = 1;
} else {
- ::encode(client_meta, payload);
+ encode(client_meta, payload);
header.version = HEAD_VERSION;
}
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
head.num_split_inos = split_inos.size();
head.num_split_realms = split_realms.size();
head.trace_len = bl.length();
- ::encode(head, payload);
- ::encode_nohead(split_inos, payload);
- ::encode_nohead(split_realms, payload);
- ::encode_nohead(bl, payload);
+ encode(head, payload);
+ encode_nohead(split_inos, payload);
+ encode_nohead(split_realms, payload);
+ encode_nohead(bl, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(head, p);
- ::decode_nohead(head.num_split_inos, split_inos, p);
- ::decode_nohead(head.num_split_realms, split_realms, p);
- ::decode_nohead(head.trace_len, bl, p);
+ decode(head, p);
+ decode_nohead(head.num_split_inos, split_inos, p);
+ decode_nohead(head.num_split_realms, split_realms, p);
+ decode_nohead(head.trace_len, bl, p);
assert(p.end());
}
}
void encode_payload(uint64_t features) override {
- ::encode(fsid, payload);
- ::encode(cmd, payload);
+ using ceph::encode;
+ encode(fsid, payload);
+ encode(cmd, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(cmd, p);
+ decode(fsid, p);
+ decode(cmd, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(r, payload);
- ::encode(rs, payload);
+ using ceph::encode;
+ encode(r, payload);
+ encode(rs, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(r, p);
- ::decode(rs, p);
+ decode(r, p);
+ decode(rs, p);
}
};
public:
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(tag, p);
- ::decode(counter, p);
+ decode(tag, p);
+ decode(counter, p);
}
void encode_payload(uint64_t features) override {
- ::encode(tag, payload);
- ::encode(counter, payload);
+ using ceph::encode;
+ encode(tag, payload);
+ encode(counter, payload);
}
const char *get_type_name() const override { return "data_ping"; }
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(subtree, p);
- ::decode(dirfrag, p);
- ::decode(dn, p);
- ::decode(is_primary, p);
- ::decode(bl, p);
+ decode(subtree, p);
+ decode(dirfrag, p);
+ decode(dn, p);
+ decode(is_primary, p);
+ decode(bl, p);
}
void encode_payload(uint64_t features) override {
- ::encode(subtree, payload);
- ::encode(dirfrag, payload);
- ::encode(dn, payload);
- ::encode(is_primary, payload);
- ::encode(bl, payload);
+ using ceph::encode;
+ encode(subtree, payload);
+ encode(dirfrag, payload);
+ encode(dn, payload);
+ encode(is_primary, payload);
+ encode(bl, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(dn, p);
- ::decode(straybl, p);
+ decode(dirfrag, p);
+ decode(dn, p);
+ decode(straybl, p);
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(dn, payload);
- ::encode(straybl, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(dn, payload);
+ encode(straybl, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(from_mds, p);
- ::decode(dirfrag, p);
- ::decode(dir_rep, p);
- ::decode(discover, p);
- ::decode(dir_rep_by, p);
- ::decode(path, p);
+ decode(from_mds, p);
+ decode(dirfrag, p);
+ decode(dir_rep, p);
+ decode(discover, p);
+ decode(dir_rep_by, p);
+ decode(path, p);
}
void encode_payload(uint64_t features) override {
- ::encode(from_mds, payload);
- ::encode(dirfrag, payload);
- ::encode(dir_rep, payload);
- ::encode(discover, payload);
- ::encode(dir_rep_by, payload);
- ::encode(path, payload);
+ using ceph::encode;
+ encode(from_mds, payload);
+ encode(dirfrag, payload);
+ encode(dir_rep, payload);
+ encode(discover, payload);
+ encode(dir_rep_by, payload);
+ encode(path, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(base_ino, p);
- ::decode(base_dir_frag, p);
- ::decode(snapid, p);
- ::decode(want, p);
- ::decode(want_base_dir, p);
- ::decode(want_xlocked, p);
+ decode(base_ino, p);
+ decode(base_dir_frag, p);
+ decode(snapid, p);
+ decode(want, p);
+ decode(want_base_dir, p);
+ decode(want_xlocked, p);
}
void encode_payload(uint64_t features) override {
- ::encode(base_ino, payload);
- ::encode(base_dir_frag, payload);
- ::encode(snapid, payload);
- ::encode(want, payload);
- ::encode(want_base_dir, payload);
- ::encode(want_xlocked, payload);
+ using ceph::encode;
+ encode(base_ino, payload);
+ encode(base_dir_frag, payload);
+ encode(snapid, payload);
+ encode(want, payload);
+ encode(want_base_dir, payload);
+ encode(want_xlocked, payload);
}
};
// ...
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(base_ino, p);
- ::decode(base_dir_frag, p);
- ::decode(wanted_base_dir, p);
- ::decode(wanted_xlocked, p);
- ::decode(wanted_snapid, p);
- ::decode(flag_error_dn, p);
- ::decode(flag_error_dir, p);
- ::decode(error_dentry, p);
- ::decode(dir_auth_hint, p);
- ::decode(unsolicited, p);
-
- ::decode(starts_with, p);
- ::decode(trace, p);
+ decode(base_ino, p);
+ decode(base_dir_frag, p);
+ decode(wanted_base_dir, p);
+ decode(wanted_xlocked, p);
+ decode(wanted_snapid, p);
+ decode(flag_error_dn, p);
+ decode(flag_error_dir, p);
+ decode(error_dentry, p);
+ decode(dir_auth_hint, p);
+ decode(unsolicited, p);
+
+ decode(starts_with, p);
+ decode(trace, p);
}
void encode_payload(uint64_t features) override {
- ::encode(base_ino, payload);
- ::encode(base_dir_frag, payload);
- ::encode(wanted_base_dir, payload);
- ::encode(wanted_xlocked, payload);
- ::encode(wanted_snapid, payload);
- ::encode(flag_error_dn, payload);
- ::encode(flag_error_dir, payload);
- ::encode(error_dentry, payload);
- ::encode(dir_auth_hint, payload);
- ::encode(unsolicited, payload);
-
- ::encode(starts_with, payload);
- ::encode(trace, payload);
+ using ceph::encode;
+ encode(base_ino, payload);
+ encode(base_dir_frag, payload);
+ encode(wanted_base_dir, payload);
+ encode(wanted_xlocked, payload);
+ encode(wanted_snapid, payload);
+ encode(flag_error_dn, payload);
+ encode(flag_error_dir, payload);
+ encode(error_dentry, payload);
+ encode(dir_auth_hint, payload);
+ encode(unsolicited, payload);
+
+ encode(starts_with, payload);
+ encode(trace, payload);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
- ::encode(cap_bl, payload);
- ::encode(client_map, payload, features);
+ using ceph::encode;
+ encode(ino, payload);
+ encode(cap_bl, payload);
+ encode(client_map, payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
- ::decode(cap_bl, p);
- ::decode(client_map, p);
+ decode(ino, p);
+ decode(cap_bl, p);
+ decode(client_map, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
+ using ceph::encode;
+ encode(ino, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
+ decode(ino, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(bounds, payload);
- ::encode(export_data, payload);
- ::encode(client_map, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(bounds, payload);
+ encode(export_data, payload);
+ encode(client_map, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(bounds, p);
- ::decode(export_data, p);
- ::decode(client_map, p);
+ decode(dirfrag, p);
+ decode(bounds, p);
+ decode(export_data, p);
+ decode(client_map, p);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(imported_caps, p);
+ decode(dirfrag, p);
+ decode(imported_caps, p);
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(imported_caps, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(imported_caps, payload);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
+ decode(dirfrag, p);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(from, p);
- ::decode(dirfrag, p);
- ::decode(path, p);
+ decode(from, p);
+ decode(dirfrag, p);
+ decode(path, p);
}
void encode_payload(uint64_t features) override {
- ::encode(from, payload);
- ::encode(dirfrag, payload);
- ::encode(path, payload);
+ using ceph::encode;
+ encode(from, payload);
+ encode(dirfrag, payload);
+ encode(path, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(success, p);
+ decode(dirfrag, p);
+ decode(success, p);
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(success, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(success, payload);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(last, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(last, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(last, p);
+ decode(dirfrag, p);
+ decode(last, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(base, payload);
- ::encode(ack, payload);
- ::encode(old_auth, payload);
- ::encode(new_auth, payload);
- ::encode(bounds, payload);
+ using ceph::encode;
+ encode(base, payload);
+ encode(ack, payload);
+ encode(old_auth, payload);
+ encode(new_auth, payload);
+ encode(bounds, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(base, p);
- ::decode(ack, p);
- ::decode(old_auth, p);
- ::decode(new_auth, p);
- ::decode(bounds, p);
+ decode(base, p);
+ decode(ack, p);
+ decode(old_auth, p);
+ decode(new_auth, p);
+ decode(bounds, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(new_auth, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(new_auth, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(new_auth, p);
+ decode(dirfrag, p);
+ decode(new_auth, p);
}
};
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(basedir, p);
- ::decode(bounds, p);
- ::decode(traces, p);
- ::decode(bystanders, p);
+ decode(dirfrag, p);
+ decode(basedir, p);
+ decode(bounds, p);
+ decode(traces, p);
+ decode(bystanders, p);
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(basedir, payload);
- ::encode(bounds, payload);
- ::encode(traces, payload);
- ::encode(bystanders, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(basedir, payload);
+ encode(bounds, payload);
+ encode(traces, payload);
+ encode(bystanders, payload);
}
};
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(dirfrag, p);
- ::decode(success, p);
+ decode(dirfrag, p);
+ decode(success, p);
}
void encode_payload(uint64_t features) override {
- ::encode(dirfrag, payload);
- ::encode(success, payload);
+ using ceph::encode;
+ encode(dirfrag, payload);
+ encode(success, payload);
}
};
// marshalling
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(fsmap, p);
+ decode(epoch, p);
+ decode(fsmap, p);
}
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(fsmap, payload, features);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(fsmap, payload, features);
}
};
// marshalling
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(fsmap, p);
+ decode(epoch, p);
+ decode(fsmap, p);
}
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(fsmap, payload, features);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(fsmap, payload, features);
}
};
public:
void encode_payload(uint64_t features) override {
- ::encode(tid, payload);
- ::encode(client, payload, features);
- ::encode(client_caps, payload, features);
+ using ceph::encode;
+ encode(tid, payload);
+ encode(client, payload, features);
+ encode(client_caps, payload, features);
// Encode client message with intersection of target and source
// features. This could matter if the semantics of the encoded
// message are changed when reencoding with more features than the
msg->clear_payload();
}
encode_message(msg, features & con_features, payload);
- ::encode(con_features, payload);
- ::encode(entity_name, payload);
+ encode(con_features, payload);
+ encode(entity_name, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(tid, p);
- ::decode(client, p);
- ::decode(client_caps, p);
+ decode(tid, p);
+ decode(client, p);
+ decode(client_caps, p);
msg = (PaxosServiceMessage *)decode_message(NULL, 0, p);
- ::decode(con_features, p);
- ::decode(entity_name, p);
+ decode(con_features, p);
+ decode(entity_name, p);
}
PaxosServiceMessage *claim_message() {
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
+ using ceph::encode;
+ encode(ino, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
+ decode(ino, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(pools, payload);
+ encode(fsid, payload);
+ encode(pools, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(pools, p);
+ decode(fsid, p);
+ decode(pools, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(pool_stats, payload, features);
+ encode(fsid, payload);
+ encode(pool_stats, payload, features);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(pool_stats, p);
+ decode(fsid, p);
+ decode(pool_stats, p);
}
};
const char *get_type_name() const override { return "HB"; }
void encode_payload(uint64_t features) override {
- ::encode(load, payload);
- ::encode(beat, payload);
- ::encode(import_map, payload);
- ::encode(last_epoch_under, payload);
+ using ceph::encode;
+ encode(load, payload);
+ encode(beat, payload);
+ encode(import_map, payload);
+ encode(last_epoch_under, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
utime_t now(ceph_clock_now());
- ::decode(load, now, p);
- ::decode(beat, p);
- ::decode(import_map, p);
+ decode(load, now, p);
+ decode(beat, p);
+ decode(import_map, p);
if (header.version >= 2) {
- ::decode(last_epoch_under, p);
+ decode(last_epoch_under, p);
} else {
last_epoch_under = 0;
}
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
- ::encode(caps, payload);
+ using ceph::encode;
+ encode(ino, payload);
+ encode(caps, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
- ::decode(caps, p);
+ decode(ino, p);
+ decode(caps, p);
}
};
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(asker, p);
- ::decode(action, p);
- ::decode(reqid, p);
- ::decode(lock_type, p);
- ::decode(object_info, p);
- ::decode(lockdata, p);
+ decode(asker, p);
+ decode(action, p);
+ decode(reqid, p);
+ decode(lock_type, p);
+ decode(object_info, p);
+ decode(lockdata, p);
}
void encode_payload(uint64_t features) override {
- ::encode(asker, payload);
- ::encode(action, payload);
- ::encode(reqid, payload);
- ::encode(lock_type, payload);
- ::encode(object_info, payload);
- ::encode(lockdata, payload);
+ using ceph::encode;
+ encode(asker, payload);
+ encode(action, payload);
+ encode(reqid, payload);
+ encode(lock_type, payload);
+ encode(object_info, payload);
+ encode(lockdata, payload);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(entries, payload, features);
+ encode(fsid, payload);
+ encode(entries, payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(entries, p);
+ decode(fsid, p);
+ decode(entries, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(fsid, payload);
- ::encode(last, payload);
- ::encode(channel, payload);
+ using ceph::encode;
+ encode(fsid, payload);
+ encode(last, payload);
+ encode(channel, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(last, p);
+ decode(fsid, p);
+ decode(last, p);
if (!p.end())
- ::decode(channel, p);
+ decode(channel, p);
}
};
MDS_HEALTH_CACHE_OVERSIZED
};
-static inline const char *mds_metric_name(mds_metric_t m)
+inline const char *mds_metric_name(mds_metric_t m)
{
switch (m) {
case MDS_HEALTH_TRIM: return "MDS_TRIM";
}
}
-static inline const char *mds_metric_summary(mds_metric_t m)
+inline const char *mds_metric_summary(mds_metric_t m)
{
switch (m) {
case MDS_HEALTH_TRIM:
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
assert(type != MDS_HEALTH_NULL);
- ::encode((uint16_t)type, bl);
- ::encode((uint8_t)sev, bl);
- ::encode(message, bl);
- ::encode(metadata, bl);
+ encode((uint16_t)type, bl);
+ encode((uint8_t)sev, bl);
+ encode(message, bl);
+ encode(metadata, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode((uint16_t&)type, bl);
+ decode((uint16_t&)type, bl);
assert(type != MDS_HEALTH_NULL);
- ::decode((uint8_t&)sev, bl);
- ::decode(message, bl);
- ::decode(metadata, bl);
+ decode((uint8_t&)sev, bl);
+ decode(message, bl);
+ decode(metadata, bl);
DECODE_FINISH(bl);
}
void encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(metrics, bl);
+ encode(metrics, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator& bl) {
DECODE_START(1, bl);
- ::decode(metrics, bl);
+ decode(metrics, bl);
DECODE_FINISH(bl);
}
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(global_id, payload);
- ::encode((__u32)state, payload);
- ::encode(seq, payload);
- ::encode(name, payload);
- ::encode(standby_for_rank, payload);
- ::encode(standby_for_name, payload);
- ::encode(compat, payload);
- ::encode(health, payload);
+ encode(fsid, payload);
+ encode(global_id, payload);
+ encode((__u32)state, payload);
+ encode(seq, payload);
+ encode(name, payload);
+ encode(standby_for_rank, payload);
+ encode(standby_for_name, payload);
+ encode(compat, payload);
+ encode(health, payload);
if (state == MDSMap::STATE_BOOT) {
- ::encode(sys_info, payload);
+ encode(sys_info, payload);
}
- ::encode(mds_features, payload);
- ::encode(standby_for_fscid, payload);
- ::encode(standby_replay, payload);
+ encode(mds_features, payload);
+ encode(standby_for_fscid, payload);
+ encode(standby_replay, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(global_id, p);
- ::decode((__u32&)state, p);
- ::decode(seq, p);
- ::decode(name, p);
- ::decode(standby_for_rank, p);
- ::decode(standby_for_name, p);
- ::decode(compat, p);
- ::decode(health, p);
+ decode(fsid, p);
+ decode(global_id, p);
+ decode((__u32&)state, p);
+ decode(seq, p);
+ decode(name, p);
+ decode(standby_for_rank, p);
+ decode(standby_for_name, p);
+ decode(compat, p);
+ decode(health, p);
if (state == MDSMap::STATE_BOOT) {
- ::decode(sys_info, p);
+ decode(sys_info, p);
}
- ::decode(mds_features, p);
- ::decode(standby_for_fscid, p);
+ decode(mds_features, p);
+ decode(standby_for_fscid, p);
if (header.version >= 7) {
- ::decode(standby_replay, p);
+ decode(standby_replay, p);
}
if (header.version < 7 && state == MDSMap::STATE_STANDBY_REPLAY) {
nonce(n), caps_wanted(cw),
filelock(dl), nestlock(nl), dftlock(dftl) { }
void encode(bufferlist &bl) const {
- ::encode(nonce, bl);
- ::encode(caps_wanted, bl);
- ::encode(filelock, bl);
- ::encode(nestlock, bl);
- ::encode(dftlock, bl);
+ using ceph::encode;
+ encode(nonce, bl);
+ encode(caps_wanted, bl);
+ encode(filelock, bl);
+ encode(nestlock, bl);
+ encode(dftlock, bl);
}
void decode(bufferlist::iterator &bl) {
- ::decode(nonce, bl);
- ::decode(caps_wanted, bl);
- ::decode(filelock, bl);
- ::decode(nestlock, bl);
- ::decode(dftlock, bl);
+ using ceph::decode;
+ decode(nonce, bl);
+ decode(caps_wanted, bl);
+ decode(filelock, bl);
+ decode(nestlock, bl);
+ decode(dftlock, bl);
}
};
WRITE_CLASS_ENCODER(inode_strong)
dirfrag_strong() {}
dirfrag_strong(int n, int dr) : nonce(n), dir_rep(dr) {}
void encode(bufferlist &bl) const {
- ::encode(nonce, bl);
- ::encode(dir_rep, bl);
+ using ceph::encode;
+ encode(nonce, bl);
+ encode(dir_rep, bl);
}
void decode(bufferlist::iterator &bl) {
- ::decode(nonce, bl);
- ::decode(dir_rep, bl);
+ using ceph::decode;
+ decode(nonce, bl);
+ decode(dir_rep, bl);
}
};
WRITE_CLASS_ENCODER(dirfrag_strong)
bool is_remote() { return remote_ino > 0; }
bool is_null() { return ino == 0 && remote_ino == 0; }
void encode(bufferlist &bl) const {
- ::encode(first, bl);
- ::encode(ino, bl);
- ::encode(remote_ino, bl);
- ::encode(remote_d_type, bl);
- ::encode(nonce, bl);
- ::encode(lock, bl);
+ using ceph::encode;
+ encode(first, bl);
+ encode(ino, bl);
+ encode(remote_ino, bl);
+ encode(remote_d_type, bl);
+ encode(nonce, bl);
+ encode(lock, bl);
}
void decode(bufferlist::iterator &bl) {
- ::decode(first, bl);
- ::decode(ino, bl);
- ::decode(remote_ino, bl);
- ::decode(remote_d_type, bl);
- ::decode(nonce, bl);
- ::decode(lock, bl);
+ using ceph::decode;
+ decode(first, bl);
+ decode(ino, bl);
+ decode(remote_ino, bl);
+ decode(remote_d_type, bl);
+ decode(nonce, bl);
+ decode(lock, bl);
}
};
WRITE_CLASS_ENCODER(dn_strong)
dn_weak() : ino(0) {}
dn_weak(snapid_t f, inodeno_t pi) : first(f), ino(pi) {}
void encode(bufferlist &bl) const {
- ::encode(first, bl);
- ::encode(ino, bl);
+ using ceph::encode;
+ encode(first, bl);
+ encode(ino, bl);
}
void decode(bufferlist::iterator &bl) {
- ::decode(first, bl);
- ::decode(ino, bl);
+ using ceph::decode;
+ decode(first, bl);
+ decode(ino, bl);
}
};
WRITE_CLASS_ENCODER(dn_weak)
struct lock_bls {
bufferlist file, nest, dft;
void encode(bufferlist& bl) const {
- ::encode(file, bl);
- ::encode(nest, bl);
- ::encode(dft, bl);
+ using ceph::encode;
+ encode(file, bl);
+ encode(nest, bl);
+ encode(dft, bl);
}
void decode(bufferlist::iterator& bl) {
- ::decode(file, bl);
- ::decode(nest, bl);
- ::decode(dft, bl);
+ using ceph::decode;
+ decode(file, bl);
+ decode(nest, bl);
+ decode(dft, bl);
}
};
WRITE_CLASS_ENCODER(lock_bls)
slave_reqid(const metareqid_t& r, __u32 a)
: reqid(r), attempt(a) {}
void encode(bufferlist& bl) const {
- ::encode(reqid, bl);
- ::encode(attempt, bl);
+ using ceph::encode;
+ encode(reqid, bl);
+ encode(attempt, bl);
}
void decode(bufferlist::iterator& bl) {
- ::decode(reqid, bl);
- ::decode(attempt, bl);
+ using ceph::decode;
+ decode(reqid, bl);
+ decode(attempt, bl);
}
};
map<vinodeno_t, list<slave_reqid> > authpinned_inodes;
strong_inodes[i] = inode_strong(n, cw, dl, nl, dftl);
}
void add_inode_locks(CInode *in, __u32 nonce, bufferlist& bl) {
- ::encode(in->inode.ino, inode_locks);
- ::encode(in->last, inode_locks);
- ::encode(nonce, inode_locks);
- ::encode(bl, inode_locks);
+ using ceph::encode;
+ encode(in->inode.ino, inode_locks);
+ encode(in->last, inode_locks);
+ encode(nonce, inode_locks);
+ encode(bl, inode_locks);
}
void add_inode_base(CInode *in, uint64_t features) {
- ::encode(in->inode.ino, inode_base);
- ::encode(in->last, inode_base);
+ using ceph::encode;
+ encode(in->inode.ino, inode_base);
+ encode(in->last, inode_base);
bufferlist bl;
in->_encode_base(bl, features);
- ::encode(bl, inode_base);
+ encode(bl, inode_base);
}
void add_inode_authpin(vinodeno_t ino, const metareqid_t& ri, __u32 attempt) {
authpinned_inodes[ino].push_back(slave_reqid(ri, attempt));
// -- encoding --
void encode_payload(uint64_t features) override {
- ::encode(op, payload);
- ::encode(strong_inodes, payload);
- ::encode(inode_base, payload);
- ::encode(inode_locks, payload);
- ::encode(inode_scatterlocks, payload);
- ::encode(authpinned_inodes, payload);
- ::encode(frozen_authpin_inodes, payload);
- ::encode(xlocked_inodes, payload);
- ::encode(wrlocked_inodes, payload);
- ::encode(cap_exports, payload);
- ::encode(client_map, payload, features);
- ::encode(imported_caps, payload);
- ::encode(strong_dirfrags, payload);
- ::encode(dirfrag_bases, payload);
- ::encode(weak, payload);
- ::encode(weak_dirfrags, payload);
- ::encode(weak_inodes, payload);
- ::encode(strong_dentries, payload);
- ::encode(authpinned_dentries, payload);
- ::encode(xlocked_dentries, payload);
+ using ceph::encode;
+ encode(op, payload);
+ encode(strong_inodes, payload);
+ encode(inode_base, payload);
+ encode(inode_locks, payload);
+ encode(inode_scatterlocks, payload);
+ encode(authpinned_inodes, payload);
+ encode(frozen_authpin_inodes, payload);
+ encode(xlocked_inodes, payload);
+ encode(wrlocked_inodes, payload);
+ encode(cap_exports, payload);
+ encode(client_map, payload, features);
+ encode(imported_caps, payload);
+ encode(strong_dirfrags, payload);
+ encode(dirfrag_bases, payload);
+ encode(weak, payload);
+ encode(weak_dirfrags, payload);
+ encode(weak_inodes, payload);
+ encode(strong_dentries, payload);
+ encode(authpinned_dentries, payload);
+ encode(xlocked_dentries, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(op, p);
- ::decode(strong_inodes, p);
- ::decode(inode_base, p);
- ::decode(inode_locks, p);
- ::decode(inode_scatterlocks, p);
- ::decode(authpinned_inodes, p);
- ::decode(frozen_authpin_inodes, p);
- ::decode(xlocked_inodes, p);
- ::decode(wrlocked_inodes, p);
- ::decode(cap_exports, p);
- ::decode(client_map, p);
- ::decode(imported_caps, p);
- ::decode(strong_dirfrags, p);
- ::decode(dirfrag_bases, p);
- ::decode(weak, p);
- ::decode(weak_dirfrags, p);
- ::decode(weak_inodes, p);
- ::decode(strong_dentries, p);
- ::decode(authpinned_dentries, p);
- ::decode(xlocked_dentries, p);
+ using ceph::decode;
+ decode(op, p);
+ decode(strong_inodes, p);
+ decode(inode_base, p);
+ decode(inode_locks, p);
+ decode(inode_scatterlocks, p);
+ decode(authpinned_inodes, p);
+ decode(frozen_authpin_inodes, p);
+ decode(xlocked_inodes, p);
+ decode(wrlocked_inodes, p);
+ decode(cap_exports, p);
+ decode(client_map, p);
+ decode(imported_caps, p);
+ decode(strong_dirfrags, p);
+ decode(dirfrag_bases, p);
+ decode(weak, p);
+ decode(weak_dirfrags, p);
+ decode(weak_inodes, p);
+ decode(strong_dentries, p);
+ decode(authpinned_dentries, p);
+ decode(xlocked_dentries, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(tid, payload);
- ::encode(ino, payload);
+ using ceph::encode;
+ encode(tid, payload);
+ encode(ino, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(tid, p);
- ::decode(ino, p);
+ decode(tid, p);
+ decode(ino, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(tid, payload);
- ::encode(path, payload);
+ using ceph::encode;
+ encode(tid, payload);
+ encode(path, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(tid, p);
- ::decode(path, p);
+ decode(tid, p);
+ decode(path, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
- ::encode(basefrag, payload);
- ::encode(bits, payload);
- ::encode(basebl, payload);
+ using ceph::encode;
+ encode(ino, payload);
+ encode(basefrag, payload);
+ encode(bits, payload);
+ encode(basebl, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
- ::decode(basefrag, p);
- ::decode(bits, p);
- ::decode(basebl, p);
+ decode(ino, p);
+ decode(basefrag, p);
+ decode(bits, p);
+ decode(basebl, p);
}
};
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(global_id, p);
- ::decode(targets, p);
+ decode(global_id, p);
+ decode(targets, p);
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(global_id, payload);
- ::encode(targets, payload);
+ encode(global_id, payload);
+ encode(targets, payload);
}
};
// marshalling
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(epoch, p);
- ::decode(encoded, p);
+ decode(fsid, p);
+ decode(epoch, p);
+ decode(encoded, p);
}
void encode_payload(uint64_t features) override {
- ::encode(fsid, payload);
- ::encode(epoch, payload);
+ using ceph::encode;
+ encode(fsid, payload);
+ encode(epoch, payload);
if ((features & CEPH_FEATURE_PGID64) == 0 ||
(features & CEPH_FEATURE_MDSENC) == 0 ||
(features & CEPH_FEATURE_MSG_ADDR2) == 0) {
encoded.clear();
m.encode(encoded, features);
}
- ::encode(encoded, payload);
+ encode(encoded, payload);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
- ::encode(ancestors, payload);
+ using ceph::encode;
+ encode(ino, payload);
+ encode(ancestors, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
- ::decode(ancestors, p);
+ decode(ino, p);
+ decode(ancestors, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(ino, payload);
- ::encode(ancestors, payload);
- ::encode(hint, payload);
- ::encode(error, payload);
+ using ceph::encode;
+ encode(ino, payload);
+ encode(ancestors, payload);
+ encode(hint, payload);
+ encode(error, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(ino, p);
- ::decode(ancestors, p);
- ::decode(hint, p);
- ::decode(error, p);
+ decode(ino, p);
+ decode(ancestors, p);
+ decode(hint, p);
+ decode(error, p);
}
};
bool committing;
slave_request() : committing(false) {}
void encode(bufferlist &bl) const {
- ::encode(inode_caps, bl);
- ::encode(committing, bl);
+ using ceph::encode;
+ encode(inode_caps, bl);
+ encode(committing, bl);
}
void decode(bufferlist::iterator &bl) {
- ::decode(inode_caps, bl);
- ::decode(committing, bl);
+ using ceph::decode;
+ decode(inode_caps, bl);
+ decode(committing, bl);
}
};
WRITE_CLASS_ENCODER(slave_request)
}
void encode_payload(uint64_t features) override {
- ::encode(subtrees, payload);
- ::encode(ambiguous_imports, payload);
- ::encode(slave_requests, payload);
+ using ceph::encode;
+ encode(subtrees, payload);
+ encode(ambiguous_imports, payload);
+ encode(slave_requests, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(subtrees, p);
- ::decode(ambiguous_imports, p);
- ::decode(slave_requests, p);
+ decode(subtrees, p);
+ decode(ambiguous_imports, p);
+ decode(slave_requests, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(commit, payload);
- ::encode(abort, payload);
+ using ceph::encode;
+ encode(commit, payload);
+ encode(abort, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
- ::decode(commit, p);
- ::decode(abort, p);
+ decode(commit, p);
+ decode(abort, p);
}
};
public:
void encode_payload(uint64_t features) override {
- ::encode(reqid, payload);
- ::encode(attempt, payload);
- ::encode(op, payload);
- ::encode(flags, payload);
- ::encode(lock_type, payload);
- ::encode(object_info, payload);
- ::encode(authpins, payload);
- ::encode(srcdnpath, payload);
- ::encode(destdnpath, payload);
- ::encode(witnesses, payload);
- ::encode(op_stamp, payload);
- ::encode(inode_export, payload);
- ::encode(inode_export_v, payload);
- ::encode(srcdn_auth, payload);
- ::encode(srci_replica, payload);
- ::encode(stray, payload);
+ using ceph::encode;
+ encode(reqid, payload);
+ encode(attempt, payload);
+ encode(op, payload);
+ encode(flags, payload);
+ encode(lock_type, payload);
+ encode(object_info, payload);
+ encode(authpins, payload);
+ encode(srcdnpath, payload);
+ encode(destdnpath, payload);
+ encode(witnesses, payload);
+ encode(op_stamp, payload);
+ encode(inode_export, payload);
+ encode(inode_export_v, payload);
+ encode(srcdn_auth, payload);
+ encode(srci_replica, payload);
+ encode(stray, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(reqid, p);
- ::decode(attempt, p);
- ::decode(op, p);
- ::decode(flags, p);
- ::decode(lock_type, p);
- ::decode(object_info, p);
- ::decode(authpins, p);
- ::decode(srcdnpath, p);
- ::decode(destdnpath, p);
- ::decode(witnesses, p);
- ::decode(op_stamp, p);
- ::decode(inode_export, p);
- ::decode(inode_export_v, p);
- ::decode(srcdn_auth, p);
- ::decode(srci_replica, p);
- ::decode(stray, p);
+ decode(reqid, p);
+ decode(attempt, p);
+ decode(op, p);
+ decode(flags, p);
+ decode(lock_type, p);
+ decode(object_info, p);
+ decode(authpins, p);
+ decode(srcdnpath, p);
+ decode(destdnpath, p);
+ decode(witnesses, p);
+ decode(op_stamp, p);
+ decode(inode_export, p);
+ decode(inode_export_v, p);
+ decode(srcdn_auth, p);
+ decode(srci_replica, p);
+ decode(stray, p);
}
const char *get_type_name() const override { return "slave_request"; }
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(table, p);
- ::decode(op, p);
- ::decode(reqid, p);
- ::decode(bl, p);
+ decode(table, p);
+ decode(op, p);
+ decode(reqid, p);
+ decode(bl, p);
}
void encode_payload(uint64_t features) override {
- ::encode(table, payload);
- ::encode(op, payload);
- ::encode(reqid, payload);
- ::encode(bl, payload);
+ using ceph::encode;
+ encode(table, payload);
+ encode(op, payload);
+ encode(reqid, payload);
+ encode(bl, payload);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(server_addr, payload, features);
- ::encode(gid, payload);
- ::encode(available, payload);
- ::encode(name, payload);
- ::encode(fsid, payload);
- ::encode(available_modules, payload);
- ::encode(command_descs, payload);
- ::encode(metadata, payload);
- ::encode(services, payload);
+ encode(server_addr, payload, features);
+ encode(gid, payload);
+ encode(available, payload);
+ encode(name, payload);
+ encode(fsid, payload);
+ encode(available_modules, payload);
+ encode(command_descs, payload);
+ encode(metadata, payload);
+ encode(services, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(server_addr, p);
- ::decode(gid, p);
- ::decode(available, p);
- ::decode(name, p);
+ decode(server_addr, p);
+ decode(gid, p);
+ decode(available, p);
+ decode(name, p);
if (header.version >= 2) {
- ::decode(fsid, p);
+ decode(fsid, p);
}
if (header.version >= 3) {
- ::decode(available_modules, p);
+ decode(available_modules, p);
}
if (header.version >= 4) {
- ::decode(command_descs, p);
+ decode(command_descs, p);
}
if (header.version >= 5) {
- ::decode(metadata, p);
+ decode(metadata, p);
}
if (header.version >= 6) {
- ::decode(services, p);
+ decode(services, p);
}
}
};
void decode_payload() override
{
bufferlist::iterator p = payload.begin();
- ::decode(stats_period, p);
+ decode(stats_period, p);
if (header.version >= 2) {
- ::decode(stats_threshold, p);
+ decode(stats_threshold, p);
}
}
void encode_payload(uint64_t features) override {
- ::encode(stats_period, payload);
- ::encode(stats_threshold, payload);
+ using ceph::encode;
+ encode(stats_period, payload);
+ encode(stats_threshold, payload);
}
const char *get_type_name() const override { return "mgrconfigure"; }
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(mon_status_json, p);
- ::decode(health_json, p);
+ decode(mon_status_json, p);
+ decode(health_json, p);
}
void encode_payload(uint64_t features) override {
- ::encode(mon_status_json, payload);
- ::encode(health_json, payload);
+ using ceph::encode;
+ encode(mon_status_json, payload);
+ encode(health_json, payload);
}
private:
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(map, p);
+ decode(map, p);
}
void encode_payload(uint64_t features) override {
- ::encode(map, payload, features);
+ using ceph::encode;
+ encode(map, payload, features);
}
};
void decode_payload() override
{
bufferlist::iterator p = payload.begin();
- ::decode(daemon_name, p);
+ decode(daemon_name, p);
if (header.version >= 2) {
- ::decode(service_name, p);
- ::decode(service_daemon, p);
+ decode(service_name, p);
+ decode(service_daemon, p);
if (service_daemon) {
- ::decode(daemon_metadata, p);
- ::decode(daemon_status, p);
+ decode(daemon_metadata, p);
+ decode(daemon_status, p);
}
}
}
void encode_payload(uint64_t features) override {
- ::encode(daemon_name, payload);
- ::encode(service_name, payload);
- ::encode(service_daemon, payload);
+ using ceph::encode;
+ encode(daemon_name, payload);
+ encode(service_name, payload);
+ encode(service_daemon, payload);
if (service_daemon) {
- ::encode(daemon_metadata, payload);
- ::encode(daemon_status, payload);
+ encode(daemon_metadata, payload);
+ encode(daemon_status, payload);
}
}
// encoding here, we could rely on the MgrReport
// verisoning instead.
ENCODE_START(2, 1, bl);
- ::encode(path, bl);
- ::encode(description, bl);
- ::encode(nick, bl);
+ encode(path, bl);
+ encode(description, bl);
+ encode(nick, bl);
static_assert(sizeof(type) == 1, "perfcounter_type_d must be one byte");
- ::encode((uint8_t)type, bl);
- ::encode(priority, bl);
+ encode((uint8_t)type, bl);
+ encode(priority, bl);
ENCODE_FINISH(bl);
}
void decode(bufferlist::iterator &p)
{
DECODE_START(2, p);
- ::decode(path, p);
- ::decode(description, p);
- ::decode(nick, p);
- ::decode((uint8_t&)type, p);
+ decode(path, p);
+ decode(description, p);
+ decode(nick, p);
+ decode((uint8_t&)type, p);
if (struct_v >= 2) {
- ::decode(priority, p);
+ decode(priority, p);
}
DECODE_FINISH(p);
}
void decode_payload() override
{
bufferlist::iterator p = payload.begin();
- ::decode(daemon_name, p);
- ::decode(declare_types, p);
- ::decode(packed, p);
+ decode(daemon_name, p);
+ decode(declare_types, p);
+ decode(packed, p);
if (header.version >= 2)
- ::decode(undeclare_types, p);
+ decode(undeclare_types, p);
if (header.version >= 3) {
- ::decode(service_name, p);
- ::decode(daemon_status, p);
+ decode(service_name, p);
+ decode(daemon_status, p);
}
if (header.version >= 5) {
- ::decode(osd_health_metrics, p);
+ decode(osd_health_metrics, p);
}
}
void encode_payload(uint64_t features) override {
- ::encode(daemon_name, payload);
- ::encode(declare_types, payload);
- ::encode(packed, payload);
- ::encode(undeclare_types, payload);
- ::encode(service_name, payload);
- ::encode(daemon_status, payload);
- ::encode(osd_health_metrics, payload);
+ using ceph::encode;
+ encode(daemon_name, payload);
+ encode(declare_types, payload);
+ encode(packed, payload);
+ encode(undeclare_types, payload);
+ encode(service_name, payload);
+ encode(daemon_status, payload);
+ encode(osd_health_metrics, payload);
}
const char *get_type_name() const override { return "mgrreport"; }
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(cmd, payload);
+ encode(fsid, payload);
+ encode(cmd, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(cmd, p);
+ decode(fsid, p);
+ decode(cmd, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(r, payload);
- ::encode(rs, payload);
- ::encode(cmd, payload);
+ encode(r, payload);
+ encode(rs, payload);
+ encode(cmd, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(r, p);
- ::decode(rs, p);
- ::decode(cmd, p);
+ decode(r, p);
+ decode(rs, p);
+ decode(cmd, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
if (monmap_bl.length() && (features != CEPH_FEATURES_ALL)) {
// reencode old-format monmap
MonMap t;
t.encode(monmap_bl, features);
}
- ::encode(fsid, payload);
- ::encode(op, payload);
- ::encode(epoch, payload);
- ::encode(monmap_bl, payload);
- ::encode(quorum, payload);
- ::encode(quorum_features, payload);
- ::encode((version_t)0, payload); // defunct
- ::encode((version_t)0, payload); // defunct
- ::encode(sharing_bl, payload);
- ::encode(mon_features, payload);
- ::encode(metadata, payload);
+ encode(fsid, payload);
+ encode(op, payload);
+ encode(epoch, payload);
+ encode(monmap_bl, payload);
+ encode(quorum, payload);
+ encode(quorum_features, payload);
+ encode((version_t)0, payload); // defunct
+ encode((version_t)0, payload); // defunct
+ encode(sharing_bl, payload);
+ encode(mon_features, payload);
+ encode(metadata, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(op, p);
- ::decode(epoch, p);
- ::decode(monmap_bl, p);
- ::decode(quorum, p);
- ::decode(quorum_features, p);
+ decode(fsid, p);
+ decode(op, p);
+ decode(epoch, p);
+ decode(monmap_bl, p);
+ decode(quorum, p);
+ decode(quorum_features, p);
{
version_t v; // defunct fields from old encoding
- ::decode(v, p);
- ::decode(v, p);
+ decode(v, p);
+ decode(v, p);
}
- ::decode(sharing_bl, p);
+ decode(sharing_bl, p);
if (header.version >= 6)
- ::decode(mon_features, p);
+ decode(mon_features, p);
if (header.version >= 7)
- ::decode(metadata, p);
+ decode(metadata, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(full_first, payload);
- ::encode(full_last, payload);
- ::encode(inc_first, payload);
- ::encode(inc_last, payload);
+ encode(full_first, payload);
+ encode(full_last, payload);
+ encode(inc_first, payload);
+ encode(inc_last, payload);
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(full_first, p);
- ::decode(full_last, p);
- ::decode(inc_first, p);
- ::decode(inc_last, p);
+ decode(full_first, p);
+ decode(full_last, p);
+ decode(inc_first, p);
+ decode(inc_last, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(handle, payload);
- ::encode(what, payload);
+ using ceph::encode;
+ encode(handle, payload);
+ encode(what, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(handle, p);
- ::decode(what, p);
+ decode(handle, p);
+ decode(what, p);
}
ceph_tid_t handle = 0;
}
void encode_payload(uint64_t features) override {
- ::encode(handle, payload);
- ::encode(version, payload);
- ::encode(oldest_version, payload);
+ using ceph::encode;
+ encode(handle, payload);
+ encode(version, payload);
+ encode(oldest_version, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(handle, p);
- ::decode(version, p);
+ decode(handle, p);
+ decode(version, p);
if (header.version >= 2)
- ::decode(oldest_version, p);
+ decode(oldest_version, p);
}
ceph_tid_t handle = 0;
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(old_max_id, p);
+ decode(old_max_id, p);
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(old_max_id, payload);
+ encode(old_max_id, payload);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(health_checks, p);
+ decode(health_checks, p);
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(health_checks, payload);
+ encode(health_checks, payload);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(name, payload);
- ::encode(addr, payload, features);
+ encode(fsid, payload);
+ encode(name, payload);
+ encode(addr, payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(name, p);
- ::decode(addr, p);
+ decode(fsid, p);
+ decode(name, p);
+ decode(addr, p);
}
};
t.encode(monmapbl, features);
}
- ::encode(monmapbl, payload);
+ using ceph::encode;
+ encode(monmapbl, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(monmapbl, p);
+ decode(monmapbl, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(data, payload);
+ using ceph::encode;
+ encode(data, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(data, p);
+ decode(data, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(health_checks, payload);
- ::encode(service_map_bl, payload);
+ encode(health_checks, payload);
+ encode(service_map_bl, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(health_checks, p);
- ::decode(service_map_bl, p);
+ decode(health_checks, p);
+ decode(service_map_bl, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
header.version = HEAD_VERSION;
- ::encode(epoch, payload);
- ::encode(op, payload);
- ::encode(first_committed, payload);
- ::encode(last_committed, payload);
- ::encode(pn_from, payload);
- ::encode(pn, payload);
- ::encode(uncommitted_pn, payload);
- ::encode(lease_timestamp, payload);
- ::encode(sent_timestamp, payload);
- ::encode(latest_version, payload);
- ::encode(latest_value, payload);
- ::encode(values, payload);
- ::encode(feature_map, payload);
+ encode(epoch, payload);
+ encode(op, payload);
+ encode(first_committed, payload);
+ encode(last_committed, payload);
+ encode(pn_from, payload);
+ encode(pn, payload);
+ encode(uncommitted_pn, payload);
+ encode(lease_timestamp, payload);
+ encode(sent_timestamp, payload);
+ encode(latest_version, payload);
+ encode(latest_value, payload);
+ encode(values, payload);
+ encode(feature_map, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(op, p);
- ::decode(first_committed, p);
- ::decode(last_committed, p);
- ::decode(pn_from, p);
- ::decode(pn, p);
- ::decode(uncommitted_pn, p);
- ::decode(lease_timestamp, p);
- ::decode(sent_timestamp, p);
- ::decode(latest_version, p);
- ::decode(latest_value, p);
- ::decode(values, p);
+ decode(epoch, p);
+ decode(op, p);
+ decode(first_committed, p);
+ decode(last_committed, p);
+ decode(pn_from, p);
+ decode(pn, p);
+ decode(uncommitted_pn, p);
+ decode(lease_timestamp, p);
+ decode(sent_timestamp, p);
+ decode(latest_version, p);
+ decode(latest_value, p);
+ decode(values, p);
if (header.version >= 4) {
- ::decode(feature_map, p);
+ decode(feature_map, p);
}
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
if (monmap_bl.length() &&
((features & CEPH_FEATURE_MONENC) == 0 ||
(features & CEPH_FEATURE_MSG_ADDR2) == 0)) {
t.encode(monmap_bl, features);
}
- ::encode(fsid, payload);
- ::encode(op, payload);
- ::encode(name, payload);
- ::encode(quorum, payload);
- ::encode(monmap_bl, payload);
- ::encode(has_ever_joined, payload);
- ::encode(paxos_first_version, payload);
- ::encode(paxos_last_version, payload);
- ::encode(required_features, payload);
+ encode(fsid, payload);
+ encode(op, payload);
+ encode(name, payload);
+ encode(quorum, payload);
+ encode(monmap_bl, payload);
+ encode(has_ever_joined, payload);
+ encode(paxos_first_version, payload);
+ encode(paxos_last_version, payload);
+ encode(required_features, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(op, p);
- ::decode(name, p);
- ::decode(quorum, p);
- ::decode(monmap_bl, p);
- ::decode(has_ever_joined, p);
- ::decode(paxos_first_version, p);
- ::decode(paxos_last_version, p);
+ decode(fsid, p);
+ decode(op, p);
+ decode(name, p);
+ decode(quorum, p);
+ decode(monmap_bl, p);
+ decode(has_ever_joined, p);
+ decode(paxos_first_version, p);
+ decode(paxos_last_version, p);
if (header.version >= 6)
- ::decode(required_features, p);
+ decode(required_features, p);
else
required_features = 0;
}
}
void service_encode() {
- ::encode(epoch, payload);
- ::encode(round, payload);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(round, payload);
}
void service_decode(bufferlist::iterator &p) {
- ::decode(epoch, p);
- ::decode(round, p);
+ decode(epoch, p);
+ decode(round, p);
}
void encode_payload(uint64_t features) override {
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
uint8_t o = op;
- ::encode(o, payload);
- ::encode(version, payload);
- ::encode(result, payload);
- ::encode(num_keys, payload);
- ::encode(key, payload);
+ encode(o, payload);
+ encode(version, payload);
+ encode(result, payload);
+ encode(num_keys, payload);
+ encode(key, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
uint8_t o;
- ::decode(o, p);
+ decode(o, p);
op = (op_type_t)o;
- ::decode(version, p);
- ::decode(result, p);
- ::decode(num_keys, p);
- ::decode(key, p);
+ decode(version, p);
+ decode(result, p);
+ decode(num_keys, p);
+ decode(key, p);
}
};
bufferlist::iterator p = payload.begin();
if (header.version < 2) {
map<string, ceph_mon_subscribe_item_old> oldwhat;
- ::decode(oldwhat, p);
+ decode(oldwhat, p);
what.clear();
for (map<string, ceph_mon_subscribe_item_old>::iterator q = oldwhat.begin();
q != oldwhat.end();
what[q->first].flags |= CEPH_SUBSCRIBE_ONETIME;
}
} else {
- ::decode(what, p);
+ decode(what, p);
}
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
if (features & CEPH_FEATURE_SUBSCRIBE2) {
- ::encode(what, payload);
+ encode(what, payload);
header.version = HEAD_VERSION;
} else {
header.version = 0;
oldwhat[q->first].have = 0;
oldwhat[q->first].onetime = q->second.flags & CEPH_SUBSCRIBE_ONETIME;
}
- ::encode(oldwhat, payload);
+ encode(oldwhat, payload);
}
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(interval, p);
- ::decode(fsid, p);
+ decode(interval, p);
+ decode(fsid, p);
}
void encode_payload(uint64_t features) override {
- ::encode(interval, payload);
- ::encode(fsid, payload);
+ using ceph::encode;
+ encode(interval, payload);
+ encode(fsid, payload);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(op, payload);
- ::encode(cookie, payload);
- ::encode(last_committed, payload);
- ::encode(last_key.first, payload);
- ::encode(last_key.second, payload);
- ::encode(chunk_bl, payload);
- ::encode(reply_to, payload, features);
+ using ceph::encode;
+ encode(op, payload);
+ encode(cookie, payload);
+ encode(last_committed, payload);
+ encode(last_key.first, payload);
+ encode(last_key.second, payload);
+ encode(chunk_bl, payload);
+ encode(reply_to, payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(op, p);
- ::decode(cookie, p);
- ::decode(last_committed, p);
- ::decode(last_key.first, p);
- ::decode(last_key.second, p);
- ::decode(chunk_bl, p);
- ::decode(reply_to, p);
+ decode(op, p);
+ decode(cookie, p);
+ decode(last_committed, p);
+ decode(last_key.first, p);
+ decode(last_key.second, p);
+ decode(chunk_bl, p);
+ decode(reply_to, p);
}
};
~MNop() {}
void encode_payload(uint64_t _features) {
- ::encode(tag, payload);
+ using ceph::encode;
+ encode(tag, payload);
}
void decode_payload() {
bufferlist::iterator p = payload.begin();
- ::decode(tag, p);
+ decode(tag, p);
}
const char *get_type_name() const { return "MNop"; }
public:
void encode_payload(uint64_t features) override {
paxos_encode();
- ::encode(want, payload);
+ using ceph::encode;
+ encode(want, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(want, p);
+ decode(want, p);
}
const char *get_type_name() const override { return "osd_alive"; }
end(end_) { }
void encode_payload(uint64_t features) override {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(op, payload);
- ::encode(id, payload);
- ::encode(begin, payload);
- ::encode(end, payload);
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(op, payload);
+ encode(id, payload);
+ encode(begin, payload);
+ encode(end, payload);
}
void decode_payload() override {
auto p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(op, p);
- ::decode(id, p);
- ::decode(begin, p);
- ::decode(end, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(op, p);
+ decode(id, p);
+ decode(begin, p);
+ decode(end, p);
}
const char *get_type_name() const override { return "osd_backoff"; }
min_last_epoch_clean(min_lec)
{}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(pgs, payload);
- ::encode(min_last_epoch_clean, payload);
+ encode(pgs, payload);
+ encode(min_last_epoch_clean, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(pgs, p);
- ::decode(min_last_epoch_clean, p);
+ decode(pgs, p);
+ decode(min_last_epoch_clean, p);
}
const char *get_type_name() const override { return "osd_beacon"; }
void print(ostream &out) const {
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(sb, payload);
- ::encode(hb_back_addr, payload, features);
- ::encode(cluster_addr, payload, features);
- ::encode(boot_epoch, payload);
- ::encode(hb_front_addr, payload, features);
- ::encode(metadata, payload);
- ::encode(osd_features, payload);
+ encode(sb, payload);
+ encode(hb_back_addr, payload, features);
+ encode(cluster_addr, payload, features);
+ encode(boot_epoch, payload);
+ encode(hb_front_addr, payload, features);
+ encode(metadata, payload);
+ encode(osd_features, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(sb, p);
- ::decode(hb_back_addr, p);
- ::decode(cluster_addr, p);
- ::decode(boot_epoch, p);
- ::decode(hb_front_addr, p);
- ::decode(metadata, p);
- ::decode(osd_features, p);
+ decode(sb, p);
+ decode(hb_back_addr, p);
+ decode(cluster_addr, p);
+ decode(boot_epoch, p);
+ decode(hb_front_addr, p);
+ decode(metadata, p);
+ decode(osd_features, p);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(op, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(op, p);
if (header.version >= 3) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
decode_trace(p);
} else {
min_epoch = map_epoch;
}
void encode_payload(uint64_t features) override {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(op, payload, features);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(op, payload, features);
+ encode(min_epoch, payload);
encode_trace(payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(op, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(op, p);
if (header.version >= 2) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
decode_trace(p);
} else {
min_epoch = map_epoch;
}
void encode_payload(uint64_t features) override {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(op, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(op, payload);
+ encode(min_epoch, payload);
encode_trace(payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(op, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(op, p);
if (header.version >= 2) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
decode_trace(p);
} else {
min_epoch = map_epoch;
}
void encode_payload(uint64_t features) override {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(op, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(op, payload);
+ encode(min_epoch, payload);
encode_trace(payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(op, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(op, p);
if (header.version >= 2) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
decode_trace(p);
} else {
min_epoch = map_epoch;
}
void encode_payload(uint64_t features) override {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(op, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(op, payload);
+ encode(min_epoch, payload);
encode_trace(payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(target_osd, p);
- ::decode(epoch, p);
- ::decode(flags, p);
- ::decode(failed_for, p);
+ decode(fsid, p);
+ decode(target_osd, p);
+ decode(epoch, p);
+ decode(flags, p);
+ decode(failed_for, p);
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(target_osd, payload, features);
- ::encode(epoch, payload);
- ::encode(flags, payload);
- ::encode(failed_for, payload);
+ encode(fsid, payload);
+ encode(target_osd, payload, features);
+ encode(epoch, payload);
+ encode(flags, payload);
+ encode(failed_for, payload);
}
const char *get_type_name() const override { return "osd_failure"; }
}
void encode_payload(uint64_t features) {
- ::encode(fsid, payload);
- ::encode(forced_pgs, payload);
- ::encode(options, payload);
+ using ceph::encode;
+ encode(fsid, payload);
+ encode(forced_pgs, payload);
+ encode(options, payload);
}
void decode_payload() {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(forced_pgs, p);
- ::decode(options, p);
+ decode(fsid, p);
+ decode(forced_pgs, p);
+ decode(options, p);
}
};
public:
void encode_payload(uint64_t features) {
+ using ceph::encode;
paxos_encode();
- ::encode(map_epoch, payload);
- ::encode(state, payload);
+ encode(map_epoch, payload);
+ encode(state, payload);
}
void decode_payload() {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(map_epoch, p);
- ::decode(state, p);
+ decode(map_epoch, p);
+ decode(state, p);
}
const char *get_type_name() const { return "osd_full"; }
// marshalling
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(incremental_maps, p);
- ::decode(maps, p);
+ decode(fsid, p);
+ decode(incremental_maps, p);
+ decode(maps, p);
if (header.version >= 2) {
- ::decode(oldest_map, p);
- ::decode(newest_map, p);
+ decode(oldest_map, p);
+ decode(newest_map, p);
} else {
oldest_map = 0;
newest_map = 0;
}
if (header.version >= 4) {
- ::decode(gap_removed_snaps, p);
+ decode(gap_removed_snaps, p);
}
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
header.version = HEAD_VERSION;
header.compat_version = COMPAT_VERSION;
- ::encode(fsid, payload);
+ encode(fsid, payload);
if ((features & CEPH_FEATURE_PGID64) == 0 ||
(features & CEPH_FEATURE_PGPOOL3) == 0 ||
(features & CEPH_FEATURE_OSDENC) == 0 ||
m.encode(p->second, features | CEPH_FEATURE_RESERVED);
}
}
- ::encode(incremental_maps, payload);
- ::encode(maps, payload);
+ encode(incremental_maps, payload);
+ encode(maps, payload);
if (header.version >= 2) {
- ::encode(oldest_map, payload);
- ::encode(newest_map, payload);
+ encode(oldest_map, payload);
+ encode(newest_map, payload);
}
if (header.version >= 4) {
- ::encode(gap_removed_snaps, payload);
+ encode(gap_removed_snaps, payload);
}
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(target_osd, p);
- ::decode(epoch, p);
- ::decode(request_ack, p);
+ decode(fsid, p);
+ decode(target_osd, p);
+ decode(epoch, p);
+ decode(request_ack, p);
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(target_osd, payload, features);
- ::encode(epoch, payload);
- ::encode(request_ack, payload);
+ encode(fsid, payload);
+ encode(target_osd, payload, features);
+ encode(epoch, payload);
+ encode(request_ack, payload);
}
const char *get_type_name() const override { return "MOSDMarkMeDown"; }
// marshalling
void encode_payload(uint64_t features) override {
+ using ceph::encode;
if( false == bdata_encode ) {
OSDOp::merge_osd_op_vector_in_data(ops, data);
bdata_encode = true;
#endif
header.version = 1;
- ::encode(client_inc, payload);
+ encode(client_inc, payload);
__u32 su = 0;
- ::encode(get_raw_pg(), payload);
- ::encode(su, payload);
+ encode(get_raw_pg(), payload);
+ encode(su, payload);
- ::encode(osdmap_epoch, payload);
- ::encode(flags, payload);
- ::encode(mtime, payload);
- ::encode(eversion_t(), payload); // reassert_version
+ encode(osdmap_epoch, payload);
+ encode(flags, payload);
+ encode(mtime, payload);
+ encode(eversion_t(), payload); // reassert_version
__u32 oid_len = hobj.oid.name.length();
- ::encode(oid_len, payload);
- ::encode(hobj.snap, payload);
- ::encode(snap_seq, payload);
+ encode(oid_len, payload);
+ encode(hobj.snap, payload);
+ encode(snap_seq, payload);
__u32 num_snaps = snaps.size();
- ::encode(num_snaps, payload);
+ encode(num_snaps, payload);
//::encode(ops, payload);
__u16 num_ops = ops.size();
- ::encode(num_ops, payload);
+ encode(num_ops, payload);
for (unsigned i = 0; i < ops.size(); i++)
- ::encode(ops[i].op, payload);
+ encode(ops[i].op, payload);
- ::encode_nohead(hobj.oid.name, payload);
- ::encode_nohead(snaps, payload);
+ encode_nohead(hobj.oid.name, payload);
+ encode_nohead(snaps, payload);
} else if ((features & CEPH_FEATURE_NEW_OSDOP_ENCODING) == 0) {
header.version = 6;
- ::encode(client_inc, payload);
- ::encode(osdmap_epoch, payload);
- ::encode(flags, payload);
- ::encode(mtime, payload);
- ::encode(eversion_t(), payload); // reassert_version
- ::encode(get_object_locator(), payload);
- ::encode(get_raw_pg(), payload);
+ encode(client_inc, payload);
+ encode(osdmap_epoch, payload);
+ encode(flags, payload);
+ encode(mtime, payload);
+ encode(eversion_t(), payload); // reassert_version
+ encode(get_object_locator(), payload);
+ encode(get_raw_pg(), payload);
- ::encode(hobj.oid, payload);
+ encode(hobj.oid, payload);
__u16 num_ops = ops.size();
- ::encode(num_ops, payload);
+ encode(num_ops, payload);
for (unsigned i = 0; i < ops.size(); i++)
- ::encode(ops[i].op, payload);
+ encode(ops[i].op, payload);
- ::encode(hobj.snap, payload);
- ::encode(snap_seq, payload);
- ::encode(snaps, payload);
+ encode(hobj.snap, payload);
+ encode(snap_seq, payload);
+ encode(snaps, payload);
- ::encode(retry_attempt, payload);
- ::encode(features, payload);
+ encode(retry_attempt, payload);
+ encode(features, payload);
if (reqid.name != entity_name_t() || reqid.tid != 0) {
- ::encode(reqid, payload);
+ encode(reqid, payload);
} else {
// don't include client_inc in the reqid for the legacy v6
// encoding or else we'll confuse older peers.
- ::encode(osd_reqid_t(), payload);
+ encode(osd_reqid_t(), payload);
}
} else if (!HAVE_FEATURE(features, RESEND_ON_SPLIT)) {
// reordered, v7 message encoding
header.version = 7;
- ::encode(get_raw_pg(), payload);
- ::encode(osdmap_epoch, payload);
- ::encode(flags, payload);
- ::encode(eversion_t(), payload); // reassert_version
- ::encode(reqid, payload);
- ::encode(client_inc, payload);
- ::encode(mtime, payload);
- ::encode(get_object_locator(), payload);
- ::encode(hobj.oid, payload);
+ encode(get_raw_pg(), payload);
+ encode(osdmap_epoch, payload);
+ encode(flags, payload);
+ encode(eversion_t(), payload); // reassert_version
+ encode(reqid, payload);
+ encode(client_inc, payload);
+ encode(mtime, payload);
+ encode(get_object_locator(), payload);
+ encode(hobj.oid, payload);
__u16 num_ops = ops.size();
- ::encode(num_ops, payload);
+ encode(num_ops, payload);
for (unsigned i = 0; i < ops.size(); i++)
- ::encode(ops[i].op, payload);
+ encode(ops[i].op, payload);
- ::encode(hobj.snap, payload);
- ::encode(snap_seq, payload);
- ::encode(snaps, payload);
+ encode(hobj.snap, payload);
+ encode(snap_seq, payload);
+ encode(snaps, payload);
- ::encode(retry_attempt, payload);
- ::encode(features, payload);
+ encode(retry_attempt, payload);
+ encode(features, payload);
} else {
// v9 encoding for dmclock use, otherwise v8.
// v8 encoding with hobject_t hash separate from pgid, no
header.version = 8;
}
- ::encode(pgid, payload);
- ::encode(hobj.get_hash(), payload);
- ::encode(osdmap_epoch, payload);
- ::encode(flags, payload);
- ::encode(reqid, payload);
+ encode(pgid, payload);
+ encode(hobj.get_hash(), payload);
+ encode(osdmap_epoch, payload);
+ encode(flags, payload);
+ encode(reqid, payload);
if (header.version >= 9) {
- ::encode(qos_params, payload);
+ encode(qos_params, payload);
}
encode_trace(payload, features);
// -- above decoded up front; below decoded post-dispatch thread --
- ::encode(client_inc, payload);
- ::encode(mtime, payload);
- ::encode(get_object_locator(), payload);
- ::encode(hobj.oid, payload);
+ encode(client_inc, payload);
+ encode(mtime, payload);
+ encode(get_object_locator(), payload);
+ encode(hobj.oid, payload);
__u16 num_ops = ops.size();
- ::encode(num_ops, payload);
+ encode(num_ops, payload);
for (unsigned i = 0; i < ops.size(); i++)
- ::encode(ops[i].op, payload);
+ encode(ops[i].op, payload);
- ::encode(hobj.snap, payload);
- ::encode(snap_seq, payload);
- ::encode(snaps, payload);
+ encode(hobj.snap, payload);
+ encode(snap_seq, payload);
+ encode(snaps, payload);
- ::encode(retry_attempt, payload);
- ::encode(features, payload);
+ encode(retry_attempt, payload);
+ encode(features, payload);
}
}
// Always keep here the newest version of decoding order/rule
if (header.version >= 8) {
- ::decode(pgid, p); // actual pgid
+ decode(pgid, p); // actual pgid
uint32_t hash;
- ::decode(hash, p); // raw hash value
+ decode(hash, p); // raw hash value
hobj.set_hash(hash);
- ::decode(osdmap_epoch, p);
- ::decode(flags, p);
- ::decode(reqid, p);
+ decode(osdmap_epoch, p);
+ decode(flags, p);
+ decode(reqid, p);
if (header.version >= 9)
- ::decode(qos_params, p);
+ decode(qos_params, p);
decode_trace(p);
} else if (header.version == 7) {
- ::decode(pgid.pgid, p); // raw pgid
+ decode(pgid.pgid, p); // raw pgid
hobj.set_hash(pgid.pgid.ps());
- ::decode(osdmap_epoch, p);
- ::decode(flags, p);
+ decode(osdmap_epoch, p);
+ decode(flags, p);
eversion_t reassert_version;
- ::decode(reassert_version, p);
- ::decode(reqid, p);
+ decode(reassert_version, p);
+ decode(reqid, p);
} else if (header.version < 2) {
// old decode
- ::decode(client_inc, p);
+ decode(client_inc, p);
old_pg_t opgid;
::decode_raw(opgid, p);
pgid.pgid = opgid;
__u32 su;
- ::decode(su, p);
+ decode(su, p);
- ::decode(osdmap_epoch, p);
- ::decode(flags, p);
- ::decode(mtime, p);
+ decode(osdmap_epoch, p);
+ decode(flags, p);
+ decode(mtime, p);
eversion_t reassert_version;
- ::decode(reassert_version, p);
+ decode(reassert_version, p);
__u32 oid_len;
- ::decode(oid_len, p);
- ::decode(hobj.snap, p);
- ::decode(snap_seq, p);
+ decode(oid_len, p);
+ decode(hobj.snap, p);
+ decode(snap_seq, p);
__u32 num_snaps;
- ::decode(num_snaps, p);
+ decode(num_snaps, p);
//::decode(ops, p);
__u16 num_ops;
- ::decode(num_ops, p);
+ decode(num_ops, p);
ops.resize(num_ops);
for (unsigned i = 0; i < num_ops; i++)
- ::decode(ops[i].op, p);
+ decode(ops[i].op, p);
decode_nohead(oid_len, hobj.oid.name, p);
decode_nohead(num_snaps, snaps, p);
reqid = osd_reqid_t();
reqid.inc = client_inc;
} else if (header.version < 7) {
- ::decode(client_inc, p);
- ::decode(osdmap_epoch, p);
- ::decode(flags, p);
- ::decode(mtime, p);
+ decode(client_inc, p);
+ decode(osdmap_epoch, p);
+ decode(flags, p);
+ decode(mtime, p);
eversion_t reassert_version;
- ::decode(reassert_version, p);
+ decode(reassert_version, p);
object_locator_t oloc;
- ::decode(oloc, p);
+ decode(oloc, p);
if (header.version < 3) {
old_pg_t opgid;
::decode_raw(opgid, p);
pgid.pgid = opgid;
} else {
- ::decode(pgid.pgid, p);
+ decode(pgid.pgid, p);
}
- ::decode(hobj.oid, p);
+ decode(hobj.oid, p);
//::decode(ops, p);
__u16 num_ops;
- ::decode(num_ops, p);
+ decode(num_ops, p);
ops.resize(num_ops);
for (unsigned i = 0; i < num_ops; i++)
- ::decode(ops[i].op, p);
+ decode(ops[i].op, p);
- ::decode(hobj.snap, p);
- ::decode(snap_seq, p);
- ::decode(snaps, p);
+ decode(hobj.snap, p);
+ decode(snap_seq, p);
+ decode(snaps, p);
if (header.version >= 4)
- ::decode(retry_attempt, p);
+ decode(retry_attempt, p);
else
retry_attempt = -1;
if (header.version >= 5)
- ::decode(features, p);
+ decode(features, p);
else
features = 0;
if (header.version >= 6)
- ::decode(reqid, p);
+ decode(reqid, p);
else
reqid = osd_reqid_t();
return false; // Message is already final decoded
assert(header.version >= 7);
- ::decode(client_inc, p);
- ::decode(mtime, p);
+ decode(client_inc, p);
+ decode(mtime, p);
object_locator_t oloc;
- ::decode(oloc, p);
- ::decode(hobj.oid, p);
+ decode(oloc, p);
+ decode(hobj.oid, p);
__u16 num_ops;
- ::decode(num_ops, p);
+ decode(num_ops, p);
ops.resize(num_ops);
for (unsigned i = 0; i < num_ops; i++)
- ::decode(ops[i].op, p);
+ decode(ops[i].op, p);
- ::decode(hobj.snap, p);
- ::decode(snap_seq, p);
- ::decode(snaps, p);
+ decode(hobj.snap, p);
+ decode(snap_seq, p);
+ decode(snaps, p);
- ::decode(retry_attempt, p);
+ decode(retry_attempt, p);
- ::decode(features, p);
+ decode(features, p);
hobj.pool = pgid.pgid.pool();
hobj.set_key(oloc.key);
public:
void encode_payload(uint64_t features) override {
+ using ceph::encode;
if(false == bdata_encode) {
OSDOp::merge_osd_op_vector_out_data(ops, data);
bdata_encode = true;
head.result = result;
head.num_ops = ops.size();
head.object_len = oid.name.length();
- ::encode(head, payload);
+ encode(head, payload);
for (unsigned i = 0; i < head.num_ops; i++) {
- ::encode(ops[i].op, payload);
+ encode(ops[i].op, payload);
}
- ::encode_nohead(oid.name, payload);
+ encode_nohead(oid.name, payload);
} else {
header.version = HEAD_VERSION;
- ::encode(oid, payload);
- ::encode(pgid, payload);
- ::encode(flags, payload);
- ::encode(result, payload);
- ::encode(bad_replay_version, payload);
- ::encode(osdmap_epoch, payload);
+ encode(oid, payload);
+ encode(pgid, payload);
+ encode(flags, payload);
+ encode(result, payload);
+ encode(bad_replay_version, payload);
+ encode(osdmap_epoch, payload);
__u32 num_ops = ops.size();
- ::encode(num_ops, payload);
+ encode(num_ops, payload);
for (unsigned i = 0; i < num_ops; i++)
- ::encode(ops[i].op, payload);
+ encode(ops[i].op, payload);
- ::encode(retry_attempt, payload);
+ encode(retry_attempt, payload);
for (unsigned i = 0; i < num_ops; i++)
- ::encode(ops[i].rval, payload);
+ encode(ops[i].rval, payload);
- ::encode(replay_version, payload);
- ::encode(user_version, payload);
+ encode(replay_version, payload);
+ encode(user_version, payload);
if ((features & CEPH_FEATURE_NEW_OSDOPREPLY_ENCODING) == 0) {
header.version = 6;
- ::encode(redirect, payload);
+ encode(redirect, payload);
} else {
do_redirect = !redirect.empty();
- ::encode(do_redirect, payload);
+ encode(do_redirect, payload);
if (do_redirect) {
- ::encode(redirect, payload);
+ encode(redirect, payload);
}
if ((features & CEPH_FEATURE_QOS_DMC) == 0) {
header.version = 8;
} else {
- ::encode(qos_resp, payload);
+ encode(qos_resp, payload);
}
}
encode_trace(payload, features);
}
}
void decode_payload() override {
+ using ceph::decode;
bufferlist::iterator p = payload.begin();
// Always keep here the newest version of decoding order/rule
if (header.version == HEAD_VERSION) {
- ::decode(oid, p);
- ::decode(pgid, p);
- ::decode(flags, p);
- ::decode(result, p);
- ::decode(bad_replay_version, p);
- ::decode(osdmap_epoch, p);
+ decode(oid, p);
+ decode(pgid, p);
+ decode(flags, p);
+ decode(result, p);
+ decode(bad_replay_version, p);
+ decode(osdmap_epoch, p);
__u32 num_ops = ops.size();
- ::decode(num_ops, p);
+ decode(num_ops, p);
ops.resize(num_ops);
for (unsigned i = 0; i < num_ops; i++)
- ::decode(ops[i].op, p);
- ::decode(retry_attempt, p);
+ decode(ops[i].op, p);
+ decode(retry_attempt, p);
for (unsigned i = 0; i < num_ops; ++i)
- ::decode(ops[i].rval, p);
+ decode(ops[i].rval, p);
OSDOp::split_osd_op_vector_out_data(ops, data);
- ::decode(replay_version, p);
- ::decode(user_version, p);
- ::decode(do_redirect, p);
+ decode(replay_version, p);
+ decode(user_version, p);
+ decode(do_redirect, p);
if (do_redirect)
- ::decode(redirect, p);
- ::decode(qos_resp, p);
+ decode(redirect, p);
+ decode(qos_resp, p);
decode_trace(p);
} else if (header.version < 2) {
ceph_osd_reply_head head;
- ::decode(head, p);
+ decode(head, p);
ops.resize(head.num_ops);
for (unsigned i = 0; i < head.num_ops; i++) {
- ::decode(ops[i].op, p);
+ decode(ops[i].op, p);
}
- ::decode_nohead(head.object_len, oid.name, p);
+ decode_nohead(head.object_len, oid.name, p);
pgid = pg_t(head.layout.ol_pgid);
result = (int32_t)head.result;
flags = head.flags;
osdmap_epoch = head.osdmap_epoch;
retry_attempt = -1;
} else {
- ::decode(oid, p);
- ::decode(pgid, p);
- ::decode(flags, p);
- ::decode(result, p);
- ::decode(bad_replay_version, p);
- ::decode(osdmap_epoch, p);
+ decode(oid, p);
+ decode(pgid, p);
+ decode(flags, p);
+ decode(result, p);
+ decode(bad_replay_version, p);
+ decode(osdmap_epoch, p);
__u32 num_ops = ops.size();
- ::decode(num_ops, p);
+ decode(num_ops, p);
ops.resize(num_ops);
for (unsigned i = 0; i < num_ops; i++)
- ::decode(ops[i].op, p);
+ decode(ops[i].op, p);
if (header.version >= 3)
- ::decode(retry_attempt, p);
+ decode(retry_attempt, p);
else
retry_attempt = -1;
if (header.version >= 4) {
for (unsigned i = 0; i < num_ops; ++i)
- ::decode(ops[i].rval, p);
+ decode(ops[i].rval, p);
OSDOp::split_osd_op_vector_out_data(ops, data);
}
if (header.version >= 5) {
- ::decode(replay_version, p);
- ::decode(user_version, p);
+ decode(replay_version, p);
+ decode(user_version, p);
} else {
replay_version = bad_replay_version;
user_version = replay_version.version;
}
if (header.version == 6) {
- ::decode(redirect, p);
+ decode(redirect, p);
do_redirect = !redirect.empty();
}
if (header.version >= 7) {
- ::decode(do_redirect, p);
+ decode(do_redirect, p);
if (do_redirect) {
- ::decode(redirect, p);
+ decode(redirect, p);
}
}
if (header.version >= 8) {
if (header.version >= 9) {
- ::decode(qos_resp, p);
+ decode(qos_resp, p);
}
decode_trace(p);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(op, p);
- ::decode(map_epoch, p);
- ::decode(query_epoch, p);
- ::decode(pgid.pgid, p);
- ::decode(last_backfill, p);
+ decode(op, p);
+ decode(map_epoch, p);
+ decode(query_epoch, p);
+ decode(pgid.pgid, p);
+ decode(last_backfill, p);
// For compatibility with version 1
- ::decode(stats.stats, p);
+ decode(stats.stats, p);
- ::decode(stats, p);
+ decode(stats, p);
// Handle hobject_t format change
if (!last_backfill.is_max() &&
last_backfill.pool == -1)
last_backfill.pool = pgid.pool();
- ::decode(pgid.shard, p);
+ decode(pgid.shard, p);
}
void encode_payload(uint64_t features) override {
- ::encode(op, payload);
- ::encode(map_epoch, payload);
- ::encode(query_epoch, payload);
- ::encode(pgid.pgid, payload);
- ::encode(last_backfill, payload);
+ using ceph::encode;
+ encode(op, payload);
+ encode(map_epoch, payload);
+ encode(query_epoch, payload);
+ encode(pgid.pgid, payload);
+ encode(last_backfill, payload);
// For compatibility with version 1
- ::encode(stats.stats, payload);
+ encode(stats.stats, payload);
- ::encode(stats, payload);
+ encode(stats, payload);
- ::encode(pgid.shard, payload);
+ encode(pgid.shard, payload);
}
MOSDPGBackfill()
~MOSDPGBackfillRemove() {}
public:
- const char *get_type_name() const { return "backfill_remove"; }
- void print(ostream& out) const {
+ const char *get_type_name() const override { return "backfill_remove"; }
+ void print(ostream& out) const override {
out << "backfill_remove(" << pgid << " e" << map_epoch
<< " " << ls << ")";
}
- void encode_payload(uint64_t features) {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(ls, payload);
+ void encode_payload(uint64_t features) override {
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(ls, payload);
}
- void decode_payload() {
+ void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(ls, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(ls, p);
}
};
const char *get_type_name() const override { return "pg_create"; }
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(mkpg, payload);
- ::encode(ctimes, payload);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(mkpg, payload);
+ encode(ctimes, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(mkpg, p);
- ::decode(ctimes, p);
+ decode(epoch, p);
+ decode(mkpg, p);
+ decode(ctimes, p);
}
void print(ostream& out) const override {
out << "osd_pg_created(" << pgid << ")";
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(pgid, payload);
+ encode(pgid, payload);
}
void decode_payload() override {
auto p = payload.begin();
paxos_decode(p);
- ::decode(pgid, p);
+ decode(pgid, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(pg_list, payload);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(pg_list, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(pg_list, p);
+ decode(epoch, p);
+ decode(pg_list, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(info, payload);
- ::encode(log, payload);
- ::encode(missing, payload);
- ::encode(query_epoch, payload);
- ::encode(past_intervals, payload);
- ::encode(to, payload);
- ::encode(from, payload);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(info, payload);
+ encode(log, payload);
+ encode(missing, payload);
+ encode(query_epoch, payload);
+ encode(past_intervals, payload);
+ encode(to, payload);
+ encode(from, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(info, p);
+ decode(epoch, p);
+ decode(info, p);
log.decode(p, info.pgid.pool());
missing.decode(p, info.pgid.pool());
- ::decode(query_epoch, p);
- ::decode(past_intervals, p);
- ::decode(to, p);
- ::decode(from, p);
+ decode(query_epoch, p);
+ decode(past_intervals, p);
+ decode(to, p);
+ decode(from, p);
}
};
const char *get_type_name() const override { return "PGnot"; }
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(pg_list, payload);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(pg_list, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(pg_list, p);
+ decode(epoch, p);
+ decode(pg_list, p);
}
void print(ostream& out) const override {
out << "pg_notify(";
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid.pgid, p);
- ::decode(map_epoch, p);
- ::decode(pulls, p);
- ::decode(cost, p);
- ::decode(pgid.shard, p);
- ::decode(from, p);
+ decode(pgid.pgid, p);
+ decode(map_epoch, p);
+ decode(pulls, p);
+ decode(cost, p);
+ decode(pgid.shard, p);
+ decode(from, p);
if (header.version >= 3) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
} else {
min_epoch = map_epoch;
}
}
void encode_payload(uint64_t features) override {
- ::encode(pgid.pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(pulls, payload, features);
- ::encode(cost, payload);
- ::encode(pgid.shard, payload);
- ::encode(from, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid.pgid, payload);
+ encode(map_epoch, payload);
+ encode(pulls, payload, features);
+ encode(cost, payload);
+ encode(pgid.shard, payload);
+ encode(from, payload);
+ encode(min_epoch, payload);
}
const char *get_type_name() const override { return "MOSDPGPull"; }
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid.pgid, p);
- ::decode(map_epoch, p);
- ::decode(pushes, p);
- ::decode(cost, p);
- ::decode(pgid.shard, p);
- ::decode(from, p);
+ decode(pgid.pgid, p);
+ decode(map_epoch, p);
+ decode(pushes, p);
+ decode(cost, p);
+ decode(pgid.shard, p);
+ decode(from, p);
if (header.version >= 3) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
} else {
min_epoch = map_epoch;
}
}
void encode_payload(uint64_t features) override {
- ::encode(pgid.pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(pushes, payload, features);
- ::encode(cost, payload);
- ::encode(pgid.shard, payload);
- ::encode(from, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid.pgid, payload);
+ encode(map_epoch, payload);
+ encode(pushes, payload, features);
+ encode(cost, payload);
+ encode(pgid.shard, payload);
+ encode(from, payload);
+ encode(min_epoch, payload);
}
const char *get_type_name() const override { return "MOSDPGPush"; }
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid.pgid, p);
- ::decode(map_epoch, p);
- ::decode(replies, p);
- ::decode(cost, p);
- ::decode(pgid.shard, p);
- ::decode(from, p);
+ decode(pgid.pgid, p);
+ decode(map_epoch, p);
+ decode(replies, p);
+ decode(cost, p);
+ decode(pgid.shard, p);
+ decode(from, p);
if (header.version >= 3) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
} else {
min_epoch = map_epoch;
}
}
void encode_payload(uint64_t features) override {
- ::encode(pgid.pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(replies, payload);
- ::encode(cost, payload);
- ::encode(pgid.shard, payload);
- ::encode(from, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid.pgid, payload);
+ encode(map_epoch, payload);
+ encode(replies, payload);
+ encode(cost, payload);
+ encode(pgid.shard, payload);
+ encode(from, payload);
+ encode(min_epoch, payload);
}
void print(ostream& out) const override {
}
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(pg_list, payload, features);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(pg_list, payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(pg_list, p);
+ decode(epoch, p);
+ decode(pg_list, p);
}
};
}
void encode_payload(uint64_t features) {
- ::encode(from, payload);
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(min_epoch, payload);
- ::encode(cost, payload);
- ::encode(objects, payload);
+ using ceph::encode;
+ encode(from, payload);
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(min_epoch, payload);
+ encode(cost, payload);
+ encode(objects, payload);
}
void decode_payload() {
bufferlist::iterator p = payload.begin();
- ::decode(from, p);
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(min_epoch, p);
- ::decode(cost, p);
- ::decode(objects, p);
+ decode(from, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(min_epoch, p);
+ decode(cost, p);
+ decode(objects, p);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid.pgid, p);
- ::decode(map_epoch, p);
- ::decode(min_epoch, p);
- ::decode(objects, p);
- ::decode(pgid.shard, p);
- ::decode(from, p);
+ decode(pgid.pgid, p);
+ decode(map_epoch, p);
+ decode(min_epoch, p);
+ decode(objects, p);
+ decode(pgid.shard, p);
+ decode(from, p);
}
void encode_payload(uint64_t features) override {
- ::encode(pgid.pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(min_epoch, payload);
- ::encode(objects, payload);
- ::encode(pgid.shard, payload);
- ::encode(from, payload);
+ using ceph::encode;
+ encode(pgid.pgid, payload);
+ encode(map_epoch, payload);
+ encode(min_epoch, payload);
+ encode(objects, payload);
+ encode(pgid.shard, payload);
+ encode(from, payload);
}
void print(ostream& out) const override {
const char *get_type_name() const override { return "PGrm"; }
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(pg_list, payload);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(pg_list, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(pg_list, p);
+ decode(epoch, p);
+ decode(pg_list, p);
}
void print(ostream& out) const override {
out << "osd pg remove(" << "epoch " << epoch << "; ";
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(op, p);
- ::decode(map_epoch, p);
- ::decode(query_epoch, p);
- ::decode(pgid.pgid, p);
- ::decode(begin, p);
- ::decode(end, p);
+ decode(op, p);
+ decode(map_epoch, p);
+ decode(query_epoch, p);
+ decode(pgid.pgid, p);
+ decode(begin, p);
+ decode(end, p);
// handle hobject_t format upgrade
if (!begin.is_max() && begin.pool == -1)
if (!end.is_max() && end.pool == -1)
end.pool = pgid.pool();
- ::decode(from, p);
- ::decode(pgid.shard, p);
+ decode(from, p);
+ decode(pgid.shard, p);
}
void encode_payload(uint64_t features) override {
- ::encode(op, payload);
- ::encode(map_epoch, payload);
- ::encode(query_epoch, payload);
- ::encode(pgid.pgid, payload);
- ::encode(begin, payload);
- ::encode(end, payload);
- ::encode(from, payload);
- ::encode(pgid.shard, payload);
+ using ceph::encode;
+ encode(op, payload);
+ encode(map_epoch, payload);
+ encode(query_epoch, payload);
+ encode(pgid.pgid, payload);
+ encode(begin, payload);
+ encode(end, payload);
+ encode(from, payload);
+ encode(pgid.shard, payload);
}
MOSDPGScan()
public:
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(map_epoch, payload);
- ::encode(pg_temp, payload);
- ::encode(forced, payload);
+ encode(map_epoch, payload);
+ encode(pg_temp, payload);
+ encode(forced, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(map_epoch, p);
- ::decode(pg_temp, p);
+ decode(map_epoch, p);
+ decode(pg_temp, p);
if (header.version >= 2) {
- ::decode(forced, p);
+ decode(forced, p);
}
}
}
void encode_payload(uint64_t features) override {
- ::encode(epoch, payload);
- ::encode(pgid.pgid, payload);
- ::encode(trim_to, payload);
- ::encode(pgid.shard, payload);
+ using ceph::encode;
+ encode(epoch, payload);
+ encode(pgid.pgid, payload);
+ encode(trim_to, payload);
+ encode(pgid.shard, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(epoch, p);
- ::decode(pgid.pgid, p);
- ::decode(trim_to, p);
- ::decode(pgid.shard, p);
+ decode(epoch, p);
+ decode(pgid.pgid, p);
+ decode(trim_to, p);
+ decode(pgid.shard, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(map_epoch, payload);
- ::encode(pgid, payload);
- ::encode(from, payload);
- ::encode(rep_tid, payload);
- ::encode(entries, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(map_epoch, payload);
+ encode(pgid, payload);
+ encode(from, payload);
+ encode(rep_tid, payload);
+ encode(entries, payload);
+ encode(min_epoch, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(map_epoch, p);
- ::decode(pgid, p);
- ::decode(from, p);
- ::decode(rep_tid, p);
- ::decode(entries, p);
+ decode(map_epoch, p);
+ decode(pgid, p);
+ decode(from, p);
+ decode(rep_tid, p);
+ decode(entries, p);
if (header.version >= 2) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
} else {
min_epoch = map_epoch;
}
}
void encode_payload(uint64_t features) override {
- ::encode(map_epoch, payload);
- ::encode(pgid, payload);
- ::encode(from, payload);
- ::encode(rep_tid, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(map_epoch, payload);
+ encode(pgid, payload);
+ encode(from, payload);
+ encode(rep_tid, payload);
+ encode(min_epoch, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(map_epoch, p);
- ::decode(pgid, p);
- ::decode(from, p);
- ::decode(rep_tid, p);
+ decode(map_epoch, p);
+ decode(pgid, p);
+ decode(from, p);
+ decode(rep_tid, p);
if (header.version >= 2) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
} else {
min_epoch = map_epoch;
}
public:
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(map_epoch, p);
- ::decode(op, p);
- ::decode(stamp, p);
+ decode(fsid, p);
+ decode(map_epoch, p);
+ decode(op, p);
+ decode(stamp, p);
int payload_mid_length = p.get_off();
uint32_t size;
- ::decode(size, p);
+ decode(size, p);
p.advance(size);
min_message_size = size + payload_mid_length;
}
void encode_payload(uint64_t features) override {
- ::encode(fsid, payload);
- ::encode(map_epoch, payload);
- ::encode(op, payload);
- ::encode(stamp, payload);
+ using ceph::encode;
+ encode(fsid, payload);
+ encode(map_epoch, payload);
+ encode(op, payload);
+ encode(stamp, payload);
size_t s = 0;
if (min_message_size > payload.length()) {
s = min_message_size - payload.length();
}
- ::encode((uint32_t)s, payload);
+ encode((uint32_t)s, payload);
if (s) {
// this should be big enough for normal min_message padding sizes. since
// we are targetting jumbo ethernet frames around 9000 bytes, 16k should
void decode_payload() override {
p = payload.begin();
// splitted to partial and final
- ::decode(map_epoch, p);
+ decode(map_epoch, p);
if (header.version >= 2) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
decode_trace(p);
} else {
min_epoch = map_epoch;
}
- ::decode(reqid, p);
- ::decode(pgid, p);
+ decode(reqid, p);
+ decode(pgid, p);
}
void finish_decode() {
if (!final_decode_needed)
return; // Message is already final decoded
- ::decode(poid, p);
+ decode(poid, p);
- ::decode(acks_wanted, p);
- ::decode(version, p);
- ::decode(logbl, p);
- ::decode(pg_stats, p);
- ::decode(pg_trim_to, p);
+ decode(acks_wanted, p);
+ decode(version, p);
+ decode(logbl, p);
+ decode(pg_stats, p);
+ decode(pg_trim_to, p);
- ::decode(new_temp_oid, p);
- ::decode(discard_temp_oid, p);
+ decode(new_temp_oid, p);
+ decode(discard_temp_oid, p);
- ::decode(from, p);
- ::decode(updated_hit_set_history, p);
- ::decode(pg_roll_forward_to, p);
+ decode(from, p);
+ decode(updated_hit_set_history, p);
+ decode(pg_roll_forward_to, p);
final_decode_needed = false;
}
void encode_payload(uint64_t features) override {
- ::encode(map_epoch, payload);
+ using ceph::encode;
+ encode(map_epoch, payload);
if (HAVE_FEATURE(features, SERVER_LUMINOUS)) {
header.version = HEAD_VERSION;
- ::encode(min_epoch, payload);
+ encode(min_epoch, payload);
encode_trace(payload, features);
} else {
header.version = 1;
}
- ::encode(reqid, payload);
- ::encode(pgid, payload);
- ::encode(poid, payload);
-
- ::encode(acks_wanted, payload);
- ::encode(version, payload);
- ::encode(logbl, payload);
- ::encode(pg_stats, payload);
- ::encode(pg_trim_to, payload);
- ::encode(new_temp_oid, payload);
- ::encode(discard_temp_oid, payload);
- ::encode(from, payload);
- ::encode(updated_hit_set_history, payload);
- ::encode(pg_roll_forward_to, payload);
+ encode(reqid, payload);
+ encode(pgid, payload);
+ encode(poid, payload);
+
+ encode(acks_wanted, payload);
+ encode(version, payload);
+ encode(logbl, payload);
+ encode(pg_stats, payload);
+ encode(pg_trim_to, payload);
+ encode(new_temp_oid, payload);
+ encode(discard_temp_oid, payload);
+ encode(from, payload);
+ encode(updated_hit_set_history, payload);
+ encode(pg_roll_forward_to, payload);
}
MOSDRepOp()
void decode_payload() override {
p = payload.begin();
- ::decode(map_epoch, p);
+ decode(map_epoch, p);
if (header.version >= 2) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
decode_trace(p);
} else {
min_epoch = map_epoch;
}
- ::decode(reqid, p);
- ::decode(pgid, p);
+ decode(reqid, p);
+ decode(pgid, p);
}
void finish_decode() {
if (!final_decode_needed)
return; // Message is already final decoded
- ::decode(ack_type, p);
- ::decode(result, p);
- ::decode(last_complete_ondisk, p);
+ decode(ack_type, p);
+ decode(result, p);
+ decode(last_complete_ondisk, p);
- ::decode(from, p);
+ decode(from, p);
final_decode_needed = false;
}
void encode_payload(uint64_t features) override {
- ::encode(map_epoch, payload);
+ using ceph::encode;
+ encode(map_epoch, payload);
if (HAVE_FEATURE(features, SERVER_LUMINOUS)) {
header.version = HEAD_VERSION;
- ::encode(min_epoch, payload);
+ encode(min_epoch, payload);
encode_trace(payload, features);
} else {
header.version = 1;
}
- ::encode(reqid, payload);
- ::encode(pgid, payload);
- ::encode(ack_type, payload);
- ::encode(result, payload);
- ::encode(last_complete_ondisk, payload);
- ::encode(from, payload);
+ encode(reqid, payload);
+ encode(pgid, payload);
+ encode(ack_type, payload);
+ encode(result, payload);
+ encode(last_complete_ondisk, payload);
+ encode(from, payload);
}
spg_t get_pg() { return pgid; }
}
void encode_payload(uint64_t features) override {
- ::encode(pgid.pgid, payload);
- ::encode(scrub_from, payload);
- ::encode(scrub_to, payload);
- ::encode(map_epoch, payload);
- ::encode(chunky, payload);
- ::encode(start, payload);
- ::encode(end, payload);
- ::encode(deep, payload);
- ::encode(pgid.shard, payload);
- ::encode(seed, payload);
- ::encode(min_epoch, payload);
+ using ceph::encode;
+ encode(pgid.pgid, payload);
+ encode(scrub_from, payload);
+ encode(scrub_to, payload);
+ encode(map_epoch, payload);
+ encode(chunky, payload);
+ encode(start, payload);
+ encode(end, payload);
+ encode(deep, payload);
+ encode(pgid.shard, payload);
+ encode(seed, payload);
+ encode(min_epoch, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid.pgid, p);
- ::decode(scrub_from, p);
- ::decode(scrub_to, p);
- ::decode(map_epoch, p);
- ::decode(chunky, p);
- ::decode(start, p);
- ::decode(end, p);
- ::decode(deep, p);
- ::decode(pgid.shard, p);
- ::decode(seed, p);
+ decode(pgid.pgid, p);
+ decode(scrub_from, p);
+ decode(scrub_to, p);
+ decode(map_epoch, p);
+ decode(chunky, p);
+ decode(start, p);
+ decode(end, p);
+ decode(deep, p);
+ decode(pgid.shard, p);
+ decode(seed, p);
if (header.version >= 7) {
- ::decode(min_epoch, p);
+ decode(min_epoch, p);
} else {
min_epoch = map_epoch;
}
~MOSDRepScrubMap() {}
public:
- const char *get_type_name() const { return "rep_scrubmap"; }
- void print(ostream& out) const {
+ const char *get_type_name() const override { return "rep_scrubmap"; }
+ void print(ostream& out) const override {
out << "rep_scrubmap(" << pgid << " e" << map_epoch
<< " from shard " << from << ")";
}
- void encode_payload(uint64_t features) {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(from, payload);
+ void encode_payload(uint64_t features) override {
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(from, payload);
}
- void decode_payload() {
+ void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(from, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(from, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(fsid, payload);
- ::encode(scrub_pgs, payload);
- ::encode(repair, payload);
- ::encode(deep, payload);
+ using ceph::encode;
+ encode(fsid, payload);
+ encode(scrub_pgs, payload);
+ encode(repair, payload);
+ encode(deep, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(fsid, p);
- ::decode(scrub_pgs, p);
- ::decode(repair, p);
- ::decode(deep, p);
+ decode(fsid, p);
+ decode(scrub_pgs, p);
+ decode(repair, p);
+ decode(deep, p);
}
};
void decode_payload() {
bufferlist::iterator p = payload.begin();
- ::decode(pgid, p);
- ::decode(map_epoch, p);
- ::decode(type, p);
- ::decode(from, p);
+ decode(pgid, p);
+ decode(map_epoch, p);
+ decode(type, p);
+ decode(from, p);
}
void encode_payload(uint64_t features) {
- ::encode(pgid, payload);
- ::encode(map_epoch, payload);
- ::encode(type, payload);
- ::encode(from, payload);
+ using ceph::encode;
+ encode(pgid, payload);
+ encode(map_epoch, payload);
+ encode(type, payload);
+ encode(from, payload);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(osd_stat, payload);
- ::encode(pg_stat, payload);
- ::encode(epoch, payload);
- ::encode(had_map_for, payload);
+ encode(fsid, payload);
+ encode(osd_stat, payload);
+ encode(pg_stat, payload);
+ encode(epoch, payload);
+ encode(had_map_for, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(osd_stat, p);
- ::decode(pg_stat, p);
- ::decode(epoch, p);
- ::decode(had_map_for, p);
+ decode(fsid, p);
+ decode(osd_stat, p);
+ decode(pg_stat, p);
+ decode(epoch, p);
+ decode(had_map_for, p);
}
};
}
void encode_payload(uint64_t features) override {
- ::encode(pg_stat, payload);
+ using ceph::encode;
+ encode(pg_stat, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pg_stat, p);
+ decode(pg_stat, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(pool, payload);
- ::encode(op, payload);
- ::encode(auid, payload);
- ::encode(snapid, payload);
- ::encode(name, payload);
+ encode(fsid, payload);
+ encode(pool, payload);
+ encode(op, payload);
+ encode(auid, payload);
+ encode(snapid, payload);
+ encode(name, payload);
__u8 pad = 0;
- ::encode(pad, payload); /* for v3->v4 encoding change */
- ::encode(crush_rule, payload);
+ encode(pad, payload); /* for v3->v4 encoding change */
+ encode(crush_rule, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(pool, p);
+ decode(fsid, p);
+ decode(pool, p);
if (header.version < 2)
- ::decode(name, p);
- ::decode(op, p);
- ::decode(auid, p);
- ::decode(snapid, p);
+ decode(name, p);
+ decode(op, p);
+ decode(auid, p);
+ decode(snapid, p);
if (header.version >= 2)
- ::decode(name, p);
+ decode(name, p);
if (header.version >= 3) {
__u8 pad;
- ::decode(pad, p);
+ decode(pad, p);
if (header.version >= 4)
- ::decode(crush_rule, p);
+ decode(crush_rule, p);
else
crush_rule = pad;
} else
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(replyCode, payload);
- ::encode(epoch, payload);
+ encode(fsid, payload);
+ encode(replyCode, payload);
+ encode(epoch, payload);
if (response_data.length()) {
- ::encode(true, payload);
- ::encode(response_data, payload);
+ encode(true, payload);
+ encode(response_data, payload);
} else
- ::encode(false, payload);
+ encode(false, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
- ::decode(replyCode, p);
- ::decode(epoch, p);
+ decode(fsid, p);
+ decode(replyCode, p);
+ decode(epoch, p);
bool has_response_data;
- ::decode(has_response_data, p);
+ decode(has_response_data, p);
if (has_response_data) {
- ::decode(response_data, p);
+ decode(response_data, p);
}
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(pgid.pgid, p);
- ::decode(query_epoch, p);
- ::decode(type, p);
- ::decode(pgid.shard, p);
+ decode(pgid.pgid, p);
+ decode(query_epoch, p);
+ decode(type, p);
+ decode(pgid.shard, p);
if (header.version >= 3) {
- ::decode(priority, p);
+ decode(priority, p);
}
}
void encode_payload(uint64_t features) override {
- ::encode(pgid.pgid, payload);
- ::encode(query_epoch, payload);
- ::encode(type, payload);
- ::encode(pgid.shard, payload);
- ::encode(priority, payload);
+ using ceph::encode;
+ encode(pgid.pgid, payload);
+ encode(query_epoch, payload);
+ encode(type, payload);
+ encode(pgid.shard, payload);
+ encode(priority, payload);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(snaps, payload);
+ encode(snaps, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(snaps, p);
+ decode(snaps, p);
assert(p.end());
}
public:
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(session_mon_tid, p);
- ::decode(dest, p);
+ decode(session_mon_tid, p);
+ decode(dest, p);
bool m;
- ::decode(m, p);
+ decode(m, p);
if (m)
msg = decode_message(NULL, 0, p);
- ::decode(send_osdmap_first, p);
+ decode(send_osdmap_first, p);
}
void encode_payload(uint64_t features) override {
- ::encode(session_mon_tid, payload);
- ::encode(dest, payload, features);
+ using ceph::encode;
+ encode(session_mon_tid, payload);
+ encode(dest, payload, features);
bool m = msg ? true : false;
- ::encode(m, payload);
+ encode(m, payload);
if (msg)
encode_message(msg, features, payload);
- ::encode(send_osdmap_first, payload);
+ encode(send_osdmap_first, payload);
}
const char *get_type_name() const override { return "route"; }
<< service_map.services.size() << " svc)";
}
void encode_payload(uint64_t features) override {
- ::encode(service_map, payload, features);
+ using ceph::encode;
+ encode(service_map, payload, features);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(service_map, p);
+ decode(service_map, p);
}
};
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
paxos_encode();
- ::encode(fsid, payload);
- ::encode(data_pool, payload);
+ encode(fsid, payload);
+ encode(data_pool, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
paxos_decode(p);
- ::decode(fsid, p);
+ decode(fsid, p);
if (header.version >= 2) {
- ::decode(data_pool, p);
+ decode(data_pool, p);
} else {
data_pool = boost::optional<int64_t> ();
}
}
void encode_payload(uint64_t features) override {
- ::encode(h, payload);
+ using ceph::encode;
+ encode(h, payload);
}
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(h, p);
+ decode(h, p);
}
};
void decode_payload() override {
bufferlist::iterator p = payload.begin();
- ::decode(op, p);
- ::decode(epoch, p);
- ::decode(round, p);
- ::decode(timestamp, p);
- ::decode(skews, p);
- ::decode(latencies, p);
+ decode(op, p);
+ decode(epoch, p);
+ decode(round, p);
+ decode(timestamp, p);
+ decode(skews, p);
+ decode(latencies, p);
}
void encode_payload(uint64_t features) override {
- ::encode(op, payload);
- ::encode(epoch, payload);
- ::encode(round, payload);
- ::encode(timestamp, payload);
- ::encode(skews, payload, features);
- ::encode(latencies, payload, features);
+ using ceph::encode;
+ encode(op, payload);
+ encode(epoch, payload);
+ encode(round, payload);
+ encode(timestamp, payload);
+ encode(skews, payload, features);
+ encode(latencies, payload, features);
}
};
void decode_payload() override {
uint8_t msg_ver;
bufferlist::iterator p = payload.begin();
- ::decode(msg_ver, p);
- ::decode(opcode, p);
- ::decode(cookie, p);
- ::decode(ver, p);
- ::decode(notify_id, p);
+ decode(msg_ver, p);
+ decode(opcode, p);
+ decode(cookie, p);
+ decode(ver, p);
+ decode(notify_id, p);
if (msg_ver >= 1)
- ::decode(bl, p);
+ decode(bl, p);
if (header.version >= 2)
- ::decode(return_code, p);
+ decode(return_code, p);
else
return_code = 0;
if (header.version >= 3)
- ::decode(notifier_gid, p);
+ decode(notifier_gid, p);
else
notifier_gid = 0;
}
void encode_payload(uint64_t features) override {
+ using ceph::encode;
uint8_t msg_ver = 1;
- ::encode(msg_ver, payload);
- ::encode(opcode, payload);
- ::encode(cookie, payload);
- ::encode(ver, payload);
- ::encode(notify_id, payload);
- ::encode(bl, payload);
- ::encode(return_code, payload);
- ::encode(notifier_gid, payload);
+ encode(msg_ver, payload);
+ encode(opcode, payload);
+ encode(cookie, payload);
+ encode(ver, payload);
+ encode(notify_id, payload);
+ encode(bl, payload);
+ encode(return_code, payload);
+ encode(notifier_gid, payload);
}
const char *get_type_name() const override { return "watch-notify"; }
public:
void paxos_encode() {
- ::encode(version, payload);
- ::encode(deprecated_session_mon, payload);
- ::encode(deprecated_session_mon_tid, payload);
+ using ceph::encode;
+ encode(version, payload);
+ encode(deprecated_session_mon, payload);
+ encode(deprecated_session_mon_tid, payload);
}
void paxos_decode( bufferlist::iterator& p ) {
- ::decode(version, p);
- ::decode(deprecated_session_mon, p);
- ::decode(deprecated_session_mon_tid, p);
+ decode(version, p);
+ decode(deprecated_session_mon, p);
+ decode(deprecated_session_mon_tid, p);
}
void encode_payload(uint64_t features) override {
projects / ceph.git / commitdiff