}
try {
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
decode(*out, it);
} catch (const buffer::error &err) {
CLS_ERR("error decoding %s", key.c_str());
cls_rbd_snap snap_meta;
for (auto& val : vals) {
- bufferlist::iterator iter = val.second.begin();
+ auto iter = val.second.cbegin();
try {
decode(snap_meta, iter);
} catch (const buffer::error &err) {
int64_t data_pool_id = -1;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(size, iter);
decode(order, iter);
decode(features, iter);
{
bool read_only = false;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
uint64_t snap_id;
decode(snap_id, iter);
{
uint64_t features;
uint64_t mask;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(features, iter);
decode(mask, iter);
uint64_t snap_id, size;
uint8_t order;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
} catch (const buffer::error &err) {
{
uint64_t size;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(size, iter);
} catch (const buffer::error &err) {
{
snapid_t snap_id;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
} catch (const buffer::error &err) {
snapid_t snap_id;
uint8_t status;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
decode(status, iter);
{
uint64_t stripe_unit, stripe_count;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(stripe_unit, iter);
decode(stripe_count, iter);
}
} else {
try {
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
decode(timestamp, it);
} catch (const buffer::error &err) {
CLS_ERR("could not decode create_timestamp");
int get_flags(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
uint64_t snap_id;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
} catch (const buffer::error &err) {
uint64_t flags;
uint64_t mask;
uint64_t snap_id = CEPH_NOSNAP;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(flags, iter);
decode(mask, iter);
{
uint64_t op_features;
uint64_t mask;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(op_features, iter);
decode(mask, iter);
{
uint64_t snap_id;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
} catch (const buffer::error &err) {
snapid_t snapid;
uint64_t size;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(pool, iter);
decode(id, iter);
* methods for dealing with rbd_children object
*/
-static int decode_parent_common(bufferlist::iterator& it, uint64_t *pool_id,
+static int decode_parent_common(bufferlist::const_iterator& it, uint64_t *pool_id,
string *image_id, snapid_t *snap_id)
{
try {
static int decode_parent(bufferlist *in, uint64_t *pool_id,
string *image_id, snapid_t *snap_id)
{
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
return decode_parent_common(it, pool_id, image_id, snap_id);
}
string *image_id, snapid_t *snap_id,
string *c_image_id)
{
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
int r = decode_parent_common(it, pool_id, image_id, snap_id);
if (r < 0)
return r;
{
uint64_t snap_id;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
} catch (const buffer::error &err) {
{
uint64_t snap_id;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
} catch (const buffer::error &err) {
{
uint64_t snap_id;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(snap_id, iter);
} catch (const buffer::error &err) {
uint64_t snap_limit;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(snap_meta.name, iter);
decode(snap_meta.id, iter);
if (!iter.end()) {
int r;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(src_snap_id, iter);
decode(dst_snap_name, iter);
} catch (const buffer::error &err) {
snapid_t snap_id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(snap_id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
snapid_t snap_id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(snap_id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
string id;
try {
- bufferlist::iterator iter = read_bl.begin();
+ auto iter = read_bl.cbegin();
decode(id, iter);
} catch (const buffer::error &err) {
return -EIO;
string id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
{
string src, dest, id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(src, iter);
decode(dest, iter);
decode(id, iter);
string name;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(name, iter);
} catch (const buffer::error &err) {
return -EINVAL;
string id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
for (map<string, bufferlist>::iterator it = vals.begin();
it != vals.end(); ++it) {
string id;
- bufferlist::iterator iter = it->second.begin();
+ auto iter = it->second.cbegin();
try {
decode(id, iter);
} catch (const buffer::error &err) {
string name, id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(name, iter);
decode(id, iter);
} catch (const buffer::error &err) {
{
string name, id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(name, iter);
decode(id, iter);
} catch (const buffer::error &err) {
}
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(object_map, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode object map: %s", err.what());
{
BitVector<2> object_map;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(object_map, iter);
} catch (const buffer::error &err) {
return -EINVAL;
uint64_t object_count;
uint8_t default_state;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(object_count, iter);
decode(default_state, iter);
} catch (const buffer::error &err) {
uint8_t new_object_state;
boost::optional<uint8_t> current_object_state;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_object_no, iter);
decode(end_object_no, iter);
decode(new_object_state, iter);
}
try {
- bufferlist::iterator it = header_bl.begin();
+ auto it = header_bl.cbegin();
object_map.decode_header(it);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode object map header: %s", err.what());
}
try {
- bufferlist::iterator it = footer_bl.begin();
+ auto it = footer_bl.cbegin();
object_map.decode_footer(it);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode object map footer: %s", err.what());
}
try {
- bufferlist::iterator it = data_bl.begin();
+ auto it = data_bl.cbegin();
object_map.decode_data(it, byte_offset);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode data chunk [%" PRIu64 "]: %s",
{
BitVector<2> src_object_map;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(src_object_map, iter);
} catch (const buffer::error &err) {
return -EINVAL;
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
{
map<string, bufferlist> data, raw_data;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(data, iter);
} catch (const buffer::error &err) {
{
string key;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(key, iter);
} catch (const buffer::error &err) {
string key;
bufferlist value;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(key, iter);
} catch (const buffer::error &err) {
size_t snap_count = 0;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(new_limit, iter);
} catch (const buffer::error &err) {
return -EINVAL;
uint64_t snap_id;
cls::rbd::ChildImageSpec child_image;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(snap_id, it);
decode(child_image, it);
} catch (const buffer::error &err) {
uint64_t snap_id;
cls::rbd::ChildImageSpec child_image;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(snap_id, it);
decode(child_image, it);
} catch (const buffer::error &err) {
{
uint64_t snap_id;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(snap_id, it);
} catch (const buffer::error &err) {
return -EINVAL;
const char *snap_name;
const char *snap_names = ((char *)header) + names_ofs;
const char *end = snap_names + header->snap_names_len;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
string s;
uint64_t snap_id;
const char *snap_names = ((char *)header) + names_ofs;
const char *orig_names = snap_names;
const char *end = snap_names + header->snap_names_len;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
string s;
unsigned i;
bool found = false;
const char *snap_names = ((char *)header) + names_ofs;
const char *orig_names = snap_names;
const char *end = snap_names + header->snap_names_len;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
unsigned i;
bool found = false;
for (auto &it : vals) {
try {
- bufferlist::iterator bl_it = it.second.begin();
+ auto bl_it = it.second.cbegin();
cls::rbd::MirrorPeer peer;
decode(peer, bl_it);
peers->push_back(peer);
}
try {
- bufferlist::iterator bl_it = bl.begin();
+ auto bl_it = bl.cbegin();
decode(*peer, bl_it);
} catch (const buffer::error &err) {
CLS_ERR("could not decode peer '%s'", id.c_str());
}
try {
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
decode(*mirror_image, it);
} catch (const buffer::error &err) {
CLS_ERR("could not decode mirrored image '%s'", image_id.c_str());
cls::rbd::MirrorImageStatus::encode(bl);
}
- void decode_meta(bufferlist::iterator &it) {
+ void decode_meta(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(origin, it);
DECODE_FINISH(it);
}
- void decode(bufferlist::iterator &it) {
+ void decode(bufferlist::const_iterator &it) {
decode_meta(it);
cls::rbd::MirrorImageStatus::decode(it);
}
MirrorImageStatusOnDisk ondisk_status;
try {
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
decode(ondisk_status, it);
} catch (const buffer::error &err) {
CLS_ERR("could not decode status for mirrored image, global id '%s'",
mirror_images->size() < max_return; ++it) {
const std::string &image_id = it->first.substr(IMAGE_KEY_PREFIX.size());
cls::rbd::MirrorImage mirror_image;
- bufferlist::iterator iter = it->second.begin();
+ auto iter = it->second.cbegin();
try {
decode(mirror_image, iter);
} catch (const buffer::error &err) {
}
cls::rbd::MirrorImage mirror_image;
- bufferlist::iterator iter = list_it.second.begin();
+ auto iter = list_it.second.cbegin();
try {
decode(mirror_image, iter);
} catch (const buffer::error &err) {
MirrorImageStatusOnDisk status;
try {
- bufferlist::iterator it = list_it.second.begin();
+ auto it = list_it.second.cbegin();
status.decode_meta(it);
} catch (const buffer::error &err) {
CLS_ERR("could not decode status metadata for mirrored image '%s'",
it->first.substr(MIRROR_IMAGE_MAP_KEY_PREFIX.size());
cls::rbd::MirrorImageMap mirror_image_map;
- bufferlist::iterator iter = it->second.begin();
+ auto iter = it->second.cbegin();
try {
decode(mirror_image_map, iter);
} catch (const buffer::error &err) {
bufferlist *out) {
std::string mirror_uuid;
try {
- bufferlist::iterator bl_it = in->begin();
+ auto bl_it = in->cbegin();
decode(mirror_uuid, bl_it);
} catch (const buffer::error &err) {
return -EINVAL;
bufferlist *out) {
uint32_t mirror_mode_decode;
try {
- bufferlist::iterator bl_it = in->begin();
+ auto bl_it = in->cbegin();
decode(mirror_mode_decode, bl_it);
} catch (const buffer::error &err) {
return -EINVAL;
bufferlist *out) {
cls::rbd::MirrorPeer mirror_peer;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(mirror_peer, it);
} catch (const buffer::error &err) {
return -EINVAL;
bufferlist *out) {
std::string uuid;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(uuid, it);
} catch (const buffer::error &err) {
return -EINVAL;
std::string uuid;
std::string client_name;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(uuid, it);
decode(client_name, it);
} catch (const buffer::error &err) {
std::string uuid;
std::string cluster_name;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(uuid, it);
decode(cluster_name, it);
} catch (const buffer::error &err) {
std::string start_after;
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
const std::string &image_id =
it->first.substr(mirror::IMAGE_KEY_PREFIX.size());
cls::rbd::MirrorImage mirror_image;
- bufferlist::iterator iter = it->second.begin();
+ auto iter = it->second.cbegin();
try {
decode(mirror_image, iter);
} catch (const buffer::error &err) {
bufferlist *out) {
std::string global_id;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(global_id, it);
} catch (const buffer::error &err) {
return -EINVAL;
bufferlist *out) {
string image_id;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(image_id, it);
} catch (const buffer::error &err) {
return -EINVAL;
string image_id;
cls::rbd::MirrorImage mirror_image;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(image_id, it);
decode(mirror_image, it);
} catch (const buffer::error &err) {
bufferlist *out) {
string image_id;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(image_id, it);
} catch (const buffer::error &err) {
return -EINVAL;
string global_image_id;
cls::rbd::MirrorImageStatus status;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(global_image_id, it);
decode(status, it);
} catch (const buffer::error &err) {
bufferlist *out) {
string global_image_id;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(global_image_id, it);
} catch (const buffer::error &err) {
return -EINVAL;
bufferlist *out) {
string global_image_id;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(global_image_id, it);
} catch (const buffer::error &err) {
return -EINVAL;
std::string start_after;
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
bufferlist *out) {
std::string instance_id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(instance_id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
bufferlist *out) {
std::string instance_id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(instance_id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
std::string start_after;
uint64_t max_return;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(start_after, it);
decode(max_return, it);
} catch (const buffer::error &err) {
cls::rbd::MirrorImageMap image_map;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(global_image_id, it);
decode(image_map, it);
} catch (const buffer::error &err) {
std::string global_image_id;
try {
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
decode(global_image_id, it);
} catch (const buffer::error &err) {
return -EINVAL;
for (map<string, bufferlist>::iterator it = vals.begin();
it != vals.end() && group_snaps->size() < max_return; ++it) {
- bufferlist::iterator iter = it->second.begin();
+ auto iter = it->second.cbegin();
cls::rbd::GroupSnapshot snap;
try {
decode(snap, iter);
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
for (pair<string, bufferlist> val: vals) {
string id;
- bufferlist::iterator iter = val.second.begin();
+ auto iter = val.second.cbegin();
try {
decode(id, iter);
} catch (const buffer::error &err) {
string name, id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(name, iter);
decode(id, iter);
} catch (const buffer::error &err) {
{
string src, dest, id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(src, iter);
decode(dest, iter);
decode(id, iter);
{
string name, id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(name, iter);
decode(id, iter);
} catch (const buffer::error &err) {
cls::rbd::GroupImageStatus st;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(st, iter);
} catch (const buffer::error &err) {
return -EINVAL;
CLS_LOG(20, "group_image_remove");
cls::rbd::GroupImageSpec spec;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(spec, iter);
} catch (const buffer::error &err) {
return -EINVAL;
cls::rbd::GroupImageSpec start_after;
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
for (map<string, bufferlist>::iterator it = vals.begin();
it != vals.end() && res.size() < max_return; ++it) {
- bufferlist::iterator iter = it->second.begin();
+ auto iter = it->second.cbegin();
cls::rbd::GroupImageLinkState state;
try {
decode(state, iter);
CLS_LOG(20, "image_group_add");
cls::rbd::GroupSpec new_group;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(new_group, iter);
} catch (const buffer::error &err) {
return -EINVAL;
// success. If this image already belongs to another group then abort.
cls::rbd::GroupSpec old_group;
try {
- bufferlist::iterator iter = existing_refbl.begin();
+ auto iter = existing_refbl.cbegin();
decode(old_group, iter);
} catch (const buffer::error &err) {
return -EINVAL;
CLS_LOG(20, "image_group_remove");
cls::rbd::GroupSpec spec;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(spec, iter);
} catch (const buffer::error &err) {
return -EINVAL;
}
cls::rbd::GroupSpec ref_spec;
- bufferlist::iterator iter = refbl.begin();
+ auto iter = refbl.cbegin();
try {
decode(ref_spec, iter);
} catch (const buffer::error &err) {
cls::rbd::GroupSpec spec;
if (r != -ENOENT) {
- bufferlist::iterator iter = refbl.begin();
+ auto iter = refbl.cbegin();
try {
decode(spec, iter);
} catch (const buffer::error &err) {
CLS_LOG(20, "group_snap_set");
cls::rbd::GroupSnapshot group_snap;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(group_snap, iter);
} catch (const buffer::error &err) {
return -EINVAL;
CLS_LOG(20, "group_snap_remove");
std::string snap_id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(snap_id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
std::string snap_id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(snap_id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
}
cls::rbd::GroupSnapshot group_snap;
- bufferlist::iterator iter = snapbl.begin();
+ auto iter = snapbl.cbegin();
try {
decode(group_snap, iter);
} catch (const buffer::error &err) {
cls::rbd::GroupSnapshot start_after;
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
string id;
cls::rbd::TrashImageSpec trash_spec;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
decode(trash_spec, iter);
} catch (const buffer::error &err) {
{
string id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
uint64_t max_return;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after, iter);
decode(max_return, iter);
} catch (const buffer::error &err) {
{
string id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
} catch (const buffer::error &err) {
return -EINVAL;
encode(overlap, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(pool, bl);
decode(id, bl);
encode(child_count, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(7, p);
decode(id, p);
decode(name, p);
op->exec("rbd", "get_features", features_bl);
}
- int get_initial_metadata_finish(bufferlist::iterator *it,
+ int get_initial_metadata_finish(bufferlist::const_iterator *it,
std::string *object_prefix,
uint8_t *order,
uint64_t *features) {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_initial_metadata_finish(&it, object_prefix, order, features);
}
rados::cls::lock::get_lock_info_start(op, RBD_LOCK_NAME);
}
- int get_mutable_metadata_finish(bufferlist::iterator *it,
+ int get_mutable_metadata_finish(bufferlist::const_iterator *it,
uint64_t *size, uint64_t *features,
uint64_t *incompatible_features,
std::map<rados::cls::lock::locker_id_t,
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_mutable_metadata_finish(&it, size, features,
incompatible_features, lockers,
exclusive_lock, lock_tag, snapc,
return r;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(*features, iter);
} catch (const buffer::error &err) {
return -EBADMSG;
return r;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(*object_prefix, iter);
} catch (const buffer::error &err) {
return -EBADMSG;
op->exec("rbd", "get_data_pool", bl);
}
- int get_data_pool_finish(bufferlist::iterator *it, int64_t *data_pool_id) {
+ int get_data_pool_finish(bufferlist::const_iterator *it, int64_t *data_pool_id) {
try {
decode(*data_pool_id, *it);
} catch (const buffer::error &err) {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_data_pool_finish(&it, data_pool_id);
}
return r;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(*order, iter);
decode(*size, iter);
} catch (const buffer::error &err) {
op->exec("rbd", "get_parent", bl);
}
- int get_parent_finish(bufferlist::iterator *it, ParentSpec *pspec,
+ int get_parent_finish(bufferlist::const_iterator *it, ParentSpec *pspec,
uint64_t *parent_overlap)
{
try {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_parent_finish(&it, pspec, parent_overlap);
}
}
- int get_flags_finish(bufferlist::iterator *it, uint64_t *flags,
+ int get_flags_finish(bufferlist::const_iterator *it, uint64_t *flags,
const std::vector<snapid_t> &snap_ids,
std::vector<uint64_t> *snap_flags) {
snap_flags->resize(snap_ids.size());
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_flags_finish(&it, flags, snap_ids, snap_flags);
}
op->exec("rbd", "op_features_get", in_bl);
}
- int op_features_get_finish(bufferlist::iterator *it, uint64_t *op_features)
+ int op_features_get_finish(bufferlist::const_iterator *it, uint64_t *op_features)
{
try {
decode(*op_features, *it);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return op_features_get_finish(&it, op_features);
}
op->exec("rbd", "get_children", in_bl);
}
- int get_children_finish(bufferlist::iterator *it,
+ int get_children_finish(bufferlist::const_iterator *it,
std::set<std::string>* children) {
try {
decode(*children, *it);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_children_finish(&it, &children);
}
}
}
- int snapshot_get_finish(bufferlist::iterator *it,
+ int snapshot_get_finish(bufferlist::const_iterator *it,
const std::vector<snapid_t> &ids,
std::vector<cls::rbd::SnapshotInfo>* snaps,
std::vector<ParentInfo> *parents,
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return snapshot_get_finish(&it, ids, snaps, parents, protection_statuses);
}
op->exec("rbd", "get_snapcontext", bl);
}
- int get_snapcontext_finish(bufferlist::iterator *it,
+ int get_snapcontext_finish(bufferlist::const_iterator *it,
::SnapContext *snapc)
{
try {
return r;
}
- auto bl_it = out_bl.begin();
+ auto bl_it = out_bl.cbegin();
return get_snapcontext_finish(&bl_it, snapc);
}
}
}
- int snapshot_list_finish(bufferlist::iterator *it,
+ int snapshot_list_finish(bufferlist::const_iterator *it,
const std::vector<snapid_t> &ids,
std::vector<string> *names,
std::vector<uint64_t> *sizes,
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return snapshot_list_finish(&it, ids, names, sizes, parents,
protection_statuses);
}
}
}
- int snapshot_timestamp_list_finish(bufferlist::iterator *it,
+ int snapshot_timestamp_list_finish(bufferlist::const_iterator *it,
const std::vector<snapid_t> &ids,
std::vector<utime_t> *timestamps)
{
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return snapshot_timestamp_list_finish(&it, ids, timestamps);
}
op->exec("rbd", "snap_list", in_bl);
}
- int old_snapshot_list_finish(bufferlist::iterator *it,
+ int old_snapshot_list_finish(bufferlist::const_iterator *it,
std::vector<string> *names,
std::vector<uint64_t> *sizes,
::SnapContext *snapc) {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return old_snapshot_list_finish(&it, names, sizes, snapc);
}
op->exec("rbd", "get_all_features", in);
}
- int get_all_features_finish(bufferlist::iterator *it,
+ int get_all_features_finish(bufferlist::const_iterator *it,
uint64_t *all_features) {
try {
decode(*all_features, *it);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_all_features_finish(&it, all_features);
}
op->exec("rbd", "get_protection_status", bl);
}
- int get_protection_status_finish(bufferlist::iterator *it,
+ int get_protection_status_finish(bufferlist::const_iterator *it,
uint8_t *protection_status)
{
try {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_protection_status_finish(&it, protection_status);
}
}
try {
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
decode(*limit, iter);
} catch (const buffer::error &err) {
return -EBADMSG;
op->exec("rbd", "get_stripe_unit_count", empty_bl);
}
- int get_stripe_unit_count_finish(bufferlist::iterator *it,
+ int get_stripe_unit_count_finish(bufferlist::const_iterator *it,
uint64_t *stripe_unit,
uint64_t *stripe_count) {
assert(stripe_unit);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_stripe_unit_count_finish(&it, stripe_unit, stripe_count);
}
op->exec("rbd", "get_create_timestamp", empty_bl);
}
- int get_create_timestamp_finish(bufferlist::iterator *it,
+ int get_create_timestamp_finish(bufferlist::const_iterator *it,
utime_t *timestamp) {
assert(timestamp);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_create_timestamp_finish(&it, timestamp);
}
op->exec("rbd", "get_id", empty_bl);
}
- int get_id_finish(bufferlist::iterator *it, std::string *id) {
+ int get_id_finish(bufferlist::const_iterator *it, std::string *id) {
try {
decode(*id, *it);
} catch (const buffer::error &err) {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return get_id_finish(&it, id);
}
op->exec("rbd", "dir_get_id", bl);
}
- int dir_get_id_finish(bufferlist::iterator *iter, std::string *image_id) {
+ int dir_get_id_finish(bufferlist::const_iterator *iter, std::string *image_id) {
try {
decode(*image_id, *iter);
} catch (const buffer::error &err) {
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
return dir_get_id_finish(&iter, id);
}
op->exec("rbd", "dir_get_name", in_bl);
}
- int dir_get_name_finish(bufferlist::iterator *it, std::string *name) {
+ int dir_get_name_finish(bufferlist::const_iterator *it, std::string *name) {
try {
decode(*name, *it);
} catch (const buffer::error &err) {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return dir_get_name_finish(&it, name);
}
op->exec("rbd", "dir_list", in_bl);
}
- int dir_list_finish(bufferlist::iterator *it, map<string, string> *images)
+ int dir_list_finish(bufferlist::const_iterator *it, map<string, string> *images)
{
try {
decode(*images, *it);
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
return dir_list_finish(&iter, images);
}
op->exec("rbd", "object_map_load", in_bl);
}
- int object_map_load_finish(bufferlist::iterator *it,
+ int object_map_load_finish(bufferlist::const_iterator *it,
ceph::BitVector<2> *object_map) {
try {
decode(*object_map, *it);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return object_map_load_finish(&it, object_map);
}
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return metadata_list_finish(&it, pairs);
}
op->exec("rbd", "metadata_list", in_bl);
}
- int metadata_list_finish(bufferlist::iterator *it,
+ int metadata_list_finish(bufferlist::const_iterator *it,
std::map<std::string, bufferlist> *pairs)
{
assert(pairs);
if (r < 0)
return r;
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
try {
decode(*s, iter);
} catch (const buffer::error &err) {
op->exec("rbd", "children_list", bl);
}
- int children_list_finish(bufferlist::iterator *it,
+ int children_list_finish(bufferlist::const_iterator *it,
cls::rbd::ChildImageSpecs *child_images)
{
child_images->clear();
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
r = children_list_finish(&it, child_images);
if (r < 0) {
return r;
op->exec("rbd", "mirror_uuid_get", bl);
}
- int mirror_uuid_get_finish(bufferlist::iterator *it,
+ int mirror_uuid_get_finish(bufferlist::const_iterator *it,
std::string *uuid) {
try {
decode(*uuid, *it);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
r = mirror_uuid_get_finish(&it, uuid);
if (r < 0) {
return r;
op->exec("rbd", "mirror_mode_get", bl);
}
- int mirror_mode_get_finish(bufferlist::iterator *it,
+ int mirror_mode_get_finish(bufferlist::const_iterator *it,
cls::rbd::MirrorMode *mirror_mode) {
try {
uint32_t mirror_mode_decode;
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
r = mirror_mode_get_finish(&it, mirror_mode);
if (r < 0) {
return r;
peers->clear();
try {
- bufferlist::iterator bl_it = out_bl.begin();
+ auto bl_it = out_bl.cbegin();
decode(*peers, bl_it);
} catch (const buffer::error &err) {
return -EBADMSG;
op->exec("rbd", "mirror_image_list", in_bl);
}
- int mirror_image_list_finish(bufferlist::iterator *it,
+ int mirror_image_list_finish(bufferlist::const_iterator *it,
std::map<string, string> *mirror_image_ids)
{
try {
return r;
}
- bufferlist::iterator bl_it = out_bl.begin();
+ auto bl_it = out_bl.cbegin();
return mirror_image_list_finish(&bl_it, mirror_image_ids);
}
op->exec( "rbd", "mirror_image_get_image_id", in_bl);
}
- int mirror_image_get_image_id_finish(bufferlist::iterator *it,
+ int mirror_image_get_image_id_finish(bufferlist::const_iterator *it,
std::string *image_id) {
try {
decode(*image_id, *it);
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return mirror_image_get_image_id_finish(&it, image_id);
}
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = mirror_image_get_finish(&iter, mirror_image);
if (r < 0) {
return r;
op->exec("rbd", "mirror_image_get", in_bl);
}
- int mirror_image_get_finish(bufferlist::iterator *iter,
+ int mirror_image_get_finish(bufferlist::const_iterator *iter,
cls::rbd::MirrorImage *mirror_image) {
try {
decode(*mirror_image, *iter);
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = mirror_image_status_get_finish(&iter, status);
if (r < 0) {
return r;
op->exec("rbd", "mirror_image_status_get", bl);
}
- int mirror_image_status_get_finish(bufferlist::iterator *iter,
+ int mirror_image_status_get_finish(bufferlist::const_iterator *iter,
cls::rbd::MirrorImageStatus *status) {
try {
decode(*status, *iter);
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = mirror_image_status_list_finish(&iter, images, statuses);
if (r < 0) {
return r;
op->exec("rbd", "mirror_image_status_list", bl);
}
- int mirror_image_status_list_finish(bufferlist::iterator *iter,
+ int mirror_image_status_list_finish(bufferlist::const_iterator *iter,
std::map<std::string, cls::rbd::MirrorImage> *images,
std::map<std::string, cls::rbd::MirrorImageStatus> *statuses) {
images->clear();
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = mirror_image_status_get_summary_finish(&iter, states);
if (r < 0) {
return r;
op->exec("rbd", "mirror_image_status_get_summary", bl);
}
- int mirror_image_status_get_summary_finish(bufferlist::iterator *iter,
+ int mirror_image_status_get_summary_finish(bufferlist::const_iterator *iter,
std::map<cls::rbd::MirrorImageStatusState, int> *states) {
try {
decode(*states, *iter);
op->exec("rbd", "mirror_instances_list", bl);
}
- int mirror_instances_list_finish(bufferlist::iterator *iter,
+ int mirror_instances_list_finish(bufferlist::const_iterator *iter,
std::vector<std::string> *instance_ids) {
instance_ids->clear();
try {
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = mirror_instances_list_finish(&iter, instance_ids);
if (r < 0) {
return r;
op->exec("rbd", "mirror_image_map_list", bl);
}
- int mirror_image_map_list_finish(bufferlist::iterator *iter,
+ int mirror_image_map_list_finish(bufferlist::const_iterator *iter,
std::map<std::string, cls::rbd::MirrorImageMap> *image_mapping) {
try {
decode(*image_mapping, *iter);
if (r < 0)
return r;
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
try {
decode(*cgs, iter);
} catch (const buffer::error &err) {
if (r < 0)
return r;
- bufferlist::iterator iter = bl2.begin();
+ auto iter = bl2.cbegin();
try {
decode(*images, iter);
} catch (const buffer::error &err) {
op->exec("rbd", "image_group_get", in_bl);
}
- int image_group_get_finish(bufferlist::iterator *iter,
+ int image_group_get_finish(bufferlist::const_iterator *iter,
cls::rbd::GroupSpec *group_spec)
{
try {
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
return image_group_get_finish(&iter, group_spec);
}
return r;
}
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
try {
decode(*snapshot, iter);
} catch (const buffer::error &err) {
if (r < 0) {
return r;
}
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
try {
decode(*snapshots, iter);
} catch (const buffer::error &err) {
op->exec("rbd", "trash_list", bl);
}
- int trash_list_finish(bufferlist::iterator *it,
+ int trash_list_finish(bufferlist::const_iterator *it,
map<string, cls::rbd::TrashImageSpec> *entries)
{
assert(entries);
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
return trash_list_finish(&iter, entries);
}
op->exec("rbd", "trash_get", bl);
}
- int trash_get_finish(bufferlist::iterator *it,
+ int trash_get_finish(bufferlist::const_iterator *it,
cls::rbd::TrashImageSpec *trash_spec) {
assert(trash_spec);
try {
return r;
}
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
return trash_get_finish(&it, trash_spec);
}
namespace cls_client {
// high-level interface to the header
void get_initial_metadata_start(librados::ObjectReadOperation *op);
- int get_initial_metadata_finish(bufferlist::iterator *it,
+ int get_initial_metadata_finish(bufferlist::const_iterator *it,
std::string *object_prefix,
uint8_t *order,
uint64_t *features);
void get_mutable_metadata_start(librados::ObjectReadOperation *op,
bool read_only);
- int get_mutable_metadata_finish(bufferlist::iterator *it,
+ int get_mutable_metadata_finish(bufferlist::const_iterator *it,
uint64_t *size, uint64_t *features,
uint64_t *incompatible_features,
std::map<rados::cls::lock::locker_id_t,
int get_object_prefix(librados::IoCtx *ioctx, const std::string &oid,
std::string *object_prefix);
void get_data_pool_start(librados::ObjectReadOperation *op);
- int get_data_pool_finish(bufferlist::iterator *it, int64_t *data_pool_id);
+ int get_data_pool_finish(bufferlist::const_iterator *it, int64_t *data_pool_id);
int get_data_pool(librados::IoCtx *ioctx, const std::string &oid,
int64_t *data_pool_id);
int get_size(librados::IoCtx *ioctx, const std::string &oid,
void set_size(librados::ObjectWriteOperation *op, uint64_t size);
void get_parent_start(librados::ObjectReadOperation *op, snapid_t snap_id);
- int get_parent_finish(bufferlist::iterator *it, ParentSpec *pspec,
+ int get_parent_finish(bufferlist::const_iterator *it, ParentSpec *pspec,
uint64_t *parent_overlap);
int get_parent(librados::IoCtx *ioctx, const std::string &oid,
snapid_t snap_id, ParentSpec *pspec,
const ParentSpec &pspec, uint64_t parent_overlap);
void get_flags_start(librados::ObjectReadOperation *op,
const std::vector<snapid_t> &snap_ids);
- int get_flags_finish(bufferlist::iterator *it, uint64_t *flags,
+ int get_flags_finish(bufferlist::const_iterator *it, uint64_t *flags,
const std::vector<snapid_t> &snap_ids,
std::vector<uint64_t> *snap_flags);
int get_flags(librados::IoCtx *ioctx, const std::string &oid,
void set_flags(librados::ObjectWriteOperation *op, snapid_t snap_id,
uint64_t flags, uint64_t mask);
void op_features_get_start(librados::ObjectReadOperation *op);
- int op_features_get_finish(bufferlist::iterator *it, uint64_t *op_features);
+ int op_features_get_finish(bufferlist::const_iterator *it, uint64_t *op_features);
int op_features_get(librados::IoCtx *ioctx, const std::string &oid,
uint64_t *op_features);
void op_features_set(librados::ObjectWriteOperation *op,
const ParentSpec &pspec, const std::string &c_imageid);
void get_children_start(librados::ObjectReadOperation *op,
const ParentSpec &pspec);
- int get_children_finish(bufferlist::iterator *it,
+ int get_children_finish(bufferlist::const_iterator *it,
std::set<string> *children);
int get_children(librados::IoCtx *ioctx, const std::string &oid,
const ParentSpec &pspec, set<string>& children);
void snapshot_get_start(librados::ObjectReadOperation *op,
const std::vector<snapid_t> &ids);
- int snapshot_get_finish(bufferlist::iterator *it,
+ int snapshot_get_finish(bufferlist::const_iterator *it,
const std::vector<snapid_t> &ids,
std::vector<cls::rbd::SnapshotInfo>* snaps,
std::vector<ParentInfo> *parents,
snapid_t snap_id);
void get_snapcontext_start(librados::ObjectReadOperation *op);
- int get_snapcontext_finish(bufferlist::iterator *it,
+ int get_snapcontext_finish(bufferlist::const_iterator *it,
::SnapContext *snapc);
int get_snapcontext(librados::IoCtx *ioctx, const std::string &oid,
::SnapContext *snapc);
/// NOTE: remove after Luminous is retired
void snapshot_list_start(librados::ObjectReadOperation *op,
const std::vector<snapid_t> &ids);
- int snapshot_list_finish(bufferlist::iterator *it,
+ int snapshot_list_finish(bufferlist::const_iterator *it,
const std::vector<snapid_t> &ids,
std::vector<string> *names,
std::vector<uint64_t> *sizes,
/// NOTE: remove after Luminous is retired
void snapshot_timestamp_list_start(librados::ObjectReadOperation *op,
const std::vector<snapid_t> &ids);
- int snapshot_timestamp_list_finish(bufferlist::iterator *it,
+ int snapshot_timestamp_list_finish(bufferlist::const_iterator *it,
const std::vector<snapid_t> &ids,
std::vector<utime_t> *timestamps);
int snapshot_timestamp_list(librados::IoCtx *ioctx, const std::string &oid,
std::vector<utime_t> *timestamps);
void get_all_features_start(librados::ObjectReadOperation *op);
- int get_all_features_finish(bufferlist::iterator *it,
+ int get_all_features_finish(bufferlist::const_iterator *it,
uint64_t *all_features);
int get_all_features(librados::IoCtx *ioctx, const std::string &oid,
uint64_t *all_features);
/// NOTE: remove protection after clone v1 is retired
void get_protection_status_start(librados::ObjectReadOperation *op,
snapid_t snap_id);
- int get_protection_status_finish(bufferlist::iterator *it,
+ int get_protection_status_finish(bufferlist::const_iterator *it,
uint8_t *protection_status);
int get_protection_status(librados::IoCtx *ioctx, const std::string &oid,
snapid_t snap_id, uint8_t *protection_status);
uint64_t limit);
void get_stripe_unit_count_start(librados::ObjectReadOperation *op);
- int get_stripe_unit_count_finish(bufferlist::iterator *it,
+ int get_stripe_unit_count_finish(bufferlist::const_iterator *it,
uint64_t *stripe_unit,
uint64_t *stripe_count);
int get_stripe_unit_count(librados::IoCtx *ioctx, const std::string &oid,
int set_stripe_unit_count(librados::IoCtx *ioctx, const std::string &oid,
uint64_t stripe_unit, uint64_t stripe_count);
void get_create_timestamp_start(librados::ObjectReadOperation *op);
- int get_create_timestamp_finish(bufferlist::iterator *it,
+ int get_create_timestamp_finish(bufferlist::const_iterator *it,
utime_t *timestamp);
int get_create_timestamp(librados::IoCtx *ioctx, const std::string &oid,
utime_t *timestamp);
map<string, bufferlist> *pairs);
void metadata_list_start(librados::ObjectReadOperation *op,
const std::string &start, uint64_t max_return);
- int metadata_list_finish(bufferlist::iterator *it,
+ int metadata_list_finish(bufferlist::const_iterator *it,
std::map<std::string, bufferlist> *pairs);
void metadata_set(librados::ObjectWriteOperation *op,
const map<std::string, bufferlist> &data);
const cls::rbd::ChildImageSpec& child_image);
void children_list_start(librados::ObjectReadOperation *op,
snapid_t snap_id);
- int children_list_finish(bufferlist::iterator *it,
+ int children_list_finish(bufferlist::const_iterator *it,
cls::rbd::ChildImageSpecs *child_images);
int children_list(librados::IoCtx *ioctx, const std::string &oid,
snapid_t snap_id,
// operations on rbd_id objects
void get_id_start(librados::ObjectReadOperation *op);
- int get_id_finish(bufferlist::iterator *it, std::string *id);
+ int get_id_finish(bufferlist::const_iterator *it, std::string *id);
int get_id(librados::IoCtx *ioctx, const std::string &oid, std::string *id);
void set_id(librados::ObjectWriteOperation *op, const std::string &id);
const std::string &name, std::string *id);
void dir_get_id_start(librados::ObjectReadOperation *op,
const std::string &image_name);
- int dir_get_id_finish(bufferlist::iterator *iter, std::string *image_id);
+ int dir_get_id_finish(bufferlist::const_iterator *iter, std::string *image_id);
void dir_get_name_start(librados::ObjectReadOperation *op,
const std::string &id);
- int dir_get_name_finish(bufferlist::iterator *it, std::string *name);
+ int dir_get_name_finish(bufferlist::const_iterator *it, std::string *name);
int dir_get_name(librados::IoCtx *ioctx, const std::string &oid,
const std::string &id, std::string *name);
void dir_list_start(librados::ObjectReadOperation *op,
const std::string &start, uint64_t max_return);
- int dir_list_finish(bufferlist::iterator *it, map<string, string> *images);
+ int dir_list_finish(bufferlist::const_iterator *it, map<string, string> *images);
int dir_list(librados::IoCtx *ioctx, const std::string &oid,
const std::string &start, uint64_t max_return,
map<string, string> *images);
// operations on the rbd_object_map.$image_id object
void object_map_load_start(librados::ObjectReadOperation *op);
- int object_map_load_finish(bufferlist::iterator *it,
+ int object_map_load_finish(bufferlist::const_iterator *it,
ceph::BitVector<2> *object_map);
int object_map_load(librados::IoCtx *ioctx, const std::string &oid,
ceph::BitVector<2> *object_map);
snapid_t src_snap_id, const std::string &dst_name);
void old_snapshot_list_start(librados::ObjectReadOperation *op);
- int old_snapshot_list_finish(bufferlist::iterator *it,
+ int old_snapshot_list_finish(bufferlist::const_iterator *it,
std::vector<string> *names,
std::vector<uint64_t> *sizes,
::SnapContext *snapc);
// operations on the rbd_mirroring object
void mirror_uuid_get_start(librados::ObjectReadOperation *op);
- int mirror_uuid_get_finish(bufferlist::iterator *it,
+ int mirror_uuid_get_finish(bufferlist::const_iterator *it,
std::string *uuid);
int mirror_uuid_get(librados::IoCtx *ioctx, std::string *uuid);
int mirror_uuid_set(librados::IoCtx *ioctx, const std::string &uuid);
void mirror_mode_get_start(librados::ObjectReadOperation *op);
- int mirror_mode_get_finish(bufferlist::iterator *it,
+ int mirror_mode_get_finish(bufferlist::const_iterator *it,
cls::rbd::MirrorMode *mirror_mode);
int mirror_mode_get(librados::IoCtx *ioctx,
cls::rbd::MirrorMode *mirror_mode);
const std::string &cluster_name);
void mirror_image_list_start(librados::ObjectReadOperation *op,
const std::string &start, uint64_t max_return);
- int mirror_image_list_finish(bufferlist::iterator *it,
+ int mirror_image_list_finish(bufferlist::const_iterator *it,
std::map<string, string> *mirror_image_ids);
int mirror_image_list(librados::IoCtx *ioctx,
const std::string &start, uint64_t max_return,
std::map<std::string, std::string> *mirror_image_ids);
void mirror_image_get_image_id_start(librados::ObjectReadOperation *op,
const std::string &global_image_id);
- int mirror_image_get_image_id_finish(bufferlist::iterator *it,
+ int mirror_image_get_image_id_finish(bufferlist::const_iterator *it,
std::string *image_id);
int mirror_image_get_image_id(librados::IoCtx *ioctx,
const std::string &global_image_id,
cls::rbd::MirrorImage *mirror_image);
void mirror_image_get_start(librados::ObjectReadOperation *op,
const std::string &image_id);
- int mirror_image_get_finish(bufferlist::iterator *iter,
+ int mirror_image_get_finish(bufferlist::const_iterator *iter,
cls::rbd::MirrorImage *mirror_image);
void mirror_image_set(librados::ObjectWriteOperation *op,
const std::string &image_id,
cls::rbd::MirrorImageStatus *status);
void mirror_image_status_get_start(librados::ObjectReadOperation *op,
const std::string &global_image_id);
- int mirror_image_status_get_finish(bufferlist::iterator *iter,
+ int mirror_image_status_get_finish(bufferlist::const_iterator *iter,
cls::rbd::MirrorImageStatus *status);
int mirror_image_status_list(librados::IoCtx *ioctx,
const std::string &start, uint64_t max_return,
void mirror_image_status_list_start(librados::ObjectReadOperation *op,
const std::string &start,
uint64_t max_return);
- int mirror_image_status_list_finish(bufferlist::iterator *iter,
+ int mirror_image_status_list_finish(bufferlist::const_iterator *iter,
std::map<std::string, cls::rbd::MirrorImage> *images,
std::map<std::string, cls::rbd::MirrorImageStatus> *statuses);
int mirror_image_status_get_summary(librados::IoCtx *ioctx,
std::map<cls::rbd::MirrorImageStatusState, int> *states);
void mirror_image_status_get_summary_start(librados::ObjectReadOperation *op);
- int mirror_image_status_get_summary_finish(bufferlist::iterator *iter,
+ int mirror_image_status_get_summary_finish(bufferlist::const_iterator *iter,
std::map<cls::rbd::MirrorImageStatusState, int> *states);
int mirror_image_status_remove_down(librados::IoCtx *ioctx);
void mirror_image_status_remove_down(librados::ObjectWriteOperation *op);
void mirror_instances_list_start(librados::ObjectReadOperation *op);
- int mirror_instances_list_finish(bufferlist::iterator *iter,
+ int mirror_instances_list_finish(bufferlist::const_iterator *iter,
std::vector<std::string> *instance_ids);
int mirror_instances_list(librados::IoCtx *ioctx,
std::vector<std::string> *instance_ids);
void mirror_image_map_list_start(librados::ObjectReadOperation *op,
const std::string &start_after,
uint64_t max_read);
- int mirror_image_map_list_finish(bufferlist::iterator *iter,
+ int mirror_image_map_list_finish(bufferlist::const_iterator *iter,
std::map<std::string, cls::rbd::MirrorImageMap> *image_mapping);
void mirror_image_map_update(librados::ObjectWriteOperation *op,
const std::string &global_image_id,
int image_group_remove(librados::IoCtx *ioctx, const std::string &oid,
const cls::rbd::GroupSpec &group_spec);
void image_group_get_start(librados::ObjectReadOperation *op);
- int image_group_get_finish(bufferlist::iterator *iter,
+ int image_group_get_finish(bufferlist::const_iterator *iter,
cls::rbd::GroupSpec *group_spec);
int image_group_get(librados::IoCtx *ioctx, const std::string &oid,
cls::rbd::GroupSpec *group_spec);
int trash_remove(librados::IoCtx *ioctx, const std::string &id);
void trash_list_start(librados::ObjectReadOperation *op,
const std::string &start, uint64_t max_return);
- int trash_list_finish(bufferlist::iterator *it,
+ int trash_list_finish(bufferlist::const_iterator *it,
map<string, cls::rbd::TrashImageSpec> *entries);
int trash_list(librados::IoCtx *ioctx,
const std::string &start, uint64_t max_return,
map<string, cls::rbd::TrashImageSpec> *entries);
void trash_get_start(librados::ObjectReadOperation *op,
const std::string &id);
- int trash_get_finish(bufferlist::iterator *it,
+ int trash_get_finish(bufferlist::const_iterator *it,
cls::rbd::TrashImageSpec *trash_spec);
int trash_get(librados::IoCtx *ioctx, const std::string &id,
cls::rbd::TrashImageSpec *trash_spec);
ENCODE_FINISH(bl);
}
-void MirrorPeer::decode(bufferlist::iterator &it) {
+void MirrorPeer::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(uuid, it);
decode(cluster_name, it);
ENCODE_FINISH(bl);
}
-void MirrorImage::decode(bufferlist::iterator &it) {
+void MirrorImage::decode(bufferlist::const_iterator &it) {
uint8_t int_state;
DECODE_START(1, it);
decode(global_image_id, it);
ENCODE_FINISH(bl);
}
-void MirrorImageStatus::decode(bufferlist::iterator &it) {
+void MirrorImageStatus::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(state, it);
decode(description, it);
ENCODE_FINISH(bl);
}
-void ChildImageSpec::decode(bufferlist::iterator &it) {
+void ChildImageSpec::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(pool_id, it);
decode(image_id, it);
ENCODE_FINISH(bl);
}
-void GroupImageSpec::decode(bufferlist::iterator &it) {
+void GroupImageSpec::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(image_id, it);
decode(pool_id, it);
ENCODE_FINISH(bl);
}
-void GroupImageStatus::decode(bufferlist::iterator &it) {
+void GroupImageStatus::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(spec, it);
decode(state, it);
ENCODE_FINISH(bl);
}
-void GroupSpec::decode(bufferlist::iterator &it) {
+void GroupSpec::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(pool_id, it);
decode(group_id, it);
encode(group_snapshot_id, bl);
}
-void GroupSnapshotNamespace::decode(bufferlist::iterator& it) {
+void GroupSnapshotNamespace::decode(bufferlist::const_iterator& it) {
using ceph::decode;
decode(group_pool, it);
decode(group_id, it);
encode(static_cast<uint32_t>(original_snapshot_namespace_type), bl);
}
-void TrashSnapshotNamespace::decode(bufferlist::iterator& it) {
+void TrashSnapshotNamespace::decode(bufferlist::const_iterator& it) {
using ceph::decode;
decode(original_name, it);
uint32_t snap_type;
class DecodeSnapshotNamespaceVisitor : public boost::static_visitor<void> {
public:
- DecodeSnapshotNamespaceVisitor(bufferlist::iterator &iter)
+ DecodeSnapshotNamespaceVisitor(bufferlist::const_iterator &iter)
: m_iter(iter) {
}
t.decode(m_iter);
}
private:
- bufferlist::iterator &m_iter;
+ bufferlist::const_iterator &m_iter;
};
class DumpSnapshotNamespaceVisitor : public boost::static_visitor<void> {
ENCODE_FINISH(bl);
}
-void SnapshotInfo::decode(bufferlist::iterator& it) {
+void SnapshotInfo::decode(bufferlist::const_iterator& it) {
DECODE_START(1, it);
decode(id, it);
decode(snapshot_namespace, it);
ENCODE_FINISH(bl);
}
-void SnapshotNamespace::decode(bufferlist::iterator &p)
+void SnapshotNamespace::decode(bufferlist::const_iterator &p)
{
DECODE_START(1, p);
uint32_t snap_type;
ENCODE_FINISH(bl);
}
-void ImageSnapshotSpec::decode(bufferlist::iterator& it) {
+void ImageSnapshotSpec::decode(bufferlist::const_iterator& it) {
using ceph::decode;
DECODE_START(1, it);
decode(pool, it);
ENCODE_FINISH(bl);
}
-void GroupSnapshot::decode(bufferlist::iterator& it) {
+void GroupSnapshot::decode(bufferlist::const_iterator& it) {
using ceph::decode;
DECODE_START(1, it);
decode(id, it);
ENCODE_FINISH(bl);
}
-void TrashImageSpec::decode(bufferlist::iterator &it) {
+void TrashImageSpec::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(source, it);
decode(name, it);
ENCODE_FINISH(bl);
}
-void MirrorImageMap::decode(bufferlist::iterator &it) {
+void MirrorImageMap::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(instance_id, it);
decode(mapped_time, it);
encode(static_cast<uint8_t>(state), bl);
}
-inline void decode(GroupImageLinkState &state, bufferlist::iterator& it)
+inline void decode(GroupImageLinkState &state, bufferlist::const_iterator& it)
{
uint8_t int_state;
using ceph::decode;
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<MirrorPeer*> &o);
MirrorImageState state = MIRROR_IMAGE_STATE_DISABLING;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<MirrorImage*> &o);
encode(static_cast<uint8_t>(state), bl);
}
-inline void decode(MirrorImageStatusState &state, bufferlist::iterator& it)
+inline void decode(MirrorImageStatusState &state, bufferlist::const_iterator& it)
{
uint8_t int_state;
using ceph::decode;
bool up = false;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
std::string state_to_string() const;
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<ChildImageSpec*> &o);
int64_t pool_id = -1;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<GroupImageSpec*> &o);
GroupImageLinkState state = GROUP_IMAGE_LINK_STATE_INCOMPLETE;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<GroupImageStatus*> &o);
int64_t pool_id = -1;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
bool is_valid() const;
UserSnapshotNamespace() {}
void encode(bufferlist& bl) const {}
- void decode(bufferlist::iterator& it) {}
+ void decode(bufferlist::const_iterator& it) {}
void dump(Formatter *f) const {}
string group_snapshot_id;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
original_snapshot_namespace_type(original_snapshot_namespace_type) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
inline bool operator==(const TrashSnapshotNamespace& usn) const {
UnknownSnapshotNamespace() {}
void encode(bufferlist& bl) const {}
- void decode(bufferlist::iterator& it) {}
+ void decode(bufferlist::const_iterator& it) {}
void dump(Formatter *f) const {}
inline bool operator==(const UnknownSnapshotNamespace& gsn) const {
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<SnapshotNamespace*> &o);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<SnapshotInfo*> &o);
encode(static_cast<uint8_t>(state), bl);
}
-inline void decode(GroupSnapshotState &state, bufferlist::iterator& it)
+inline void decode(GroupSnapshotState &state, bufferlist::const_iterator& it)
{
using ceph::decode;
uint8_t int_state;
snap_id(_snap_id) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
vector<ImageSnapshotSpec> snaps;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<GroupSnapshot *> &o);
encode(static_cast<uint8_t>(source), bl);
}
-inline void decode(TrashImageSource &source, bufferlist::iterator& it)
+inline void decode(TrashImageSource &source, bufferlist::const_iterator& it)
{
uint8_t int_source;
using ceph::decode;
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
inline bool operator==(const TrashImageSpec& rhs) const {
bufferlist data;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<MirrorImageMap*> &o);
notify_message = NotifyMessage(HeaderUpdatePayload());
} else {
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(notify_message, iter);
} catch (const buffer::error &err) {
lderr(m_image_ctx.cct) << this << " error decoding image notification: "
}
librbd::journal::ClientData client_data;
- bufferlist::iterator bl_it = client->data.begin();
+ auto bl_it = client->data.cbegin();
try {
decode(client_data, bl_it);
} catch (const buffer::error &err) {
}
bufferlist data = replay_entry.get_data();
- bufferlist::iterator it = data.begin();
+ auto it = data.cbegin();
journal::EventEntry event_entry;
int r = m_journal_replay->decode(&it, &event_entry);
}
librbd::journal::ClientData client_data;
- bufferlist::iterator bl_it = client.data.begin();
+ auto bl_it = client.data.cbegin();
try {
decode(client_data, bl_it);
} catch (const buffer::error &err) {
NotifyMessage notify_message;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(notify_message, iter);
} catch (const buffer::error &err) {
lderr(cct) << ": error decoding image notification: " << err.what()
NotifyMessage notify_message;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(notify_message, iter);
} catch (const buffer::error &err) {
lderr(cct) << "error decoding image notification: " << err.what()
encode(request_id, bl);
}
-void AsyncRequestId::decode(bufferlist::iterator &iter) {
+void AsyncRequestId::decode(bufferlist::const_iterator &iter) {
using ceph::decode;
decode(client_id, iter);
decode(request_id, iter);
encode(client_id, bl);
}
-void AcquiredLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void AcquiredLockPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
if (version >= 2) {
decode(client_id, iter);
encode(client_id, bl);
}
-void ReleasedLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void ReleasedLockPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
if (version >= 2) {
decode(client_id, iter);
encode(force, bl);
}
-void RequestLockPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void RequestLockPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
if (version >= 2) {
decode(client_id, iter);
void HeaderUpdatePayload::encode(bufferlist &bl) const {
}
-void HeaderUpdatePayload::decode(__u8 version, bufferlist::iterator &iter) {
+void HeaderUpdatePayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void HeaderUpdatePayload::dump(Formatter *f) const {
encode(async_request_id, bl);
}
-void AsyncRequestPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
+void AsyncRequestPayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(async_request_id, iter);
}
encode(total, bl);
}
-void AsyncProgressPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void AsyncProgressPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
AsyncRequestPayloadBase::decode(version, iter);
decode(offset, iter);
encode(result, bl);
}
-void AsyncCompletePayload::decode(__u8 version, bufferlist::iterator &iter) {
+void AsyncCompletePayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
AsyncRequestPayloadBase::decode(version, iter);
decode(result, iter);
encode(allow_shrink, bl);
}
-void ResizePayload::decode(__u8 version, bufferlist::iterator &iter) {
+void ResizePayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(size, iter);
AsyncRequestPayloadBase::decode(version, iter);
encode(snap_namespace, bl);
}
-void SnapPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
+void SnapPayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(snap_name, iter);
if (version >= 6) {
SnapPayloadBase::encode(bl);
}
-void SnapCreatePayload::decode(__u8 version, bufferlist::iterator &iter) {
+void SnapCreatePayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
SnapPayloadBase::decode(version, iter);
if (version == 5) {
SnapPayloadBase::encode(bl);
}
-void SnapRenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
+void SnapRenamePayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(snap_id, iter);
SnapPayloadBase::decode(version, iter);
encode(image_name, bl);
}
-void RenamePayload::decode(__u8 version, bufferlist::iterator &iter) {
+void RenamePayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(image_name, iter);
}
encode(enabled, bl);
}
-void UpdateFeaturesPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void UpdateFeaturesPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(features, iter);
decode(enabled, iter);
ceph_abort();
}
-void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void UnknownPayload::dump(Formatter *f) const {
ENCODE_FINISH(bl);
}
-void NotifyMessage::decode(bufferlist::iterator& iter) {
+void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
uint32_t notify_op;
ENCODE_FINISH(bl);
}
-void ResponseMessage::decode(bufferlist::iterator& iter) {
+void ResponseMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
decode(result, iter);
DECODE_FINISH(iter);
: client_id(client_id_), request_id(request_id_) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
inline bool operator<(const AsyncRequestId &rhs) const {
AcquiredLockPayload(const ClientId &client_id_) : client_id(client_id_) {}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
ReleasedLockPayload(const ClientId &client_id_) : client_id(client_id_) {}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
static const bool CHECK_FOR_REFRESH = false;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
AsyncRequestId async_request_id;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
protected:
uint64_t total;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
int result;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
bool allow_shrink;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
std::string snap_name;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
protected:
: SnapPayloadBase(_snap_namespace, name) {}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
uint64_t snap_id = 0;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
std::string image_name;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
bool enabled;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
static const bool CHECK_FOR_REFRESH = false;
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
bool check_for_refresh() const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
NotifyOp get_notify_op() const;
int result;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<ResponseMessage *> &o);
Metadata metadata;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = librbd::cls_client::metadata_list_finish(&it, &metadata);
}
map<string, bufferlist> metadata;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = cls_client::metadata_list_finish(&it, &metadata);
}
ldout(m_cct, 20) << this << " " << __func__ << " r=" << r << dendl;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = cls_client::mirror_mode_get_finish(&it, &m_mirror_mode);
}
uint64_t all_features;
if (r >= 0) {
- bufferlist::iterator it = m_outbl.begin();
+ auto it = m_outbl.cbegin();
r = cls_client::get_all_features_finish(&it, &all_features);
}
if (r < 0) {
cls::rbd::MirrorMode mirror_mode_internal = cls::rbd::MIRROR_MODE_DISABLED;
if (r == 0) {
- bufferlist::iterator it = m_outbl.begin();
+ auto it = m_outbl.cbegin();
r = cls_client::mirror_mode_get_finish(&it, &mirror_mode_internal);
if (r < 0) {
lderr(m_cct) << "Failed to retrieve mirror mode" << dendl;
ldout(cct, 10) << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::get_id_finish(&it, &m_image_ctx->id);
}
if (*result < 0) {
ldout(cct, 10) << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::dir_get_name_finish(&it, &m_image_ctx->name);
}
if (*result < 0 && *result != -ENOENT) {
cls::rbd::TrashImageSpec trash_spec;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::trash_get_finish(&it, &trash_spec);
m_image_ctx->name = trash_spec.name;
}
ldout(cct, 10) << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::get_initial_metadata_finish(
&it, &m_image_ctx->object_prefix, &m_image_ctx->order, &m_image_ctx->features);
}
ldout(cct, 10) << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::get_stripe_unit_count_finish(
&it, &m_image_ctx->stripe_unit, &m_image_ctx->stripe_count);
}
ldout(cct, 10) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::get_create_timestamp_finish(&it,
&m_image_ctx->create_timestamp);
}
int64_t data_pool_id = -1;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::get_data_pool_finish(&it, &data_pool_id);
} else if (*result == -EOPNOTSUPP) {
*result = 0;
std::vector<std::string> snap_names;
std::vector<uint64_t> snap_sizes;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::old_snapshot_list_finish(&it, &snap_names,
&snap_sizes, &m_snapc);
}
if (*result == -EOPNOTSUPP) {
*result = 0;
} else if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
ClsLockType lock_type;
*result = rados::cls::lock::get_lock_info_finish(&it, &m_lockers,
&lock_type, &m_lock_tag);
<< "r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::get_mutable_metadata_finish(&it, &m_size, &m_features,
&m_incompatible_features,
&m_lockers,
std::map<std::string, bufferlist> metadata;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::metadata_list_finish(&it, &metadata);
}
if (*result == 0) {
/// NOTE: remove support for snap paramter after Luminous is retired
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
cls_client::get_flags_finish(&it, &m_flags, m_snapc.snaps, &m_snap_flags);
}
if (*result == -EOPNOTSUPP) {
// -EOPNOTSUPP handler not required since feature bit implies OSD
// supports the method
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
cls_client::op_features_get_finish(&it, &m_op_features);
} else if (*result < 0) {
lderr(cct) << "failed to retrieve op features: " << cpp_strerror(*result)
<< "r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
cls_client::image_group_get_finish(&it, &m_group_spec);
}
if (*result == -EOPNOTSUPP) {
<< "r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::snapshot_get_finish(&it, m_snapc.snaps, &m_snap_infos,
&m_snap_parents,
&m_snap_protection);
std::vector<std::string> snap_names;
std::vector<uint64_t> snap_sizes;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::snapshot_list_finish(&it, m_snapc.snaps,
&snap_names, &snap_sizes,
&m_snap_parents,
std::vector<utime_t> snap_timestamps;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::snapshot_timestamp_list_finish(&it, m_snapc.snaps,
&snap_timestamps);
}
cls::rbd::GroupSpec s;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = librbd::cls_client::image_group_get_finish(&it, &s);
}
if (r < 0 && r != -EOPNOTSUPP) {
}
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = librbd::cls_client::dir_get_id_finish(&iter, &m_image_id);
if (r < 0) {
finish(r);
}
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = librbd::cls_client::dir_get_name_finish(&iter, &m_image_name);
if (r < 0) {
finish(r);
}
try {
- bufferlist::iterator iter = response.begin();
+ auto iter = response.cbegin();
ResponseMessage response_message;
using ceph::decode;
// old format images are in a tmap
if (bl.length()) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
bufferlist header;
map<string,bufferlist> m;
decode(header, p);
}
librbd::journal::ClientData client_data;
- bufferlist::iterator bl = client.data.begin();
+ auto bl = client.data.cbegin();
try {
decode(client_data, bl);
} catch (const buffer::error &err) {
}
template <typename I>
-int Replay<I>::decode(bufferlist::iterator *it, EventEntry *event_entry) {
+int Replay<I>::decode(bufferlist::const_iterator *it, EventEntry *event_entry) {
try {
using ceph::decode;
decode(*event_entry, *it);
Replay(ImageCtxT &image_ctx);
~Replay();
- int decode(bufferlist::iterator *it, EventEntry *event_entry);
+ int decode(bufferlist::const_iterator *it, EventEntry *event_entry);
void process(const EventEntry &event_entry,
Context *on_ready, Context *on_safe);
class DecodeVisitor : public boost::static_visitor<void> {
public:
- DecodeVisitor(__u8 version, bufferlist::iterator &iter)
+ DecodeVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {
}
}
private:
__u8 m_version;
- bufferlist::iterator &m_iter;
+ bufferlist::const_iterator &m_iter;
};
class DumpVisitor : public boost::static_visitor<void> {
encode(skip_partial_discard, bl);
}
-void AioDiscardEvent::decode(__u8 version, bufferlist::iterator& it) {
+void AioDiscardEvent::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(offset, it);
decode(length, it);
encode(data, bl);
}
-void AioWriteEvent::decode(__u8 version, bufferlist::iterator& it) {
+void AioWriteEvent::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(offset, it);
decode(length, it);
encode(data, bl);
}
-void AioWriteSameEvent::decode(__u8 version, bufferlist::iterator& it) {
+void AioWriteSameEvent::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(offset, it);
decode(length, it);
encode(write_data, bl);
}
-void AioCompareAndWriteEvent::decode(__u8 version, bufferlist::iterator& it) {
+void AioCompareAndWriteEvent::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(offset, it);
decode(length, it);
void AioFlushEvent::encode(bufferlist& bl) const {
}
-void AioFlushEvent::decode(__u8 version, bufferlist::iterator& it) {
+void AioFlushEvent::decode(__u8 version, bufferlist::const_iterator& it) {
}
void AioFlushEvent::dump(Formatter *f) const {
encode(op_tid, bl);
}
-void OpEventBase::decode(__u8 version, bufferlist::iterator& it) {
+void OpEventBase::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(op_tid, it);
}
encode(r, bl);
}
-void OpFinishEvent::decode(__u8 version, bufferlist::iterator& it) {
+void OpFinishEvent::decode(__u8 version, bufferlist::const_iterator& it) {
OpEventBase::decode(version, it);
using ceph::decode;
decode(op_tid, it);
encode(snap_namespace, bl);
}
-void SnapEventBase::decode(__u8 version, bufferlist::iterator& it) {
+void SnapEventBase::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
OpEventBase::decode(version, it);
using ceph::decode;
SnapEventBase::encode(bl);
}
-void SnapCreateEvent::decode(__u8 version, bufferlist::iterator& it) {
+void SnapCreateEvent::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
SnapEventBase::decode(version, it);
if (version == 3) {
encode(limit, bl);
}
-void SnapLimitEvent::decode(__u8 version, bufferlist::iterator& it) {
+void SnapLimitEvent::decode(__u8 version, bufferlist::const_iterator& it) {
OpEventBase::decode(version, it);
using ceph::decode;
decode(limit, it);
encode(src_snap_name, bl);
}
-void SnapRenameEvent::decode(__u8 version, bufferlist::iterator& it) {
+void SnapRenameEvent::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
OpEventBase::decode(version, it);
decode(dst_snap_name, it);
encode(image_name, bl);
}
-void RenameEvent::decode(__u8 version, bufferlist::iterator& it) {
+void RenameEvent::decode(__u8 version, bufferlist::const_iterator& it) {
OpEventBase::decode(version, it);
using ceph::decode;
decode(image_name, it);
encode(size, bl);
}
-void ResizeEvent::decode(__u8 version, bufferlist::iterator& it) {
+void ResizeEvent::decode(__u8 version, bufferlist::const_iterator& it) {
OpEventBase::decode(version, it);
using ceph::decode;
decode(size, it);
void DemotePromoteEvent::encode(bufferlist& bl) const {
}
-void DemotePromoteEvent::decode(__u8 version, bufferlist::iterator& it) {
+void DemotePromoteEvent::decode(__u8 version, bufferlist::const_iterator& it) {
}
void DemotePromoteEvent::dump(Formatter *f) const {
encode(enabled, bl);
}
-void UpdateFeaturesEvent::decode(__u8 version, bufferlist::iterator& it) {
+void UpdateFeaturesEvent::decode(__u8 version, bufferlist::const_iterator& it) {
OpEventBase::decode(version, it);
using ceph::decode;
decode(features, it);
encode(value, bl);
}
-void MetadataSetEvent::decode(__u8 version, bufferlist::iterator& it) {
+void MetadataSetEvent::decode(__u8 version, bufferlist::const_iterator& it) {
OpEventBase::decode(version, it);
using ceph::decode;
decode(key, it);
encode(key, bl);
}
-void MetadataRemoveEvent::decode(__u8 version, bufferlist::iterator& it) {
+void MetadataRemoveEvent::decode(__u8 version, bufferlist::const_iterator& it) {
OpEventBase::decode(version, it);
using ceph::decode;
decode(key, it);
ceph_abort();
}
-void UnknownEvent::decode(__u8 version, bufferlist::iterator& it) {
+void UnknownEvent::decode(__u8 version, bufferlist::const_iterator& it) {
}
void UnknownEvent::dump(Formatter *f) const {
encode_metadata(bl);
}
-void EventEntry::decode(bufferlist::iterator& it) {
+void EventEntry::decode(bufferlist::const_iterator& it) {
DECODE_START(1, it);
uint32_t event_type;
ENCODE_FINISH(bl);
}
-void EventEntry::decode_metadata(bufferlist::iterator& it) {
+void EventEntry::decode_metadata(bufferlist::const_iterator& it) {
DECODE_START(1, it);
decode(timestamp, it);
DECODE_FINISH(it);
encode(resync_requested, bl);
}
-void ImageClientMeta::decode(__u8 version, bufferlist::iterator& it) {
+void ImageClientMeta::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(tag_class, it);
decode(resync_requested, it);
encode(snap_namespace, bl);
}
-void MirrorPeerSyncPoint::decode(__u8 version, bufferlist::iterator& it) {
+void MirrorPeerSyncPoint::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(snap_name, it);
decode(from_snap_name, it);
encode(snap_seqs, bl);
}
-void MirrorPeerClientMeta::decode(__u8 version, bufferlist::iterator& it) {
+void MirrorPeerClientMeta::decode(__u8 version, bufferlist::const_iterator& it) {
using ceph::decode;
decode(image_id, it);
void CliClientMeta::encode(bufferlist& bl) const {
}
-void CliClientMeta::decode(__u8 version, bufferlist::iterator& it) {
+void CliClientMeta::decode(__u8 version, bufferlist::const_iterator& it) {
}
void CliClientMeta::dump(Formatter *f) const {
ceph_abort();
}
-void UnknownClientMeta::decode(__u8 version, bufferlist::iterator& it) {
+void UnknownClientMeta::decode(__u8 version, bufferlist::const_iterator& it) {
}
void UnknownClientMeta::dump(Formatter *f) const {
ENCODE_FINISH(bl);
}
-void ClientData::decode(bufferlist::iterator& it) {
+void ClientData::decode(bufferlist::const_iterator& it) {
DECODE_START(1, it);
uint32_t client_meta_type;
encode(entry_tid, bl);
}
-void TagPredecessor::decode(bufferlist::iterator& it) {
+void TagPredecessor::decode(bufferlist::const_iterator& it) {
using ceph::decode;
decode(mirror_uuid, it);
decode(commit_valid, it);
predecessor.encode(bl);
}
-void TagData::decode(bufferlist::iterator& it) {
+void TagData::decode(bufferlist::const_iterator& it) {
using ceph::decode;
decode(mirror_uuid, it);
predecessor.decode(it);
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
static const EventType TYPE = EVENT_TYPE_AIO_FLUSH;
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
EVENT_TYPE_DEMOTE_PROMOTE);
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
static const EventType TYPE = static_cast<EventType>(-1);
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
EventType get_event_type() const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<EventEntry *> &o);
static const uint32_t METADATA_FIXED_SIZE = 14; /// version encoding, timestamp
void encode_metadata(bufferlist& bl) const;
- void decode_metadata(bufferlist::iterator& it);
+ void decode_metadata(bufferlist::const_iterator& it);
};
// Journal Client data structures
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
static const ClientMetaType TYPE = CLI_CLIENT_META_TYPE;
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
static const ClientMetaType TYPE = static_cast<ClientMetaType>(-1);
void encode(bufferlist& bl) const;
- void decode(__u8 version, bufferlist::iterator& it);
+ void decode(__u8 version, bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
ClientMetaType get_client_meta_type() const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<ClientData *> &o);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<TagData *> &o);
namespace journal {
namespace util {
-int C_DecodeTag::decode(bufferlist::iterator *it, TagData *tag_data) {
+int C_DecodeTag::decode(bufferlist::const_iterator *it, TagData *tag_data) {
try {
using ceph::decode;
decode(*tag_data, *it);
Mutex::Locker locker(*lock);
*tag_tid = tag.tid;
- bufferlist::iterator data_it = tag.data.begin();
+ auto data_it = tag.data.cbegin();
r = decode(&data_it, tag_data);
if (r < 0) {
lderr(cct) << "C_DecodeTag: " << this << " " << __func__ << ": "
Mutex::Locker locker(*lock);
*tag_tid = tags.back().tid;
- bufferlist::iterator data_it = tags.back().data.begin();
+ auto data_it = tags.back().data.cbegin();
r = C_DecodeTag::decode(&data_it, tag_data);
if (r < 0) {
lderr(cct) << "C_DecodeTags: " << this << " " << __func__ << ": "
int process(int r);
- static int decode(bufferlist::iterator *it, TagData *tag_data);
+ static int decode(bufferlist::const_iterator *it, TagData *tag_data);
};
ClsLockType lock_type = LOCK_NONE;
std::string lock_tag;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = rados::cls::lock::get_lock_info_finish(&it, &lockers, &lock_type,
&lock_tag);
}
ldout(cct, 10) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
*result = cls_client::mirror_image_get_finish(&iter, &m_mirror_image);
}
for (auto client : m_clients) {
journal::ClientData client_data;
- bufferlist::iterator bl_it = client.data.begin();
+ auto bl_it = client.data.cbegin();
try {
using ceph::decode;
decode(client_data, bl_it);
ldout(m_cct, 10) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
*result = cls_client::mirror_image_get_finish(&iter, &m_mirror_image);
}
m_mirror_image->state = cls::rbd::MIRROR_IMAGE_STATE_DISABLED;
*m_promotion_state = PROMOTION_STATE_NON_PRIMARY;
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = cls_client::mirror_image_get_finish(&iter, m_mirror_image);
}
ldout(cct, 20) << "r=" << r << dendl;
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = cls_client::mirror_image_status_get_finish(&iter,
m_mirror_image_status);
}
encode(static_cast<uint32_t>(mirror_mode), bl);
}
-void ModeUpdatedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void ModeUpdatedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
uint32_t mirror_mode_decode;
decode(mirror_mode_decode, iter);
encode(global_image_id, bl);
}
-void ImageUpdatedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void ImageUpdatedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
uint32_t mirror_image_state_decode;
decode(mirror_image_state_decode, iter);
ceph_abort();
}
-void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void UnknownPayload::dump(Formatter *f) const {
ENCODE_FINISH(bl);
}
-void NotifyMessage::decode(bufferlist::iterator& iter) {
+void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
uint32_t notify_op;
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
Payload payload;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<NotifyMessage *> &o);
ClsLockType lock_type;
std::string lock_tag;
if (*ret_val == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*ret_val = rados::cls::lock::get_lock_info_finish(&it, &m_lockers,
&lock_type, &lock_tag);
}
ldout(cct, 10) << this << " " << __func__ << ": r=" << *ret_val << dendl;
if (*ret_val == 0) {
- bufferlist::iterator bl_it = m_out_bl.begin();
+ auto bl_it = m_out_bl.cbegin();
*ret_val = cls_client::object_map_load_finish(&bl_it,
&m_on_disk_object_map);
}
}
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = cls_client::object_map_load_finish(&it, &m_snap_object_map);
}
if (r < 0) {
ldout(cct, 20) << this << " " << __func__ << ": r=" << *result << dendl;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::mirror_mode_get_finish(&it, &m_mirror_mode);
}
cls::rbd::MirrorImage mirror_image;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::mirror_image_get_finish(&it, &mirror_image);
}
cls::rbd::MirrorMode mirror_mode = cls::rbd::MIRROR_MODE_DISABLED;
if (*result == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
*result = cls_client::mirror_mode_get_finish(&it, &mirror_mode);
} else if (*result == -ENOENT) {
*result = 0;
std::vector<cls::rbd::SnapshotInfo> snap_infos;
std::vector<ParentInfo> parents;
std::vector<uint8_t> protections;
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = cls_client::snapshot_get_finish(&it, {m_snap_id}, &snap_infos,
&parents, &protections);
if (r == 0) {
CephContext *cct = image_ctx.cct;
if (r == 0) {
- bufferlist::iterator it = m_children_bl.begin();
+ auto it = m_children_bl.cbegin();
r= cls_client::get_children_finish(&it, &m_children);
}
encode(trash_image_spec, bl);
}
-void ImageAddedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void ImageAddedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(image_id, iter);
decode(trash_image_spec, iter);
encode(image_id, bl);
}
-void ImageRemovedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void ImageRemovedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(image_id, iter);
}
ceph_abort();
}
-void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void UnknownPayload::dump(Formatter *f) const {
ENCODE_FINISH(bl);
}
-void NotifyMessage::decode(bufferlist::iterator& iter) {
+void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
uint32_t notify_op;
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
Payload payload;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<NotifyMessage *> &o);
if (response != nullptr) {
if (r == 0 || r == -ETIMEDOUT) {
try {
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
decode(*response, it);
} catch (const buffer::error &err) {
r = -EBADMSG;
encode(handle, bl);
}
-void ClientId::decode(bufferlist::iterator &iter) {
+void ClientId::decode(bufferlist::const_iterator &iter) {
using ceph::decode;
decode(gid, iter);
decode(handle, iter);
encode(timeouts, bl);
}
-void NotifyResponse::decode(bufferlist::iterator& iter) {
+void NotifyResponse::decode(bufferlist::const_iterator& iter) {
using ceph::decode;
decode(acks, iter);
decode(timeouts, iter);
ClientId(uint64_t gid, uint64_t handle) : gid(gid), handle(handle) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
inline bool is_valid() const {
std::vector<ClientId> timeouts;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
};
template <typename ImageCtxT>
class DecodePayloadVisitor : public boost::static_visitor<void> {
public:
- DecodePayloadVisitor(__u8 version, bufferlist::iterator &iter)
+ DecodePayloadVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {}
template <typename P>
private:
__u8 m_version;
- bufferlist::iterator &m_iter;
+ bufferlist::const_iterator &m_iter;
};
} // namespace util
#endif
}
-void decode_big_endian_string(std::string &str, bufferlist::iterator &it) {
+void decode_big_endian_string(std::string &str, bufferlist::const_iterator &it) {
using ceph::decode;
#if defined(CEPH_LITTLE_ENDIAN)
uint32_t length;
class DecodeVisitor : public boost::static_visitor<void> {
public:
- DecodeVisitor(__u8 version, bufferlist::iterator &iter)
+ DecodeVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {
}
}
private:
__u8 m_version;
- bufferlist::iterator &m_iter;
+ bufferlist::const_iterator &m_iter;
};
class DumpVisitor : public boost::static_visitor<void> {
encode(time_delta, bl);
}
-void Dependency::decode(bufferlist::iterator &it) {
+void Dependency::decode(bufferlist::const_iterator &it) {
decode(1, it);
}
-void Dependency::decode(__u8 version, bufferlist::iterator &it) {
+void Dependency::decode(__u8 version, bufferlist::const_iterator &it) {
using ceph::decode;
decode(id, it);
decode(time_delta, it);
encode(dependencies, bl);
}
-void ActionBase::decode(__u8 version, bufferlist::iterator &it) {
+void ActionBase::decode(__u8 version, bufferlist::const_iterator &it) {
using ceph::decode;
decode(id, it);
decode(thread_id, it);
encode(imagectx_id, bl);
}
-void ImageActionBase::decode(__u8 version, bufferlist::iterator &it) {
+void ImageActionBase::decode(__u8 version, bufferlist::const_iterator &it) {
using ceph::decode;
ActionBase::decode(version, it);
decode(imagectx_id, it);
encode(length, bl);
}
-void IoActionBase::decode(__u8 version, bufferlist::iterator &it) {
+void IoActionBase::decode(__u8 version, bufferlist::const_iterator &it) {
using ceph::decode;
ImageActionBase::decode(version, it);
decode(offset, it);
encode(read_only, bl);
}
-void OpenImageAction::decode(__u8 version, bufferlist::iterator &it) {
+void OpenImageAction::decode(__u8 version, bufferlist::const_iterator &it) {
using ceph::decode;
ImageActionBase::decode(version, it);
if (byte_swap_required(version)) {
encode(read_only, bl);
}
-void AioOpenImageAction::decode(__u8 version, bufferlist::iterator &it) {
+void AioOpenImageAction::decode(__u8 version, bufferlist::const_iterator &it) {
using ceph::decode;
ImageActionBase::decode(version, it);
if (byte_swap_required(version)) {
ceph_abort();
}
-void UnknownAction::decode(__u8 version, bufferlist::iterator &it) {
+void UnknownAction::decode(__u8 version, bufferlist::const_iterator &it) {
}
void UnknownAction::dump(Formatter *f) const {
ENCODE_FINISH(bl);
}
-void ActionEntry::decode(bufferlist::iterator &it) {
+void ActionEntry::decode(bufferlist::const_iterator &it) {
DECODE_START(1, it);
decode(struct_v, it);
DECODE_FINISH(it);
}
-void ActionEntry::decode_unversioned(bufferlist::iterator &it) {
+void ActionEntry::decode_unversioned(bufferlist::const_iterator &it) {
decode(0, it);
}
-void ActionEntry::decode(__u8 version, bufferlist::iterator &it) {
+void ActionEntry::decode(__u8 version, bufferlist::const_iterator &it) {
using ceph::decode;
uint8_t action_type;
decode(action_type, it);
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<Dependency *> &o);
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
static const ActionType ACTION_TYPE = static_cast<ActionType>(-1);
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &it);
- void decode_unversioned(bufferlist::iterator &it);
+ void decode(bufferlist::const_iterator &it);
+ void decode_unversioned(bufferlist::const_iterator &it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<ActionEntry *> &o);
private:
- void decode(__u8 version, bufferlist::iterator &it);
+ void decode(__u8 version, bufferlist::const_iterator &it);
};
WRITE_CLASS_ENCODER(ActionEntry);
assert(m_min_bytes <= m_max_bytes);
}
-int BufferReader::fetch(bufferlist::iterator **it) {
+int BufferReader::fetch(bufferlist::const_iterator **it) {
if (m_bl_it.get_remaining() < m_min_bytes) {
ssize_t bytes_to_read = round_up_to(m_max_bytes - m_bl_it.get_remaining(),
CEPH_PAGE_SIZE);
BufferReader(int fd, size_t min_bytes = DEFAULT_MIN_BYTES,
size_t max_bytes = DEFAULT_MAX_BYTES);
- int fetch(bufferlist::iterator **it);
+ int fetch(bufferlist::const_iterator **it);
private:
int m_fd;
size_t m_min_bytes;
size_t m_max_bytes;
bufferlist m_bl;
- bufferlist::iterator m_bl_it;
+ bufferlist::const_iterator m_bl_it;
bool m_eof_reached;
};
namespace {
bool is_versioned_replay(BufferReader &buffer_reader) {
- bufferlist::iterator *it;
+ bufferlist::const_iterator *it;
int r = buffer_reader.fetch(&it);
if (r < 0) {
return false;
while (true) {
action::ActionEntry action_entry;
try {
- bufferlist::iterator *it;
+ bufferlist::const_iterator *it;
int r = buffer_reader.fetch(&it);
if (r < 0) {
std::cerr << "Failed to read from trace file: " << cpp_strerror(r)
ASSERT_EQ(0, ioctx.omap_get_vals(group_id, "", 10, &vals));
cls::rbd::GroupImageLinkState ref_state;
- bufferlist::iterator it = vals[image_key].begin();
+ auto it = vals[image_key].cbegin();
decode(ref_state, it);
ASSERT_EQ(cls::rbd::GROUP_IMAGE_LINK_STATE_ATTACHED, ref_state);
}
ASSERT_EQ(0, ioctx.omap_get_vals(image_id, "", RBD_GROUP_REF, 10, &vals));
cls::rbd::GroupSpec val_spec;
- bufferlist::iterator it = vals[RBD_GROUP_REF].begin();
+ auto it = vals[RBD_GROUP_REF].cbegin();
decode(val_spec, it);
ASSERT_EQ(group_id, val_spec.group_id);
librbd::journal::EventEntry *event_entry) {
try {
bufferlist data_bl = replay_entry.get_data();
- bufferlist::iterator it = data_bl.begin();
+ auto it = data_bl.cbegin();
decode(*event_entry, it);
} catch (const buffer::error &err) {
return false;
bufferlist bl;
encode(event_entry, bl);
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
when_process(mock_journal_replay, &it, on_ready, on_safe);
}
void when_process(MockJournalReplay &mock_journal_replay,
- bufferlist::iterator *it, Context *on_ready,
+ bufferlist::const_iterator *it, Context *on_ready,
Context *on_safe) {
EventEntry event_entry;
int r = mock_journal_replay.decode(it, &event_entry);
encode(static_cast<uint32_t>(-1), bl);
ENCODE_FINISH(bl);
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
C_SaferCond on_ready;
C_SaferCond on_safe;
when_process(mock_journal_replay, &it, &on_ready, &on_safe);
cls_lock_lock_op op;
bufferlist bl;
bl.share(arg);
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(op, iter);
return op.type == (exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED);
}
cls_lock_set_cookie_op op;
bufferlist bl;
bl.share(arg);
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(op, iter);
return op.type == (exclusive ? LOCK_EXCLUSIVE : LOCK_SHARED);
}
try {
int op;
bufferlist payload;
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
DECODE_START(1, iter);
decode(op, iter);
iter.copy_all(payload);
}
bufferlist payload = m_notify_payloads[op];
- bufferlist::iterator iter = payload.begin();
-
+ auto iter = payload.cbegin();
+
switch (op) {
case NOTIFY_OP_FLATTEN:
{
}
MOCK_METHOD2(shut_down, void(bool cancel_ops, Context *));
- MOCK_METHOD2(decode, int(bufferlist::iterator*, EventEntry *));
+ MOCK_METHOD2(decode, int(bufferlist::const_iterator*, EventEntry *));
MOCK_METHOD3(process, void(const EventEntry&, Context *, Context *));
MOCK_METHOD2(replay_op_ready, void(uint64_t, Context *));
};
MockReplay::get_instance().shut_down(cancel_ops, on_finish);
}
- int decode(bufferlist::iterator *it, EventEntry *event_entry) {
+ int decode(bufferlist::const_iterator *it, EventEntry *event_entry) {
return MockReplay::get_instance().decode(it, event_entry);
}
std::string id;
cls::rbd::TrashImageSpec trash_image_spec;
- bufferlist::iterator bl_it = in_bl.begin();
+ auto bl_it = in_bl.cbegin();
decode(id, bl_it);
decode(trash_image_spec, bl_it);
bufferlist bl;
bl.append(buf, 4);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
uint32_t len;
decode(len, p);
if (len > max)
bufferlist bl;
bl.append(buf, sizeof(buf));
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(end_size, p);
uint64_t cur_size;
bufferlist bl;
bl.append(buf, sizeof(buf));
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
uint64_t image_offset, buffer_length;
decode(image_offset, p);
bufferlist bl;
bl.append(buf, sizeof(buf));
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(*readlen, p);
}
bufferlist bl;
bl.append(buf, sizeof(buf));
- bufferlist::iterator it;
- it = bl.begin();
+ auto it = bl.cbegin();
uint64_t val;
decode(val, it);
}
bufferlist bl;
bl.append(buf, sizeof(buf));
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
uint64_t diff_num;
decode(diff_num, p);
for (size_t i = 0; i < diff_num; i++) {
librbd::journal::EventEntry& event_entry,
bool verbose) {
try {
- bufferlist::iterator it = data.begin();
+ auto it = data.cbegin();
decode(event_entry, it);
} catch (const buffer::error &err) {
std::cerr << "failed to decode event entry: " << err.what() << std::endl;
bufferlist bl;
bl.append(buf, 8);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(*size, p);
} else {
break;
bufferlist bl;
bl.append(buf, 16);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(*offset, p);
decode(*length, p);
notify_message = NotifyMessage(HeaderUpdatePayload());
} else {
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
notify_message.decode(iter);
} catch (const buffer::error &err) {
std::cerr << "rbd: failed to decode image notification" << std::endl;
if (r == 0) {
try {
- bufferlist::iterator it = m_replay_tag.data.begin();
+ auto it = m_replay_tag.data.cbegin();
decode(m_replay_tag_data, it);
} catch (const buffer::error &err) {
r = -EBADMSG;
<< dendl;
bufferlist data = m_replay_entry.get_data();
- bufferlist::iterator it = data.begin();
+ auto it = data.cbegin();
int r = m_local_replay->decode(&it, &m_event_entry);
if (r < 0) {
derr << "failed to decode journal event" << dendl;
<< dendl;
if (r == 0) {
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
r = librbd::cls_client::mirror_instances_list_finish(&it, instance_ids);
} else if (r == -ENOENT) {
r = 0;
continue;
}
try {
- auto iter = bl.begin();
+ auto iter = bl.cbegin();
NotifyAckPayload ack;
decode(ack, iter);
if (ack.instance_id != instance_watcher->get_instance_id()) {
NotifyMessage notify_message;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(notify_message, iter);
} catch (const buffer::error &err) {
derr << "error decoding image notification: " << err.what() << dendl;
NotifyMessage notify_message;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(notify_message, iter);
} catch (const buffer::error &err) {
derr << ": error decoding image notification: " << err.what() << dendl;
m_pending_mirror_uuid = "";
if (r >= 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_uuid_get_finish(
&it, &m_pending_mirror_uuid);
}
::SnapContext snapc;
if (r == 0) {
- auto bl_it = m_out_bl.begin();
+ auto bl_it = m_out_bl.cbegin();
r = librbd::cls_client::get_snapcontext_finish(&bl_it, &snapc);
}
if (r < 0 && r != -ENOENT) {
dout(10) << "r=" << r << dendl;
if (r == 0) {
- auto bl_it = m_out_bl.begin();
+ auto bl_it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_image_id_finish(&bl_it,
&m_image_id);
}
std::map<std::string, cls::rbd::TrashImageSpec> images;
if (r >= 0) {
- auto bl_it = m_out_bl.begin();
+ auto bl_it = m_out_bl.cbegin();
r = librbd::cls_client::trash_list_finish(&bl_it, &images);
}
std::map<std::string, cls::rbd::MirrorImageMap> image_mapping;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_map_list_finish(&it, &image_mapping);
}
class DecodeVisitor : public boost::static_visitor<void> {
public:
- DecodeVisitor(__u8 version, bufferlist::iterator &iter)
+ DecodeVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {
}
}
private:
__u8 m_version;
- bufferlist::iterator &m_iter;
+ bufferlist::const_iterator &m_iter;
};
class DumpVisitor : public boost::static_visitor<void> {
ENCODE_FINISH(bl);
}
-void PolicyData::decode(bufferlist::iterator& it) {
+void PolicyData::decode(bufferlist::const_iterator& it) {
DECODE_START(1, it);
uint32_t policy_meta_type;
void encode(bufferlist& bl) const {
}
- void decode(__u8 version, bufferlist::iterator& it) {
+ void decode(__u8 version, bufferlist::const_iterator& it) {
}
void dump(Formatter *f) const {
assert(false);
}
- void decode(__u8 version, bufferlist::iterator& it) {
+ void decode(__u8 version, bufferlist::const_iterator& it) {
}
void dump(Formatter *f) const {
PolicyMetaType get_policy_meta_type() const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<PolicyData *> &o);
}
librbd::journal::ClientData client_data;
- bufferlist::iterator it = m_client.data.begin();
+ auto it = m_client.data.cbegin();
try {
decode(client_data, it);
} catch (const buffer::error &err) {
}
try {
- bufferlist::iterator it = remote_tag.data.begin();
+ auto it = remote_tag.data.cbegin();
decode(remote_tag_data, it);
remote_tag_data_valid = true;
} catch (const buffer::error &err) {
dout(20) << ": r=" << r << dendl;
if (r == 0) {
cls::rbd::MirrorImage mirror_image;
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_finish(&iter, &mirror_image);
if (r == 0) {
m_parent_global_image_id = mirror_image.global_image_id;
dout(20) << ": r=" << r << dendl;
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_image_id_finish(
&iter, &m_local_parent_spec.image_id);
}
template <typename I>
void GetMirrorImageIdRequest<I>::handle_get_image_id(int r) {
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_image_id_finish(
&iter, m_image_id);
}
cls::rbd::MirrorImage mirror_image;
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_finish(&iter, &mirror_image);
if (r == 0) {
if (mirror_image.state == cls::rbd::MIRROR_IMAGE_STATE_ENABLED) {
dout(20) << "r=" << r << dendl;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = librbd::cls_client::dir_get_name_finish(&it, m_local_image_name);
}
cls::rbd::MirrorImage mirror_image;
if (r == 0) {
- bufferlist::iterator iter = m_out_bl.begin();
+ auto iter = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_get_finish(&iter, &mirror_image);
}
template <typename I>
void PrepareRemoteImageRequest<I>::handle_get_remote_mirror_uuid(int r) {
if (r >= 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_uuid_get_finish(&it, m_remote_mirror_uuid);
if (r >= 0 && m_remote_mirror_uuid->empty()) {
r = -ENOENT;
dout(20) << dendl;
librbd::journal::ClientData client_data;
- bufferlist::iterator it = m_client.data.begin();
+ auto it = m_client.data.cbegin();
try {
decode(client_data, it);
} catch (const buffer::error &err) {
} else {
dout(20) << "retrieved tag " << master_tag_tid << ": " << m_tag << dendl;
- bufferlist::iterator it = m_tag.data.begin();
+ auto it = m_tag.data.cbegin();
try {
decode(tag_data, it);
} catch (const buffer::error &err) {
class DecodePayloadVisitor : public boost::static_visitor<void> {
public:
- DecodePayloadVisitor(__u8 version, bufferlist::iterator &iter)
+ DecodePayloadVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {}
template <typename Payload>
private:
__u8 m_version;
- bufferlist::iterator &m_iter;
+ bufferlist::const_iterator &m_iter;
};
class DumpPayloadVisitor : public boost::static_visitor<void> {
encode(request_id, bl);
}
-void PayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
+void PayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
decode(request_id, iter);
}
encode(global_image_id, bl);
}
-void ImagePayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
+void ImagePayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
PayloadBase::decode(version, iter);
decode(global_image_id, iter);
encode(peer_mirror_uuid, bl);
}
-void PeerImageRemovedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void PeerImageRemovedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
PayloadBase::decode(version, iter);
decode(global_image_id, iter);
encode(sync_id, bl);
}
-void SyncPayloadBase::decode(__u8 version, bufferlist::iterator &iter) {
+void SyncPayloadBase::decode(__u8 version, bufferlist::const_iterator &iter) {
using ceph::decode;
PayloadBase::decode(version, iter);
decode(sync_id, iter);
ceph_abort();
}
-void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void UnknownPayload::dump(Formatter *f) const {
ENCODE_FINISH(bl);
}
-void NotifyMessage::decode(bufferlist::iterator& iter) {
+void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(2, iter);
uint32_t notify_op;
encode(ret_val, bl);
}
-void NotifyAckPayload::decode(bufferlist::iterator &iter) {
+void NotifyAckPayload::decode(bufferlist::const_iterator &iter) {
using ceph::decode;
decode(instance_id, iter);
decode(request_id, iter);
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
Payload payload;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<NotifyMessage *> &o);
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
};
class DecodePayloadVisitor : public boost::static_visitor<void> {
public:
- DecodePayloadVisitor(__u8 version, bufferlist::iterator &iter)
+ DecodePayloadVisitor(__u8 version, bufferlist::const_iterator &iter)
: m_version(version), m_iter(iter) {}
template <typename Payload>
private:
__u8 m_version;
- bufferlist::iterator &m_iter;
+ bufferlist::const_iterator &m_iter;
};
class DumpPayloadVisitor : public boost::static_visitor<void> {
void HeartbeatPayload::encode(bufferlist &bl) const {
}
-void HeartbeatPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void HeartbeatPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void HeartbeatPayload::dump(Formatter *f) const {
void LockAcquiredPayload::encode(bufferlist &bl) const {
}
-void LockAcquiredPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void LockAcquiredPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void LockAcquiredPayload::dump(Formatter *f) const {
void LockReleasedPayload::encode(bufferlist &bl) const {
}
-void LockReleasedPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void LockReleasedPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void LockReleasedPayload::dump(Formatter *f) const {
ceph_abort();
}
-void UnknownPayload::decode(__u8 version, bufferlist::iterator &iter) {
+void UnknownPayload::decode(__u8 version, bufferlist::const_iterator &iter) {
}
void UnknownPayload::dump(Formatter *f) const {
ENCODE_FINISH(bl);
}
-void NotifyMessage::decode(bufferlist::iterator& iter) {
+void NotifyMessage::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
uint32_t notify_op;
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
}
void encode(bufferlist &bl) const;
- void decode(__u8 version, bufferlist::iterator &iter);
+ void decode(__u8 version, bufferlist::const_iterator &iter);
void dump(Formatter *f) const;
};
Payload payload;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<NotifyMessage *> &o);
std::map<std::string, std::string> ids;
if (r == 0) {
- bufferlist::iterator it = m_out_bl.begin();
+ auto it = m_out_bl.cbegin();
r = librbd::cls_client::mirror_image_list_finish(&it, &ids);
}
projects / ceph-ci.git / commitdiff