using util::create_rados_callback;
using librbd::watcher::util::HandlePayloadVisitor;
+using ceph::encode;
+using ceph::decode;
+
static const double RETRY_DELAY_SECONDS = 1.0;
template <typename I>
const std::string &oid) {
// supports legacy (empty buffer) clients
bufferlist bl;
- ::encode(NotifyMessage(HeaderUpdatePayload()), bl);
+ encode(NotifyMessage(HeaderUpdatePayload()), bl);
io_ctx.notify2(oid, bl, watcher::Notifier::NOTIFY_TIMEOUT, nullptr);
}
assert(m_image_ctx.owner_lock.is_locked());
bufferlist bl;
- ::encode(NotifyMessage(payload), bl);
+ encode(NotifyMessage(payload), bl);
NotifyLockOwner *notify_lock_owner = NotifyLockOwner::create(
m_image_ctx, this->m_notifier, std::move(bl), on_finish);
r = m_image_ctx.get_exclusive_lock_policy()->lock_requested(
payload.force);
}
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
return true;
}
m_image_ctx.operations->execute_flatten(*prog_ctx, ctx);
}
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
m_image_ctx.operations->execute_resize(payload.size, payload.allow_shrink, *prog_ctx, ctx, 0);
}
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
0, false);
return false;
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
new C_ResponseMessage(ack_ctx));
return false;
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
new C_ResponseMessage(ack_ctx));
return false;
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
new C_ResponseMessage(ack_ctx));
return false;
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
new C_ResponseMessage(ack_ctx));
return false;
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
m_image_ctx.operations->execute_rebuild_object_map(*prog_ctx, ctx);
}
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
new C_ResponseMessage(ack_ctx));
return false;
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
payload.features, payload.enabled, new C_ResponseMessage(ack_ctx), 0);
return false;
} else if (r < 0) {
- ::encode(ResponseMessage(r), ack_ctx->out);
+ encode(ResponseMessage(r), ack_ctx->out);
}
}
return true;
if (m_image_ctx.exclusive_lock != nullptr) {
int r;
if (m_image_ctx.exclusive_lock->accept_requests(&r) || r < 0) {
- ::encode(ResponseMessage(-EOPNOTSUPP), ack_ctx->out);
+ encode(ResponseMessage(-EOPNOTSUPP), ack_ctx->out);
}
}
return true;
} else {
try {
bufferlist::iterator iter = bl.begin();
- ::decode(notify_message, iter);
+ decode(notify_message, iter);
} catch (const buffer::error &err) {
lderr(m_image_ctx.cct) << this << " error decoding image notification: "
<< err.what() << dendl;
void ImageWatcher<I>::send_notify(const Payload &payload, Context *ctx) {
bufferlist bl;
- ::encode(NotifyMessage(payload), bl);
+ encode(NotifyMessage(payload), bl);
Watcher::send_notify(bl, nullptr, ctx);
}
CephContext *cct = notify_ack->cct;
ldout(cct, 10) << this << " C_ResponseMessage: r=" << r << dendl;
- ::encode(ResponseMessage(r), notify_ack->out);
+ encode(ResponseMessage(r), notify_ack->out);
notify_ack->complete(0);
}
librbd::journal::ClientData client_data;
bufferlist::iterator bl_it = client->data.begin();
try {
- ::decode(client_data, bl_it);
+ decode(client_data, bl_it);
} catch (const buffer::error &err) {
lderr(cct) << this << " OpenJournalerRequest::" << __func__ << ": "
<< "failed to decode client data" << dendl;
tag_data.predecessor = predecessor;
bufferlist tag_bl;
- ::encode(tag_data, tag_bl);
+ encode(tag_data, tag_bl);
C_SaferCond allocate_tag_ctx;
journaler->allocate_tag(tag_class, tag_bl, new_tag, &allocate_tag_ctx);
journal::ClientData client_data(client_meta);
bufferlist client_data_bl;
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
C_SaferCond update_client_ctx;
journaler.update_client(client_data_bl, &update_client_ctx);
tag_data.predecessor = predecessor;
bufferlist tag_bl;
- ::encode(tag_data, tag_bl);
+ encode(tag_data, tag_bl);
C_DecodeTag *decode_tag_ctx = new C_DecodeTag(cct, &m_lock, &m_tag_tid,
&m_tag_data, on_finish);
ceph_clock_now());
bufferlists.emplace_back();
- ::encode(event_entry, bufferlists.back());
+ encode(event_entry, bufferlists.back());
event_offset += event_length;
bytes_remaining -= event_length;
bool flush_entry, int filter_ret_val) {
bufferlist bl;
event_entry.timestamp = ceph_clock_now();
- ::encode(event_entry, bl);
+ encode(event_entry, bl);
return append_io_events(event_entry.get_event_type(), {bl}, requests, offset,
length, flush_entry, filter_ret_val);
}
bufferlist bl;
event_entry.timestamp = ceph_clock_now();
- ::encode(event_entry, bl);
+ encode(event_entry, bl);
Future future;
{
ceph_clock_now());
bufferlist bl;
- ::encode(event_entry, bl);
+ encode(event_entry, bl);
Future op_start_future;
Future op_finish_future;
librbd::journal::ClientData client_data;
bufferlist::iterator bl_it = client.data.begin();
try {
- ::decode(client_data, bl_it);
+ decode(client_data, bl_it);
} catch (const buffer::error &err) {
lderr(cct) << this << " " << __func__ << ": "
<< "failed to decode client data: " << err << dendl;
ldout(cct, 20) << dendl;
bufferlist bl;
- ::encode(NotifyMessage{ModeUpdatedPayload{mirror_mode}}, bl);
+ encode(NotifyMessage{ModeUpdatedPayload{mirror_mode}}, bl);
librados::AioCompletion *comp = create_rados_callback(on_finish);
int r = io_ctx.aio_notify(RBD_MIRRORING, comp, bl, NOTIFY_TIMEOUT_MS,
ldout(cct, 20) << dendl;
bufferlist bl;
- ::encode(NotifyMessage{ImageUpdatedPayload{
+ encode(NotifyMessage{ImageUpdatedPayload{
mirror_image_state, image_id, global_image_id}}, bl);
librados::AioCompletion *comp = create_rados_callback(on_finish);
NotifyMessage notify_message;
try {
bufferlist::iterator iter = bl.begin();
- ::decode(notify_message, iter);
+ decode(notify_message, iter);
} catch (const buffer::error &err) {
lderr(cct) << ": error decoding image notification: " << err.what()
<< dendl;
ldout(cct, 20) << dendl;
bufferlist bl;
- ::encode(NotifyMessage{ImageAddedPayload{image_id, trash_image_spec}}, bl);
+ encode(NotifyMessage{ImageAddedPayload{image_id, trash_image_spec}}, bl);
librados::AioCompletion *comp = create_rados_callback(on_finish);
int r = io_ctx.aio_notify(RBD_TRASH, comp, bl, NOTIFY_TIMEOUT_MS, nullptr);
ldout(cct, 20) << dendl;
bufferlist bl;
- ::encode(NotifyMessage{ImageRemovedPayload{image_id}}, bl);
+ encode(NotifyMessage{ImageRemovedPayload{image_id}}, bl);
librados::AioCompletion *comp = create_rados_callback(on_finish);
int r = io_ctx.aio_notify(RBD_TRASH, comp, bl, NOTIFY_TIMEOUT_MS, nullptr);
NotifyMessage notify_message;
try {
bufferlist::iterator iter = bl.begin();
- ::decode(notify_message, iter);
+ decode(notify_message, iter);
} catch (const buffer::error &err) {
lderr(cct) << "error decoding image notification: " << err.what()
<< dendl;
} // anonymous namespace
void AsyncRequestId::encode(bufferlist &bl) const {
- ::encode(client_id, bl);
- ::encode(request_id, bl);
+ using ceph::encode;
+ encode(client_id, bl);
+ encode(request_id, bl);
}
void AsyncRequestId::decode(bufferlist::iterator &iter) {
- ::decode(client_id, iter);
- ::decode(request_id, iter);
+ using ceph::decode;
+ decode(client_id, iter);
+ decode(request_id, iter);
}
void AsyncRequestId::dump(Formatter *f) const {
}
void AcquiredLockPayload::encode(bufferlist &bl) const {
- ::encode(client_id, bl);
+ using ceph::encode;
+ encode(client_id, bl);
}
void AcquiredLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
if (version >= 2) {
- ::decode(client_id, iter);
+ decode(client_id, iter);
}
}
}
void ReleasedLockPayload::encode(bufferlist &bl) const {
- ::encode(client_id, bl);
+ using ceph::encode;
+ encode(client_id, bl);
}
void ReleasedLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
if (version >= 2) {
- ::decode(client_id, iter);
+ decode(client_id, iter);
}
}
}
void RequestLockPayload::encode(bufferlist &bl) const {
- ::encode(client_id, bl);
- ::encode(force, bl);
+ using ceph::encode;
+ encode(client_id, bl);
+ encode(force, bl);
}
void RequestLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
if (version >= 2) {
- ::decode(client_id, iter);
+ decode(client_id, iter);
}
if (version >= 3) {
- ::decode(force, iter);
+ decode(force, iter);
}
}
}
void AsyncRequestPayloadBase::encode(bufferlist &bl) const {
- ::encode(async_request_id, bl);
+ using ceph::encode;
+ encode(async_request_id, bl);
}
void AsyncRequestPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
- ::decode(async_request_id, iter);
+ using ceph::decode;
+ decode(async_request_id, iter);
}
void AsyncRequestPayloadBase::dump(Formatter *f) const {
}
void AsyncProgressPayload::encode(bufferlist &bl) const {
+ using ceph::encode;
AsyncRequestPayloadBase::encode(bl);
- ::encode(offset, bl);
- ::encode(total, bl);
+ encode(offset, bl);
+ encode(total, bl);
}
void AsyncProgressPayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
AsyncRequestPayloadBase::decode(version, iter);
- ::decode(offset, iter);
- ::decode(total, iter);
+ decode(offset, iter);
+ decode(total, iter);
}
void AsyncProgressPayload::dump(Formatter *f) const {
}
void AsyncCompletePayload::encode(bufferlist &bl) const {
+ using ceph::encode;
AsyncRequestPayloadBase::encode(bl);
- ::encode(result, bl);
+ encode(result, bl);
}
void AsyncCompletePayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
AsyncRequestPayloadBase::decode(version, iter);
- ::decode(result, iter);
+ decode(result, iter);
}
void AsyncCompletePayload::dump(Formatter *f) const {
}
void ResizePayload::encode(bufferlist &bl) const {
- ::encode(size, bl);
+ using ceph::encode;
+ encode(size, bl);
AsyncRequestPayloadBase::encode(bl);
- ::encode(allow_shrink, bl);
+ encode(allow_shrink, bl);
}
void ResizePayload::decode(__u8 version, bufferlist::iterator &iter) {
- ::decode(size, iter);
+ using ceph::decode;
+ decode(size, iter);
AsyncRequestPayloadBase::decode(version, iter);
if (version >= 4) {
- ::decode(allow_shrink, iter);
+ decode(allow_shrink, iter);
}
}
void SnapPayloadBase::encode(bufferlist &bl) const {
using ceph::encode;
- ::encode(snap_name, bl);
+ encode(snap_name, bl);
encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl);
}
void SnapPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
using ceph::decode;
- ::decode(snap_name, iter);
+ decode(snap_name, iter);
if (version >= 6) {
cls::rbd::SnapshotNamespaceOnDisk sn;
decode(sn, iter);
}
void SnapRenamePayload::encode(bufferlist &bl) const {
- ::encode(snap_id, bl);
+ using ceph::encode;
+ encode(snap_id, bl);
SnapPayloadBase::encode(bl);
}
void SnapRenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
- ::decode(snap_id, iter);
+ using ceph::decode;
+ decode(snap_id, iter);
SnapPayloadBase::decode(version, iter);
}
}
void RenamePayload::encode(bufferlist &bl) const {
- ::encode(image_name, bl);
+ using ceph::encode;
+ encode(image_name, bl);
}
void RenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
- ::decode(image_name, iter);
+ using ceph::decode;
+ decode(image_name, iter);
}
void RenamePayload::dump(Formatter *f) const {
}
void UpdateFeaturesPayload::encode(bufferlist &bl) const {
- ::encode(features, bl);
- ::encode(enabled, bl);
+ using ceph::encode;
+ encode(features, bl);
+ encode(enabled, bl);
}
void UpdateFeaturesPayload::decode(__u8 version, bufferlist::iterator &iter) {
- ::decode(features, iter);
- ::decode(enabled, iter);
+ using ceph::decode;
+ decode(features, iter);
+ decode(enabled, iter);
}
void UpdateFeaturesPayload::dump(Formatter *f) const {
DECODE_START(1, iter);
uint32_t notify_op;
- ::decode(notify_op, iter);
+ decode(notify_op, iter);
// select the correct payload variant based upon the encoded op
switch (notify_op) {
void ResponseMessage::encode(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(result, bl);
+ encode(result, bl);
ENCODE_FINISH(bl);
}
void ResponseMessage::decode(bufferlist::iterator& iter) {
DECODE_START(1, iter);
- ::decode(result, iter);
+ decode(result, iter);
DECODE_FINISH(iter);
}
o.push_back(new ResponseMessage(1));
}
-} // namespace watch_notify
-} // namespace librbd
-
std::ostream &operator<<(std::ostream &out,
const librbd::watch_notify::NotifyOp &op) {
using namespace librbd::watch_notify;
<< request.request_id << "]";
return out;
}
+} // namespace watch_notify
+} // namespace librbd
static void generate_test_instances(std::list<ResponseMessage *> &o);
};
-} // namespace watch_notify
-} // namespace librbd
-
std::ostream &operator<<(std::ostream &out,
- const librbd::watch_notify::NotifyOp &op);
+ const NotifyOp &op);
std::ostream &operator<<(std::ostream &out,
- const librbd::watch_notify::AsyncRequestId &request);
+ const AsyncRequestId &request);
+
+WRITE_CLASS_ENCODER(AsyncRequestId);
+WRITE_CLASS_ENCODER(NotifyMessage);
+WRITE_CLASS_ENCODER(ResponseMessage);
+
+} // namespace watch_notify
+} // namespace librbd
-WRITE_CLASS_ENCODER(librbd::watch_notify::AsyncRequestId);
-WRITE_CLASS_ENCODER(librbd::watch_notify::NotifyMessage);
-WRITE_CLASS_ENCODER(librbd::watch_notify::ResponseMessage);
#endif // LIBRBD_WATCH_NOTIFY_TYPES_H
bufferlist::iterator iter = response.begin();
ResponseMessage response_message;
- ::decode(response_message, iter);
+ using ceph::decode;
+ decode(response_message, iter);
r = response_message.result;
} catch (const buffer::error &err) {
{
bufferlist cmdbl, emptybl;
__u8 c = CEPH_OSD_TMAP_SET;
- ::encode(c, cmdbl);
- ::encode(imgname, cmdbl);
- ::encode(emptybl, cmdbl);
+ encode(c, cmdbl);
+ encode(imgname, cmdbl);
+ encode(emptybl, cmdbl);
return io_ctx.tmap_update(RBD_DIRECTORY, cmdbl);
}
{
bufferlist cmdbl;
__u8 c = CEPH_OSD_TMAP_RM;
- ::encode(c, cmdbl);
- ::encode(imgname, cmdbl);
+ encode(c, cmdbl);
+ encode(imgname, cmdbl);
return io_ctx.tmap_update(RBD_DIRECTORY, cmdbl);
}
bufferlist::iterator p = bl.begin();
bufferlist header;
map<string,bufferlist> m;
- ::decode(header, p);
- ::decode(m, p);
+ decode(header, p);
+ decode(m, p);
for (map<string,bufferlist>::iterator q = m.begin(); q != m.end(); ++q) {
names.push_back(q->first);
}
using klass = CreateRequest<I>;
Context *ctx = create_context_callback<klass, &klass::handle_journal_tag>(this);
- ::encode(m_tag_data, m_bl);
+ encode(m_tag_data, m_bl);
m_journaler->allocate_tag(m_tag_class, m_bl, &m_tag, ctx);
}
ldout(m_cct, 20) << this << " " << __func__ << dendl;
m_bl.clear();
- ::encode(ClientData{ImageClientMeta{m_tag.tag_class}}, m_bl);
+ encode(ClientData{ImageClientMeta{m_tag.tag_class}}, m_bl);
using klass = CreateRequest<I>;
Context *ctx = create_context_callback<klass, &klass::handle_register_client>(this);
tag_data.predecessor = std::move(predecessor);
bufferlist tag_bl;
- ::encode(tag_data, tag_bl);
+ encode(tag_data, tag_bl);
auto ctx = create_context_callback<
DemoteRequest<I>, &DemoteRequest<I>::handle_allocate_tag>(this);
EventEntry event_entry{DemotePromoteEvent{}, {}};
bufferlist event_entry_bl;
- ::encode(event_entry, event_entry_bl);
+ encode(event_entry, event_entry_bl);
m_journaler->start_append(0, 0, 0);
m_future = m_journaler->append(m_tag_tid, event_entry_bl);
librbd::journal::ClientData client_data;
bufferlist::iterator bl = client.data.begin();
try {
- ::decode(client_data, bl);
+ decode(client_data, bl);
} catch (const buffer::error &err) {
lderr(cct) << "failed to decode client meta data: " << err.what()
<< dendl;
tag_data.predecessor = predecessor;
bufferlist tag_bl;
- ::encode(tag_data, tag_bl);
+ encode(tag_data, tag_bl);
Context *ctx = create_context_callback<
PromoteRequest<I>, &PromoteRequest<I>::handle_allocate_tag>(this);
EventEntry event_entry{DemotePromoteEvent{}, {}};
bufferlist event_entry_bl;
- ::encode(event_entry, event_entry_bl);
+ encode(event_entry, event_entry_bl);
m_journaler->start_append(0, 0, 0);
m_future = m_journaler->append(m_tag_tid, event_entry_bl);
template <typename I>
int Replay<I>::decode(bufferlist::iterator *it, EventEntry *event_entry) {
try {
- ::decode(*event_entry, *it);
+ using ceph::decode;
+ decode(*event_entry, *it);
} catch (const buffer::error &err) {
return -EBADMSG;
}
namespace librbd {
namespace journal {
+using ceph::encode;
+using ceph::decode;
+
namespace {
template <typename E>
template <typename T>
inline void operator()(const T& t) const {
- ::encode(static_cast<uint32_t>(T::TYPE), m_bl);
+ encode(static_cast<uint32_t>(T::TYPE), m_bl);
t.encode(m_bl);
}
private:
} // anonymous namespace
void AioDiscardEvent::encode(bufferlist& bl) const {
- ::encode(offset, bl);
- ::encode(length, bl);
- ::encode(skip_partial_discard, bl);
+ using ceph::encode;
+ encode(offset, bl);
+ encode(length, bl);
+ encode(skip_partial_discard, bl);
}
void AioDiscardEvent::decode(__u8 version, bufferlist::iterator& it) {
- ::decode(offset, it);
- ::decode(length, it);
+ using ceph::decode;
+ decode(offset, it);
+ decode(length, it);
if (version >= 4) {
- ::decode(skip_partial_discard, it);
+ decode(skip_partial_discard, it);
}
}
}
void AioWriteEvent::encode(bufferlist& bl) const {
- ::encode(offset, bl);
- ::encode(length, bl);
- ::encode(data, bl);
+ using ceph::encode;
+ encode(offset, bl);
+ encode(length, bl);
+ encode(data, bl);
}
void AioWriteEvent::decode(__u8 version, bufferlist::iterator& it) {
- ::decode(offset, it);
- ::decode(length, it);
- ::decode(data, it);
+ using ceph::decode;
+ decode(offset, it);
+ decode(length, it);
+ decode(data, it);
}
void AioWriteEvent::dump(Formatter *f) const {
}
void AioWriteSameEvent::encode(bufferlist& bl) const {
- ::encode(offset, bl);
- ::encode(length, bl);
- ::encode(data, bl);
+ using ceph::encode;
+ encode(offset, bl);
+ encode(length, bl);
+ encode(data, bl);
}
void AioWriteSameEvent::decode(__u8 version, bufferlist::iterator& it) {
- ::decode(offset, it);
- ::decode(length, it);
- ::decode(data, it);
+ using ceph::decode;
+ decode(offset, it);
+ decode(length, it);
+ decode(data, it);
}
void AioWriteSameEvent::dump(Formatter *f) const {
}
void AioCompareAndWriteEvent::encode(bufferlist& bl) const {
- ::encode(offset, bl);
- ::encode(length, bl);
- ::encode(cmp_data, bl);
- ::encode(write_data, bl);
+ using ceph::encode;
+ encode(offset, bl);
+ encode(length, bl);
+ encode(cmp_data, bl);
+ encode(write_data, bl);
}
void AioCompareAndWriteEvent::decode(__u8 version, bufferlist::iterator& it) {
- ::decode(offset, it);
- ::decode(length, it);
- ::decode(cmp_data, it);
- ::decode(write_data, it);
+ using ceph::decode;
+ decode(offset, it);
+ decode(length, it);
+ decode(cmp_data, it);
+ decode(write_data, it);
}
void AioCompareAndWriteEvent::dump(Formatter *f) const {
}
void OpEventBase::encode(bufferlist& bl) const {
- ::encode(op_tid, bl);
+ using ceph::encode;
+ encode(op_tid, bl);
}
void OpEventBase::decode(__u8 version, bufferlist::iterator& it) {
- ::decode(op_tid, it);
+ using ceph::decode;
+ decode(op_tid, it);
}
void OpEventBase::dump(Formatter *f) const {
void OpFinishEvent::encode(bufferlist& bl) const {
OpEventBase::encode(bl);
- ::encode(op_tid, bl);
- ::encode(r, bl);
+ using ceph::encode;
+ encode(op_tid, bl);
+ encode(r, bl);
}
void OpFinishEvent::decode(__u8 version, bufferlist::iterator& it) {
OpEventBase::decode(version, it);
- ::decode(op_tid, it);
- ::decode(r, it);
+ using ceph::decode;
+ decode(op_tid, it);
+ decode(r, it);
}
void OpFinishEvent::dump(Formatter *f) const {
void SnapEventBase::encode(bufferlist& bl) const {
using ceph::encode;
OpEventBase::encode(bl);
- ::encode(snap_name, bl);
+ encode(snap_name, bl);
encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl);
}
void SnapEventBase::decode(__u8 version, bufferlist::iterator& it) {
using ceph::decode;
OpEventBase::decode(version, it);
- ::decode(snap_name, it);
+ using ceph::decode;
+ decode(snap_name, it);
if (version >= 4) {
cls::rbd::SnapshotNamespaceOnDisk sn;
decode(sn, it);
void SnapLimitEvent::encode(bufferlist &bl) const {
OpEventBase::encode(bl);
- ::encode(limit, bl);
+ using ceph::encode;
+ encode(limit, bl);
}
void SnapLimitEvent::decode(__u8 version, bufferlist::iterator& it) {
OpEventBase::decode(version, it);
- ::decode(limit, it);
+ using ceph::decode;
+ decode(limit, it);
}
void SnapLimitEvent::dump(Formatter *f) const {
void SnapRenameEvent::encode(bufferlist& bl) const {
OpEventBase::encode(bl);
- ::encode(dst_snap_name, bl);
- ::encode(snap_id, bl);
- ::encode(src_snap_name, bl);
+ using ceph::encode;
+ encode(dst_snap_name, bl);
+ encode(snap_id, bl);
+ encode(src_snap_name, bl);
}
void SnapRenameEvent::decode(__u8 version, bufferlist::iterator& it) {
+ using ceph::decode;
OpEventBase::decode(version, it);
- ::decode(dst_snap_name, it);
- ::decode(snap_id, it);
+ decode(dst_snap_name, it);
+ decode(snap_id, it);
if (version >= 2) {
- ::decode(src_snap_name, it);
+ decode(src_snap_name, it);
}
}
void RenameEvent::encode(bufferlist& bl) const {
OpEventBase::encode(bl);
- ::encode(image_name, bl);
+ using ceph::encode;
+ encode(image_name, bl);
}
void RenameEvent::decode(__u8 version, bufferlist::iterator& it) {
OpEventBase::decode(version, it);
- ::decode(image_name, it);
+ using ceph::decode;
+ decode(image_name, it);
}
void RenameEvent::dump(Formatter *f) const {
void ResizeEvent::encode(bufferlist& bl) const {
OpEventBase::encode(bl);
- ::encode(size, bl);
+ using ceph::encode;
+ encode(size, bl);
}
void ResizeEvent::decode(__u8 version, bufferlist::iterator& it) {
OpEventBase::decode(version, it);
- ::decode(size, it);
+ using ceph::decode;
+ decode(size, it);
}
void ResizeEvent::dump(Formatter *f) const {
void UpdateFeaturesEvent::encode(bufferlist& bl) const {
OpEventBase::encode(bl);
- ::encode(features, bl);
- ::encode(enabled, bl);
+ using ceph::encode;
+ encode(features, bl);
+ encode(enabled, bl);
}
void UpdateFeaturesEvent::decode(__u8 version, bufferlist::iterator& it) {
OpEventBase::decode(version, it);
- ::decode(features, it);
- ::decode(enabled, it);
+ using ceph::decode;
+ decode(features, it);
+ decode(enabled, it);
}
void UpdateFeaturesEvent::dump(Formatter *f) const {
void MetadataSetEvent::encode(bufferlist& bl) const {
OpEventBase::encode(bl);
- ::encode(key, bl);
- ::encode(value, bl);
+ using ceph::encode;
+ encode(key, bl);
+ encode(value, bl);
}
void MetadataSetEvent::decode(__u8 version, bufferlist::iterator& it) {
OpEventBase::decode(version, it);
- ::decode(key, it);
- ::decode(value, it);
+ using ceph::decode;
+ decode(key, it);
+ decode(value, it);
}
void MetadataSetEvent::dump(Formatter *f) const {
void MetadataRemoveEvent::encode(bufferlist& bl) const {
OpEventBase::encode(bl);
- ::encode(key, bl);
+ using ceph::encode;
+ encode(key, bl);
}
void MetadataRemoveEvent::decode(__u8 version, bufferlist::iterator& it) {
OpEventBase::decode(version, it);
- ::decode(key, it);
+ using ceph::decode;
+ decode(key, it);
}
void MetadataRemoveEvent::dump(Formatter *f) const {
DECODE_START(1, it);
uint32_t event_type;
- ::decode(event_type, it);
+ decode(event_type, it);
// select the correct payload variant based upon the encoded op
switch (event_type) {
void EventEntry::encode_metadata(bufferlist& bl) const {
ENCODE_START(1, 1, bl);
- ::encode(timestamp, bl);
+ encode(timestamp, bl);
ENCODE_FINISH(bl);
}
void EventEntry::decode_metadata(bufferlist::iterator& it) {
DECODE_START(1, it);
- ::decode(timestamp, it);
+ decode(timestamp, it);
DECODE_FINISH(it);
}
// Journal Client
void ImageClientMeta::encode(bufferlist& bl) const {
- ::encode(tag_class, bl);
- ::encode(resync_requested, bl);
+ using ceph::encode;
+ encode(tag_class, bl);
+ encode(resync_requested, bl);
}
void ImageClientMeta::decode(__u8 version, bufferlist::iterator& it) {
- ::decode(tag_class, it);
- ::decode(resync_requested, it);
+ using ceph::decode;
+ decode(tag_class, it);
+ decode(resync_requested, it);
}
void ImageClientMeta::dump(Formatter *f) const {
void MirrorPeerSyncPoint::encode(bufferlist& bl) const {
using ceph::encode;
- ::encode(snap_name, bl);
- ::encode(from_snap_name, bl);
- ::encode(object_number, bl);
+ encode(snap_name, bl);
+ encode(from_snap_name, bl);
+ encode(object_number, bl);
encode(cls::rbd::SnapshotNamespaceOnDisk(snap_namespace), bl);
}
void MirrorPeerSyncPoint::decode(__u8 version, bufferlist::iterator& it) {
using ceph::decode;
- ::decode(snap_name, it);
- ::decode(from_snap_name, it);
- ::decode(object_number, it);
+ decode(snap_name, it);
+ decode(from_snap_name, it);
+ decode(object_number, it);
if (version >= 2) {
cls::rbd::SnapshotNamespaceOnDisk sn;
decode(sn, it);
}
void MirrorPeerClientMeta::encode(bufferlist& bl) const {
- ::encode(image_id, bl);
- ::encode(static_cast<uint32_t>(state), bl);
- ::encode(sync_object_count, bl);
- ::encode(static_cast<uint32_t>(sync_points.size()), bl);
+ using ceph::encode;
+ encode(image_id, bl);
+ encode(static_cast<uint32_t>(state), bl);
+ encode(sync_object_count, bl);
+ encode(static_cast<uint32_t>(sync_points.size()), bl);
for (auto &sync_point : sync_points) {
sync_point.encode(bl);
}
- ::encode(snap_seqs, bl);
+ encode(snap_seqs, bl);
}
void MirrorPeerClientMeta::decode(__u8 version, bufferlist::iterator& it) {
- ::decode(image_id, it);
+ using ceph::decode;
+ decode(image_id, it);
uint32_t decode_state;
- ::decode(decode_state, it);
+ decode(decode_state, it);
state = static_cast<MirrorPeerState>(decode_state);
- ::decode(sync_object_count, it);
+ decode(sync_object_count, it);
uint32_t sync_point_count;
- ::decode(sync_point_count, it);
+ decode(sync_point_count, it);
sync_points.resize(sync_point_count);
for (auto &sync_point : sync_points) {
sync_point.decode(version, it);
}
- ::decode(snap_seqs, it);
+ decode(snap_seqs, it);
}
void MirrorPeerClientMeta::dump(Formatter *f) const {
DECODE_START(1, it);
uint32_t client_meta_type;
- ::decode(client_meta_type, it);
+ decode(client_meta_type, it);
// select the correct payload variant based upon the encoded op
switch (client_meta_type) {
// Journal Tag
void TagPredecessor::encode(bufferlist& bl) const {
- ::encode(mirror_uuid, bl);
- ::encode(commit_valid, bl);
- ::encode(tag_tid, bl);
- ::encode(entry_tid, bl);
+ using ceph::encode;
+ encode(mirror_uuid, bl);
+ encode(commit_valid, bl);
+ encode(tag_tid, bl);
+ encode(entry_tid, bl);
}
void TagPredecessor::decode(bufferlist::iterator& it) {
- ::decode(mirror_uuid, it);
- ::decode(commit_valid, it);
- ::decode(tag_tid, it);
- ::decode(entry_tid, it);
+ using ceph::decode;
+ decode(mirror_uuid, it);
+ decode(commit_valid, it);
+ decode(tag_tid, it);
+ decode(entry_tid, it);
}
void TagPredecessor::dump(Formatter *f) const {
}
void TagData::encode(bufferlist& bl) const {
- ::encode(mirror_uuid, bl);
+ using ceph::encode;
+ encode(mirror_uuid, bl);
predecessor.encode(bl);
}
void TagData::decode(bufferlist::iterator& it) {
- ::decode(mirror_uuid, it);
+ using ceph::decode;
+ decode(mirror_uuid, it);
predecessor.decode(it);
}
virtual void handle_resync() = 0;
};
+WRITE_CLASS_ENCODER(EventEntry);
+WRITE_CLASS_ENCODER(ClientData);
+WRITE_CLASS_ENCODER(TagData);
+
} // namespace journal
} // namespace librbd
-WRITE_CLASS_ENCODER(librbd::journal::EventEntry);
-WRITE_CLASS_ENCODER(librbd::journal::ClientData);
-WRITE_CLASS_ENCODER(librbd::journal::TagData);
-
#endif // CEPH_LIBRBD_JOURNAL_TYPES_H
int C_DecodeTag::decode(bufferlist::iterator *it, TagData *tag_data) {
try {
- ::decode(*tag_data, *it);
+ using ceph::decode;
+ decode(*tag_data, *it);
} catch (const buffer::error &err) {
return -EBADMSG;
}
journal::ClientData client_data;
bufferlist::iterator bl_it = client.data.begin();
try {
- ::decode(client_data, bl_it);
+ using ceph::decode;
+ decode(client_data, bl_it);
} catch (const buffer::error &err) {
lderr(cct) << "failed to decode client data" << dendl;
m_error_result = -EBADMSG;
} // anonymous namespace
void ModeUpdatedPayload::encode(bufferlist &bl) const {
- ::encode(static_cast<uint32_t>(mirror_mode), bl);
+ using ceph::encode;
+ encode(static_cast<uint32_t>(mirror_mode), bl);
}
void ModeUpdatedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
uint32_t mirror_mode_decode;
- ::decode(mirror_mode_decode, iter);
+ decode(mirror_mode_decode, iter);
mirror_mode = static_cast<cls::rbd::MirrorMode>(mirror_mode_decode);
}
}
void ImageUpdatedPayload::encode(bufferlist &bl) const {
- ::encode(static_cast<uint32_t>(mirror_image_state), bl);
- ::encode(image_id, bl);
- ::encode(global_image_id, bl);
+ using ceph::encode;
+ encode(static_cast<uint32_t>(mirror_image_state), bl);
+ encode(image_id, bl);
+ encode(global_image_id, bl);
}
void ImageUpdatedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
uint32_t mirror_image_state_decode;
- ::decode(mirror_image_state_decode, iter);
+ decode(mirror_image_state_decode, iter);
mirror_image_state = static_cast<cls::rbd::MirrorImageState>(
mirror_image_state_decode);
- ::decode(image_id, iter);
- ::decode(global_image_id, iter);
+ decode(image_id, iter);
+ decode(global_image_id, iter);
}
void ImageUpdatedPayload::dump(Formatter *f) const {
DECODE_START(1, iter);
uint32_t notify_op;
- ::decode(notify_op, iter);
+ decode(notify_op, iter);
// select the correct payload variant based upon the encoded op
switch (notify_op) {
if (image_ctx.old_format) {
bufferlist cmd_bl;
bufferlist empty_bl;
- ::encode(static_cast<__u8>(CEPH_OSD_TMAP_SET), cmd_bl);
- ::encode(m_dest_name, cmd_bl);
- ::encode(empty_bl, cmd_bl);
- ::encode(static_cast<__u8>(CEPH_OSD_TMAP_RM), cmd_bl);
- ::encode(image_ctx.name, cmd_bl);
+ encode(static_cast<__u8>(CEPH_OSD_TMAP_SET), cmd_bl);
+ encode(m_dest_name, cmd_bl);
+ encode(empty_bl, cmd_bl);
+ encode(static_cast<__u8>(CEPH_OSD_TMAP_RM), cmd_bl);
+ encode(image_ctx.name, cmd_bl);
op.tmap_update(cmd_bl);
} else {
cls_client::dir_rename_image(&op, image_ctx.name, m_dest_name,
void ImageAddedPayload::encode(bufferlist &bl) const {
using ceph::encode;
- ::encode(image_id, bl);
+ encode(image_id, bl);
encode(trash_image_spec, bl);
}
void ImageAddedPayload::decode(__u8 version, bufferlist::iterator &iter) {
using ceph::decode;
- ::decode(image_id, iter);
+ decode(image_id, iter);
decode(trash_image_spec, iter);
}
}
void ImageRemovedPayload::encode(bufferlist &bl) const {
- ::encode(image_id, bl);
+ using ceph::encode;
+ encode(image_id, bl);
}
void ImageRemovedPayload::decode(__u8 version, bufferlist::iterator &iter) {
- ::decode(image_id, iter);
+ using ceph::decode;
+ decode(image_id, iter);
}
void ImageRemovedPayload::dump(Formatter *f) const {
DECODE_START(1, iter);
uint32_t notify_op;
- ::decode(notify_op, iter);
+ decode(notify_op, iter);
// select the correct payload variant based upon the encoded op
switch (notify_op) {
if (r == 0 || r == -ETIMEDOUT) {
try {
bufferlist::iterator it = out_bl.begin();
- ::decode(*response, it);
+ decode(*response, it);
} catch (const buffer::error &err) {
r = -EBADMSG;
}
namespace watcher {
void ClientId::encode(bufferlist &bl) const {
- ::encode(gid, bl);
- ::encode(handle, bl);
+ using ceph::encode;
+ encode(gid, bl);
+ encode(handle, bl);
}
void ClientId::decode(bufferlist::iterator &iter) {
- ::decode(gid, iter);
- ::decode(handle, iter);
+ using ceph::decode;
+ decode(gid, iter);
+ decode(handle, iter);
}
void ClientId::dump(Formatter *f) const {
f->dump_unsigned("handle", handle);
}
-WRITE_CLASS_ENCODER(ClientId);
-
void NotifyResponse::encode(bufferlist& bl) const {
- ::encode(acks, bl);
- ::encode(timeouts, bl);
+ using ceph::encode;
+ encode(acks, bl);
+ encode(timeouts, bl);
}
void NotifyResponse::decode(bufferlist::iterator& iter) {
- ::decode(acks, iter);
- ::decode(timeouts, iter);
+ using ceph::decode;
+ decode(acks, iter);
+ decode(timeouts, iter);
}
-
-} // namespace watcher
-} // namespace librbd
-
std::ostream &operator<<(std::ostream &out,
- const librbd::watcher::ClientId &client_id) {
+ const ClientId &client_id) {
out << "[" << client_id.gid << "," << client_id.handle << "]";
return out;
}
+
+} // namespace watcher
+} // namespace librbd
typedef librbd::Watcher Watcher;
};
-} // namespace watcher
-} // namespace librbd
-
std::ostream &operator<<(std::ostream &out,
- const librbd::watcher::ClientId &client);
+ const ClientId &client);
-WRITE_CLASS_ENCODER(librbd::watcher::ClientId);
-WRITE_CLASS_ENCODER(librbd::watcher::NotifyResponse);
+WRITE_CLASS_ENCODER(ClientId);
+WRITE_CLASS_ENCODER(NotifyResponse);
+
+} // namespace watcher
+} // namespace librbd
#endif // CEPH_LIBRBD_WATCHER_TYPES_H
template <typename P>
inline void operator()(const P &payload) const {
- ::encode(static_cast<uint32_t>(P::NOTIFY_OP), m_bl);
+ using ceph::encode;
+ encode(static_cast<uint32_t>(P::NOTIFY_OP), m_bl);
payload.encode(m_bl);
}
using namespace librbd::cls_client;
using ::librbd::ParentInfo;
using ::librbd::ParentSpec;
+using ceph::encode;
+using ceph::decode;
static int snapshot_add(librados::IoCtx *ioctx, const std::string &oid,
uint64_t snap_id, const std::string &snap_name) {
void expect_metadata_list(librbd::MockTestImageCtx &mock_image_ctx,
const Metadata& metadata, int r) {
bufferlist out_bl;
- ::encode(metadata, out_bl);
+ encode(metadata, out_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
void expect_metadata_set(librbd::MockTestImageCtx &mock_image_ctx,
const Metadata& metadata, int r) {
bufferlist in_bl;
- ::encode(metadata, in_bl);
+ encode(metadata, in_bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
try {
bufferlist data_bl = replay_entry.get_data();
bufferlist::iterator it = data_bl.begin();
- ::decode(*event_entry, it);
+ decode(*event_entry, it);
} catch (const buffer::error &err) {
return false;
}
client_data.client_meta = image_client_meta;
cls::journal::Client client;
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
EXPECT_CALL(mock_journaler, get_cached_client("", _))
.WillOnce(DoAll(SetArgPointee<1>(client),
tag_data.mirror_uuid = "remote mirror";
bufferlist tag_data_bl;
- ::encode(tag_data, tag_data_bl);
+ encode(tag_data, tag_data_bl);
::journal::Journaler::Tags tags = {{0, 345, {}}, {1, 345, tag_data_bl}};
EXPECT_CALL(mock_journaler, get_tags(345, _, _))
tag_data.predecessor = predecessor;
bufferlist tag_data_bl;
- ::encode(tag_data, tag_data_bl);
+ using ceph::encode;
+ encode(tag_data, tag_data_bl);
EXPECT_CALL(mock_journaler, allocate_tag(456, ContentsEqual(tag_data_bl),
_, _))
EventEntry &&event_entry, Context *on_ready,
Context *on_safe) {
bufferlist bl;
- ::encode(event_entry, bl);
+ encode(event_entry, bl);
bufferlist::iterator it = bl.begin();
when_process(mock_journal_replay, &it, on_ready, on_safe);
bufferlist bl;
ENCODE_START(1, 1, bl);
- ::encode(static_cast<uint32_t>(-1), bl);
+ encode(static_cast<uint32_t>(-1), bl);
ENCODE_FINISH(bl);
bufferlist::iterator it = bl.begin();
bufferlist bl;
bl.share(arg);
bufferlist::iterator iter = bl.begin();
- ::decode(op, iter);
+ decode(op, iter);
return op.type == (exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED);
}
}
bufferlist bl;
- ::encode(reply, bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
+ encode(reply, bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
std::string str(bl.c_str(), bl.length());
expect.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(str)), Return(0)));
bufferlist bl;
bl.share(arg);
bufferlist::iterator iter = bl.begin();
- ::decode(op, iter);
+ decode(op, iter);
return op.type == (exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED);
}
const std::set<cls::journal::Client> &clients,
int r) {
bufferlist bl;
- ::encode(clients, bl);
+ using ceph::encode;
+ encode(clients, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
exec(::journal::Journaler::header_oid(mock_image_ctx.id),
const std::string &client_id,
int r) {
bufferlist bl;
- ::encode(client_id, bl);
+ using ceph::encode;
+ encode(client_id, bl);
EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
exec(::journal::Journaler::header_oid(mock_image_ctx.id),
template <typename T>
bufferlist encode(const T &t) {
+ using ceph::encode;
bufferlist bl;
- ::encode(t, bl);
+ encode(t, bl);
return bl;
}
rados::cls::lock::locker_info_t()}};
bufferlist bl;
- ::encode(reply, bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
+ encode(reply, bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
std::string str(bl.c_str(), bl.length());
expect.WillOnce(DoAll(WithArg<5>(CopyInBufferlist(str)), Return(r)));
uint8_t new_state,
const boost::optional<uint8_t>& current_state, int r) {
bufferlist bl;
- ::encode(start_object_no, bl);
- ::encode(end_object_no, bl);
- ::encode(new_state, bl);
- ::encode(current_state, bl);
+ encode(start_object_no, bl);
+ encode(end_object_no, bl);
+ encode(new_state, bl);
+ encode(current_state, bl);
std::string oid(ObjectMap<>::object_map_name(ictx->id, snap_id));
if (snap_id == CEPH_NOSNAP) {
void expect_set_protection_status(MockImageCtx &mock_image_ctx,
uint64_t snap_id, uint8_t status, int r) {
bufferlist bl;
- ::encode(snap_id, bl);
- ::encode(status, bl);
+ encode(snap_id, bl);
+ encode(status, bl);
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
exec(mock_image_ctx.header_oid, _, StrEq("rbd"),
void expect_get_children(MockImageCtx &mock_image_ctx, size_t pools, int r) {
bufferlist bl;
std::set<std::string> children;
- ::encode(children, bl);
+ encode(children, bl);
auto &expect = EXPECT_CALL(get_mock_io_ctx(mock_image_ctx.md_ctx),
exec(RBD_CHILDREN, _, StrEq("rbd"), StrEq("get_children"), _,
bufferlist payload;
bufferlist::iterator iter = bl.begin();
DECODE_START(1, iter);
- ::decode(op, iter);
+ decode(op, iter);
iter.copy_all(payload);
DECODE_FINISH(iter);
bufferlist create_response_message(int r) {
bufferlist bl;
- ::encode(ResponseMessage(r), bl);
+ encode(ResponseMessage(r), bl);
return bl;
}
int notify_async_progress(librbd::ImageCtx *ictx, const AsyncRequestId &id,
uint64_t offset, uint64_t total) {
bufferlist bl;
- ::encode(NotifyMessage(AsyncProgressPayload(id, offset, total)), bl);
+ encode(NotifyMessage(AsyncProgressPayload(id, offset, total)), bl);
return m_ioctx.notify2(ictx->header_oid, bl, 5000, NULL);
}
int notify_async_complete(librbd::ImageCtx *ictx, const AsyncRequestId &id,
int r) {
bufferlist bl;
- ::encode(NotifyMessage(AsyncCompletePayload(id, r)), bl);
+ encode(NotifyMessage(AsyncCompletePayload(id, r)), bl);
return m_ioctx.notify2(ictx->header_oid, bl, 5000, NULL);
}
ASSERT_EQ(-ENOENT, init_ctx.wait());
bufferlist client_data_bl;
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
ASSERT_EQ(0, journaler.register_client(client_data_bl));
C_SaferCond shut_down_ctx;
client_data.client_meta = client_meta;
cls::journal::Client client;
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
EXPECT_CALL(mock_journaler, get_cached_client("", _))
.WillOnce(DoAll(SetArgPointee<1>(client),
tag_data.mirror_uuid = Journal<>::LOCAL_MIRROR_UUID;
bufferlist tag_data_bl;
- ::encode(tag_data, tag_data_bl);
+ encode(tag_data, tag_data_bl);
expect_get_journaler_tags(mock_image_ctx, mock_journaler, 0,
{{0, 0, tag_data_bl}}, 0);
tag_data.mirror_uuid = Journal<>::LOCAL_MIRROR_UUID;
bufferlist tag_data_bl;
- ::encode(tag_data, tag_data_bl);
+ encode(tag_data, tag_data_bl);
expect_get_journaler_tags(mock_image_ctx, mock_journaler, 0,
{{100, 0, tag_data_bl}}, 0);
void expect_get_snapcontext(const std::string& image_id,
const ::SnapContext &snapc, int r) {
bufferlist bl;
- ::encode(snapc, bl);
+ encode(snapc, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
exec(librbd::util::header_name(image_id), _, StrEq("rbd"),
} // namespace image_deleter
} // namespace mirror
} // namespace rbd
-
void expect_mirror_image_get_image_id(const std::string& image_id, int r) {
bufferlist bl;
- ::encode(image_id, bl);
+ encode(image_id, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_get_image_id"), _, _, _))
mirror_image.state = mirror_image_state;
bufferlist bl;
- ::encode(image_id, bl);
+ encode(image_id, bl);
encode(mirror_image, bl);
EXPECT_CALL(get_mock_io_ctx(m_local_io_ctx),
const librbd::journal::ClientData &client_data,
int r) {
bufferlist bl;
- ::encode(client_data, bl);
+ encode(client_data, bl);
EXPECT_CALL(mock_journaler, register_client(ContentsEqual(bl), _))
.WillOnce(WithArg<1>(Invoke([this, r](Context *on_finish) {
const librbd::journal::ClientData &client_data,
int r) {
bufferlist bl;
- ::encode(client_data, bl);
+ encode(client_data, bl);
EXPECT_CALL(mock_journaler, update_client(ContentsEqual(bl), _))
.WillOnce(WithArg<1>(Invoke([this, r](Context *on_finish) {
bufferlist encode_tag_data(const librbd::journal::TagData &tag_data) {
bufferlist bl;
- ::encode(tag_data, bl);
+ encode(tag_data, bl);
return bl;
}
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
client_data.client_meta = mirror_peer_client_meta;
client.data.clear();
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
expect_journaler_update_client(mock_journaler, client_data, 0);
// create the local image
cls::journal::Client client;
librbd::journal::ClientData client_data{
librbd::journal::ImageClientMeta{123}};
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
::journal::MockJournaler mock_journaler;
expect_journaler_get_client(mock_journaler,
librbd::Journal<>::IMAGE_CLIENT_ID,
mirror_peer_client_meta.state = librbd::journal::MIRROR_PEER_STATE_SYNCING;
client_data.client_meta = mirror_peer_client_meta;
client.data.clear();
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
expect_journaler_update_client(mock_journaler, client_data, 0);
// create the missing local image
void expect_mirror_image_get_image_id(librados::IoCtx &io_ctx,
const std::string &image_id, int r) {
bufferlist bl;
- ::encode(image_id, bl);
+ encode(image_id, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_get_image_id"), _, _, _))
void expect_mirror_image_get_image_id(librados::IoCtx &io_ctx,
const std::string &image_id, int r) {
bufferlist bl;
- ::encode(image_id, bl);
+ encode(image_id, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_get_image_id"), _, _, _))
void expect_mirror_uuid_get(librados::IoCtx &io_ctx,
const std::string &mirror_uuid, int r) {
bufferlist bl;
- ::encode(mirror_uuid, bl);
+ encode(mirror_uuid, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_uuid_get"), _, _, _))
const librbd::journal::ClientData &client_data,
int r) {
bufferlist bl;
- ::encode(client_data, bl);
+ encode(client_data, bl);
EXPECT_CALL(mock_journaler, register_client(ContentsEqual(bl), _))
.WillOnce(WithArg<1>(Invoke([this, r](Context *on_finish) {
librbd::journal::ClientData client_data{mirror_peer_client_meta};
cls::journal::Client client;
client.state = cls::journal::CLIENT_STATE_DISCONNECTED;
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
expect_journaler_get_client(mock_remote_journaler, "local mirror uuid",
client, 0);
const std::map<std::string, std::string> &ids,
int r) {
bufferlist bl;
- ::encode(ids, bl);
+ encode(ids, bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_image_list"), _, _, _))
librbd::journal::ClientData client_data(m_client_meta);
bufferlist client_data_bl;
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
ASSERT_EQ(0, m_remote_journaler->register_client(client_data_bl));
}
bufferlist encode_tag_data(const librbd::journal::TagData &tag_data) {
bufferlist bl;
- ::encode(tag_data, bl);
+ encode(tag_data, bl);
return bl;
}
client_data.client_meta = image_client_meta;
cls::journal::Client client;
- ::encode(client_data, client.data);
+ encode(client_data, client.data);
EXPECT_CALL(mock_journaler, get_cached_client("local_mirror_uuid", _))
.WillOnce(DoAll(SetArgPointee<1>(client),
auto ctx = new FunctionContext(
[instance_watcher, &mock_io_ctx, c, pbl](int r) {
instance_watcher->cancel_notify_requests("other");
- ::encode(librbd::watcher::NotifyResponse(), *pbl);
+ encode(librbd::watcher::NotifyResponse(), *pbl);
mock_io_ctx.get_mock_rados_client()->
finish_aio_completion(c, -ETIMEDOUT);
});
auto ctx = new FunctionContext(
[instance_watcher, &mock_io_ctx, c, pbl](int r) {
instance_watcher->cancel_notify_requests("other");
- ::encode(librbd::watcher::NotifyResponse(), *pbl);
+ encode(librbd::watcher::NotifyResponse(), *pbl);
mock_io_ctx.get_mock_rados_client()->
finish_aio_completion(c, -ETIMEDOUT);
});
auto ctx = new FunctionContext(
[instance_watcher, &mock_io_ctx, c, pbl](int r) {
instance_watcher->cancel_notify_requests("other");
- ::encode(librbd::watcher::NotifyResponse(), *pbl);
+ encode(librbd::watcher::NotifyResponse(), *pbl);
mock_io_ctx.get_mock_rados_client()->
finish_aio_completion(c, -ETIMEDOUT);
});
void expect_mirror_uuid_get(librados::IoCtx &io_ctx,
const std::string &uuid, int r) {
bufferlist out_bl;
- ::encode(uuid, out_bl);
+ encode(uuid, out_bl);
EXPECT_CALL(get_mock_io_ctx(io_ctx),
exec(RBD_MIRRORING, _, StrEq("rbd"), StrEq("mirror_uuid_get"),
bl.append(buf, 4);
bufferlist::iterator p = bl.begin();
uint32_t len;
- ::decode(len, p);
+ decode(len, p);
if (len > max)
return -EINVAL;
bufferlist bl;
__u8 tag = exists ? RBD_DIFF_WRITE : RBD_DIFF_ZERO;
uint64_t len = 0;
- ::encode(tag, bl);
+ encode(tag, bl);
if (export_format == 2) {
if (tag == RBD_DIFF_WRITE)
len = 8 + 8 + length;
else
len = 8 + 8;
- ::encode(len, bl);
+ encode(len, bl);
}
- ::encode(offset, bl);
- ::encode(length, bl);
+ encode(offset, bl);
+ encode(length, bl);
int r = bl.write_fd(edc->fd);
edc->pc.update_progress(offset, edc->totalsize);
uint64_t len = 0;
if (fromsnapname) {
tag = RBD_DIFF_FROM_SNAP;
- ::encode(tag, bl);
+ encode(tag, bl);
std::string from(fromsnapname);
if (export_format == 2) {
len = from.length() + 4;
- ::encode(len, bl);
+ encode(len, bl);
}
- ::encode(from, bl);
+ encode(from, bl);
}
if (endsnapname) {
tag = RBD_DIFF_TO_SNAP;
- ::encode(tag, bl);
+ encode(tag, bl);
std::string to(endsnapname);
if (export_format == 2) {
len = to.length() + 4;
- ::encode(len, bl);
+ encode(len, bl);
}
- ::encode(to, bl);
+ encode(to, bl);
}
tag = RBD_DIFF_IMAGE_SIZE;
- ::encode(tag, bl);
+ encode(tag, bl);
uint64_t endsize = info.size;
if (export_format == 2) {
len = 8;
- ::encode(len, bl);
+ encode(len, bl);
}
- ::encode(endsize, bl);
+ encode(endsize, bl);
r = bl.write_fd(fd);
if (r < 0) {
{
__u8 tag = RBD_DIFF_END;
bufferlist bl;
- ::encode(tag, bl);
+ encode(tag, bl);
r = bl.write_fd(fd);
}
// encode order
tag = RBD_EXPORT_IMAGE_ORDER;
length = 8;
- ::encode(tag, bl);
- ::encode(length, bl);
- ::encode(uint64_t(info.order), bl);
+ encode(tag, bl);
+ encode(length, bl);
+ encode(uint64_t(info.order), bl);
// encode features
tag = RBD_EXPORT_IMAGE_FEATURES;
uint64_t features;
image.features(&features);
length = 8;
- ::encode(tag, bl);
- ::encode(length, bl);
- ::encode(features, bl);
+ encode(tag, bl);
+ encode(length, bl);
+ encode(features, bl);
// encode stripe_unit and stripe_count
tag = RBD_EXPORT_IMAGE_STRIPE_UNIT;
uint64_t stripe_unit;
stripe_unit = image.get_stripe_unit();
length = 8;
- ::encode(tag, bl);
- ::encode(length, bl);
- ::encode(stripe_unit, bl);
+ encode(tag, bl);
+ encode(length, bl);
+ encode(stripe_unit, bl);
tag = RBD_EXPORT_IMAGE_STRIPE_COUNT;
uint64_t stripe_count;
stripe_count = image.get_stripe_count();
length = 8;
- ::encode(tag, bl);
- ::encode(length, bl);
- ::encode(stripe_count, bl);
+ encode(tag, bl);
+ encode(length, bl);
+ encode(stripe_count, bl);
//retrieve metadata of image
std::map<std::string, string> imagemetas;
tag = RBD_EXPORT_IMAGE_META;
length = key.length() + value.length() + 4 * 2;
- ::encode(tag, bl);
- ::encode(length, bl);
- ::encode(key, bl);
- ::encode(value, bl);
+ encode(tag, bl);
+ encode(length, bl);
+ encode(key, bl);
+ encode(value, bl);
}
// encode end tag
tag = RBD_EXPORT_IMAGE_END;
- ::encode(tag, bl);
+ encode(tag, bl);
// write bl to fd.
r = bl.write_fd(fd);
}
uint64_t diff_num = snaps.size() + 1;
- ::encode(diff_num, bl);
+ encode(diff_num, bl);
r = bl.write_fd(fd);
if (r < 0) {
bufferlist bl;
bl.append(buf, sizeof(buf));
bufferlist::iterator p = bl.begin();
- ::decode(end_size, p);
+ decode(end_size, p);
uint64_t cur_size;
idiffctx->image->size(&cur_size);
bufferlist::iterator p = bl.begin();
uint64_t image_offset, buffer_length;
- ::decode(image_offset, p);
- ::decode(buffer_length, p);
+ decode(image_offset, p);
+ decode(buffer_length, p);
if (!discard) {
bufferptr bp = buffer::create(buffer_length);
bufferlist bl;
bl.append(buf, sizeof(buf));
bufferlist::iterator p = bl.begin();
- ::decode(*readlen, p);
+ decode(*readlen, p);
}
return 0;
it = bl.begin();
uint64_t val;
- ::decode(val, it);
+ decode(val, it);
if (opts.get(imageopt, &val) != 0) {
opts.set(imageopt, val);
bl.append(buf, sizeof(buf));
bufferlist::iterator p = bl.begin();
uint64_t diff_num;
- ::decode(diff_num, p);
-
+ decode(diff_num, p);
for (size_t i = 0; i < diff_num; i++) {
r = do_import_diff_fd(rados, image, fd, true, 2, sparse_size);
if (r < 0) {
bool verbose) {
try {
bufferlist::iterator it = data.begin();
- ::decode(event_entry, it);
+ decode(event_entry, it);
} catch (const buffer::error &err) {
std::cerr << "failed to decode event entry: " << err.what() << std::endl;
return -EINVAL;
bufferlist bl;
bl.append(buf, 8);
bufferlist::iterator p = bl.begin();
- ::decode(*size, p);
+ decode(*size, p);
} else {
break;
}
bufferlist bl;
bl.append(buf, 16);
bufferlist::iterator p = bl.begin();
- ::decode(*offset, p);
- ::decode(*length, p);
+ decode(*offset, p);
+ decode(*length, p);
if (!(*length))
return -ENOTSUP;
return 0;
bufferlist bl;
- ::encode(tag, bl);
- ::encode(offset, bl);
- ::encode(length, bl);
+ encode(tag, bl);
+ encode(offset, bl);
+ encode(length, bl);
int r;
r = bl.write_fd(pd);
if (r < 0)
__u8 tag;
if (f_from.size()) {
tag = RBD_DIFF_FROM_SNAP;
- ::encode(tag, bl);
- ::encode(f_from, bl);
+ encode(tag, bl);
+ encode(f_from, bl);
}
if (s_to.size()) {
tag = RBD_DIFF_TO_SNAP;
- ::encode(tag, bl);
- ::encode(s_to, bl);
+ encode(tag, bl);
+ encode(s_to, bl);
}
tag = RBD_DIFF_IMAGE_SIZE;
- ::encode(tag, bl);
- ::encode(s_size, bl);
+ encode(tag, bl);
+ encode(s_size, bl);
r = bl.write_fd(pd);
if (r < 0) {
{//tail
__u8 tag = RBD_DIFF_END;
bufferlist bl;
- ::encode(tag, bl);
+ encode(tag, bl);
r = bl.write_fd(pd);
}
image_map::PolicyMetaNone policy_meta;
bufferlist bl;
- ::encode(image_map::PolicyData(policy_meta), bl);
+ encode(image_map::PolicyData(policy_meta), bl);
// prepare update map
std::map<std::string, cls::rbd::MirrorImageMap> update_mapping;
if (r == 0) {
try {
bufferlist::iterator it = m_replay_tag.data.begin();
- ::decode(m_replay_tag_data, it);
+ decode(m_replay_tag_data, it);
} catch (const buffer::error &err) {
r = -EBADMSG;
}
bufferlist client_data_bl;
librbd::journal::ClientData client_data(*m_client_meta);
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
Context *ctx = create_context_callback<
ImageSync<I>, &ImageSync<I>::handle_update_sync_point>(
bufferlist client_data_bl;
librbd::journal::ClientData client_data(*m_client_meta);
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
Context *ctx = create_context_callback<
ImageSync<I>, &ImageSync<I>::handle_flush_sync_point>(
try {
auto iter = bl.begin();
NotifyAckPayload ack;
- ::decode(ack, iter);
+ decode(ack, iter);
if (ack.instance_id != instance_watcher->get_instance_id()) {
derr << "C_NotifyInstanceRequest: " << this << " " << __func__
<< ": ack instance_id (" << ack.instance_id << ") "
} else {
uint64_t request_id = ++m_request_seq;
bufferlist bl;
- ::encode(NotifyMessage{ImageAcquirePayload{request_id, global_image_id}},
+ encode(NotifyMessage{ImageAcquirePayload{request_id, global_image_id}},
bl);
auto req = new C_NotifyInstanceRequest(this, instance_id, request_id,
std::move(bl), on_notify_ack);
} else {
uint64_t request_id = ++m_request_seq;
bufferlist bl;
- ::encode(NotifyMessage{ImageReleasePayload{request_id, global_image_id}},
+ encode(NotifyMessage{ImageReleasePayload{request_id, global_image_id}},
bl);
auto req = new C_NotifyInstanceRequest(this, instance_id, request_id,
std::move(bl), on_notify_ack);
} else {
uint64_t request_id = ++m_request_seq;
bufferlist bl;
- ::encode(NotifyMessage{PeerImageRemovedPayload{request_id, global_image_id,
+ encode(NotifyMessage{PeerImageRemovedPayload{request_id, global_image_id,
peer_mirror_uuid}}, bl);
auto req = new C_NotifyInstanceRequest(this, instance_id, request_id,
std::move(bl), on_notify_ack);
uint64_t request_id = ++m_request_seq;
bufferlist bl;
- ::encode(NotifyMessage{SyncRequestPayload{request_id, sync_id}}, bl);
+ encode(NotifyMessage{SyncRequestPayload{request_id, sync_id}}, bl);
auto sync_ctx = new C_SyncRequest(this, sync_id, on_sync_start);
sync_ctx->req = new C_NotifyInstanceRequest(this, "", request_id,
uint64_t request_id = ++m_request_seq;
bufferlist bl;
- ::encode(NotifyMessage{SyncStartPayload{request_id, sync_id}}, bl);
+ encode(NotifyMessage{SyncStartPayload{request_id, sync_id}}, bl);
auto ctx = new FunctionContext(
[this, sync_id] (int r) {
m_requests.erase(it);
}
- ::encode(NotifyAckPayload(instance_id, request_id, r), on_notify_ack->out);
+ encode(NotifyAckPayload(instance_id, request_id, r), on_notify_ack->out);
on_notify_ack->complete(0);
}
NotifyMessage notify_message;
try {
bufferlist::iterator iter = bl.begin();
- ::decode(notify_message, iter);
+ decode(notify_message, iter);
} catch (const buffer::error &err) {
derr << "error decoding image notification: " << err.what() << dendl;
ctx->complete(0);
LeaderWatcher<I>, &LeaderWatcher<I>::handle_notify_lock_acquired>(this);
bufferlist bl;
- ::encode(NotifyMessage{LockAcquiredPayload{}}, bl);
+ encode(NotifyMessage{LockAcquiredPayload{}}, bl);
send_notify(bl, nullptr, ctx);
}
LeaderWatcher<I>, &LeaderWatcher<I>::handle_notify_lock_released>(this);
bufferlist bl;
- ::encode(NotifyMessage{LockReleasedPayload{}}, bl);
+ encode(NotifyMessage{LockReleasedPayload{}}, bl);
send_notify(bl, nullptr, ctx);
}
LeaderWatcher<I>, &LeaderWatcher<I>::handle_notify_heartbeat>(this);
bufferlist bl;
- ::encode(NotifyMessage{HeartbeatPayload{}}, bl);
+ encode(NotifyMessage{HeartbeatPayload{}}, bl);
m_heartbeat_response.acks.clear();
send_notify(bl, &m_heartbeat_response, ctx);
NotifyMessage notify_message;
try {
bufferlist::iterator iter = bl.begin();
- ::decode(notify_message, iter);
+ decode(notify_message, iter);
} catch (const buffer::error &err) {
derr << ": error decoding image notification: " << err.what() << dendl;
ctx->complete(0);
template <typename T>
inline void operator()(const T& t) const {
- ::encode(static_cast<uint32_t>(T::TYPE), m_bl);
+ using ceph::encode;
+ encode(static_cast<uint32_t>(T::TYPE), m_bl);
t.encode(m_bl);
}
private:
DECODE_START(1, it);
uint32_t policy_meta_type;
- ::decode(policy_meta_type, it);
+ decode(policy_meta_type, it);
switch (policy_meta_type) {
case POLICY_META_TYPE_NONE:
static void generate_test_instances(std::list<PolicyData *> &o);
};
+WRITE_CLASS_ENCODER(PolicyData);
+
} // namespace image_map
} // namespace mirror
} // namespace rbd
-WRITE_CLASS_ENCODER(rbd::mirror::image_map::PolicyData);
#endif // CEPH_RBD_MIRROR_IMAGE_MAP_TYPES_H
librbd::journal::ClientData client_data;
bufferlist::iterator it = m_client.data.begin();
try {
- ::decode(client_data, it);
+ decode(client_data, it);
} catch (const buffer::error &err) {
derr << ": failed to decode remote client meta data: " << err.what()
<< dendl;
librbd::journal::ClientData client_data(client_meta);
bufferlist data_bl;
- ::encode(client_data, data_bl);
+ encode(client_data, data_bl);
Context *ctx = create_context_callback<
BootstrapRequest<I>, &BootstrapRequest<I>::handle_update_client_state>(
librbd::journal::ClientData client_data{mirror_peer_client_meta};
bufferlist client_data_bl;
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
Context *ctx = create_context_callback<
BootstrapRequest<I>, &BootstrapRequest<I>::handle_register_client>(
librbd::journal::ClientData client_data(client_meta);
bufferlist data_bl;
- ::encode(client_data, data_bl);
+ encode(client_data, data_bl);
Context *ctx = create_context_callback<
BootstrapRequest<I>, &BootstrapRequest<I>::handle_update_client_image>(
try {
bufferlist::iterator it = remote_tag.data.begin();
- ::decode(remote_tag_data, it);
+ decode(remote_tag_data, it);
remote_tag_data_valid = true;
} catch (const buffer::error &err) {
derr << ": failed to decode remote tag " << remote_tag.tid << ": "
librbd::journal::ClientData client_data(client_meta);
bufferlist data_bl;
- ::encode(client_data, data_bl);
+ encode(client_data, data_bl);
Context *ctx = create_context_callback<
EventPreprocessor<I>, &EventPreprocessor<I>::handle_update_client>(
librbd::journal::ClientData client_data{mirror_peer_client_meta};
bufferlist client_data_bl;
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
Context *ctx = create_async_context_callback(
m_threads->work_queue, create_context_callback<
librbd::journal::ClientData client_data;
bufferlist::iterator it = m_client.data.begin();
try {
- ::decode(client_data, it);
+ decode(client_data, it);
} catch (const buffer::error &err) {
derr << "failed to decode client meta data: " << err.what() << dendl;
return false;
bufferlist::iterator it = m_tag.data.begin();
try {
- ::decode(tag_data, it);
+ decode(tag_data, it);
} catch (const buffer::error &err) {
derr << "error decoding tag " << master_tag_tid << ": " << err.what()
<< dendl;
bufferlist client_data_bl;
librbd::journal::ClientData client_data(m_client_meta_copy);
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
Context *ctx = create_context_callback<
SyncPointCreateRequest<I>, &SyncPointCreateRequest<I>::handle_update_client>(
bufferlist client_data_bl;
librbd::journal::ClientData client_data(m_client_meta_copy);
- ::encode(client_data, client_data_bl);
+ encode(client_data, client_data_bl);
Context *ctx = create_context_callback<
SyncPointPruneRequest<I>, &SyncPointPruneRequest<I>::handle_update_client>(
template <typename Payload>
inline void operator()(const Payload &payload) const {
- ::encode(static_cast<uint32_t>(Payload::NOTIFY_OP), m_bl);
+ using ceph::encode;
+ encode(static_cast<uint32_t>(Payload::NOTIFY_OP), m_bl);
payload.encode(m_bl);
}
} // anonymous namespace
void PayloadBase::encode(bufferlist &bl) const {
- ::encode(request_id, bl);
+ using ceph::encode;
+ encode(request_id, bl);
}
void PayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
- ::decode(request_id, iter);
+ using ceph::decode;
+ decode(request_id, iter);
}
void PayloadBase::dump(Formatter *f) const {
}
void ImagePayloadBase::encode(bufferlist &bl) const {
+ using ceph::encode;
PayloadBase::encode(bl);
- ::encode(global_image_id, bl);
+ encode(global_image_id, bl);
}
void ImagePayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
PayloadBase::decode(version, iter);
- ::decode(global_image_id, iter);
+ decode(global_image_id, iter);
}
void ImagePayloadBase::dump(Formatter *f) const {
}
void PeerImageRemovedPayload::encode(bufferlist &bl) const {
+ using ceph::encode;
PayloadBase::encode(bl);
- ::encode(global_image_id, bl);
- ::encode(peer_mirror_uuid, bl);
+ encode(global_image_id, bl);
+ encode(peer_mirror_uuid, bl);
}
void PeerImageRemovedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
PayloadBase::decode(version, iter);
- ::decode(global_image_id, iter);
- ::decode(peer_mirror_uuid, iter);
+ decode(global_image_id, iter);
+ decode(peer_mirror_uuid, iter);
}
void PeerImageRemovedPayload::dump(Formatter *f) const {
}
void SyncPayloadBase::encode(bufferlist &bl) const {
+ using ceph::encode;
PayloadBase::encode(bl);
- ::encode(sync_id, bl);
+ encode(sync_id, bl);
}
void SyncPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
+ using ceph::decode;
PayloadBase::decode(version, iter);
- ::decode(sync_id, iter);
+ decode(sync_id, iter);
}
void SyncPayloadBase::dump(Formatter *f) const {
DECODE_START(2, iter);
uint32_t notify_op;
- ::decode(notify_op, iter);
+ decode(notify_op, iter);
// select the correct payload variant based upon the encoded op
switch (notify_op) {
}
void NotifyAckPayload::encode(bufferlist &bl) const {
- ::encode(instance_id, bl);
- ::encode(request_id, bl);
- ::encode(ret_val, bl);
+ using ceph::encode;
+ encode(instance_id, bl);
+ encode(request_id, bl);
+ encode(ret_val, bl);
}
void NotifyAckPayload::decode(bufferlist::iterator &iter) {
- ::decode(instance_id, iter);
- ::decode(request_id, iter);
- ::decode(ret_val, iter);
+ using ceph::decode;
+ decode(instance_id, iter);
+ decode(request_id, iter);
+ decode(ret_val, iter);
}
void NotifyAckPayload::dump(Formatter *f) const {
template <typename Payload>
inline void operator()(const Payload &payload) const {
- ::encode(static_cast<uint32_t>(Payload::NOTIFY_OP), m_bl);
+ using ceph::encode;
+ encode(static_cast<uint32_t>(Payload::NOTIFY_OP), m_bl);
payload.encode(m_bl);
}
DECODE_START(1, iter);
uint32_t notify_op;
- ::decode(notify_op, iter);
+ decode(notify_op, iter);
// select the correct payload variant based upon the encoded op
switch (notify_op) {
projects / ceph-ci.git / commitdiff