encode(key, bl);
encode(caps, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(a, bl);
encode(caps, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(caps, bl);
encode(flags, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
explicit AuthAuthorizer(__u32 p) : protocol(p) {}
virtual ~AuthAuthorizer() {}
- virtual bool verify_reply(bufferlist::iterator& reply) = 0;
+ virtual bool verify_reply(bufferlist::const_iterator& reply) = 0;
};
encode(key, bl);
encode(expiration, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(secrets, bl);
encode(max_ver, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
virtual void reset() = 0;
virtual void prepare_build_request() = 0;
virtual int build_request(bufferlist& bl) const = 0;
- virtual int handle_response(int ret, bufferlist::iterator& iter) = 0;
+ virtual int handle_response(int ret, bufferlist::const_iterator& iter) = 0;
virtual bool build_rotating_request(bufferlist& bl) const = 0;
virtual AuthAuthorizer *build_authorizer(uint32_t service_id) const = 0;
virtual ~AuthServiceHandler() { }
- virtual int start_session(EntityName& name, bufferlist::iterator& indata, bufferlist& result, AuthCapsInfo& caps) = 0;
- virtual int handle_request(bufferlist::iterator& indata, bufferlist& result, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) = 0;
+ virtual int start_session(EntityName& name, bufferlist::const_iterator& indata, bufferlist& result, AuthCapsInfo& caps) = 0;
+ virtual int handle_request(bufferlist::const_iterator& indata, bufferlist& result, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) = 0;
EntityName& get_entity_name() { return entity_name; }
};
bl.append(secret);
}
-void CryptoKey::decode(bufferlist::iterator& bl)
+void CryptoKey::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
decode(type, bl);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
int get_type() const { return type; }
utime_t get_created() const { return created; }
e.append(s);
bufferlist bl;
bl.decode_base64(e);
- bufferlist::iterator p = bl.begin();
+ auto p = std::cbegin(bl);
decode(p);
}
for (map<string, bufferlist>::iterator q = p->second.caps.begin();
q != p->second.caps.end();
++q) {
- bufferlist::iterator dataiter = q->second.begin();
+ auto dataiter = q->second.cbegin();
string caps;
using ceph::decode;
decode(caps, dataiter);
f->flush(bl);
}
-void KeyRing::decode_plaintext(bufferlist::iterator& bli)
+void KeyRing::decode_plaintext(bufferlist::const_iterator& bli)
{
int ret;
bufferlist bl;
}
}
-void KeyRing::decode(bufferlist::iterator& bl) {
+void KeyRing::decode(bufferlist::const_iterator& bl) {
__u8 struct_v;
- bufferlist::iterator start_pos = bl;
+ auto start_pos = bl;
try {
using ceph::decode;
decode(struct_v, bl);
}
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(iter);
}
catch (const buffer::error& err) {
for (map<string, bufferlist>::iterator q = p->second.caps.begin();
q != p->second.caps.end();
++q) {
- bufferlist::iterator dataiter = q->second.begin();
+ auto dataiter = q->second.cbegin();
string caps;
using ceph::decode;
decode(caps, dataiter);
int set_modifier(const char *type, const char *val, EntityName& name, map<string, bufferlist>& caps);
public:
- void decode_plaintext(bufferlist::iterator& bl);
+ void decode_plaintext(bufferlist::const_iterator& bl);
/* Create a KeyRing from a Ceph context.
* We will use the configuration stored inside the context. */
int from_ceph_context(CephContext *cct);
void import(CephContext *cct, KeyRing& other);
// encoders
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void encode_plaintext(bufferlist& bl);
void encode_formatted(string label, Formatter *f, bufferlist& bl);
// don't use WRITE_CLASS_ENCODER macro because we don't have an encode
// macro. don't juse encode_plaintext in that case because it is not
// wrappable; it assumes it gets the entire bufferlist.
-static inline void decode(KeyRing& kr, bufferlist::iterator& p) {
+static inline void decode(KeyRing& kr, bufferlist::const_iterator& p) {
kr.decode(p);
}
bufferlist& authorizer_data, bufferlist& authorizer_reply,
EntityName& entity_name, uint64_t& global_id, AuthCapsInfo& caps_info, CryptoKey& session_key, uint64_t *auid)
{
- bufferlist::iterator iter = authorizer_data.begin();
+ auto iter = authorizer_data.cbegin();
if (!authorizer_data.length()) {
ldout(cct, 1) << "verify authorizer, authorizer_data.length()=0" << dendl;
return need && need != CEPH_ENTITY_TYPE_MGR;
}
-int CephxClientHandler::handle_response(int ret, bufferlist::iterator& indata)
+int CephxClientHandler::handle_response(int ret, bufferlist::const_iterator& indata)
{
ldout(cct, 10) << "handle_response ret = " << ret << dendl;
RWLock::WLocker l(lock);
}
void prepare_build_request() override;
int build_request(bufferlist& bl) const override;
- int handle_response(int ret, bufferlist::iterator& iter) override;
+ int handle_response(int ret, bufferlist::const_iterator& iter) override;
bool build_rotating_request(bufferlist& bl) const override;
int get_protocol() const override { return CEPH_AUTH_CEPHX; }
for (; capsiter != mapiter->second.caps.end(); ++capsiter) {
// FIXME: need a const_iterator for bufferlist, but it doesn't exist yet.
bufferlist *bl = const_cast<bufferlist*>(&capsiter->second);
- bufferlist::iterator dataiter = bl->begin();
+ auto dataiter = bl->cbegin();
string caps;
using ceph::decode;
decode(caps, dataiter);
encode(secrets, bl);
encode(rotating_secrets, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
}
void decode_rotating(bufferlist& rotating_bl) {
using ceph::decode;
- bufferlist::iterator iter = rotating_bl.begin();
+ auto iter = rotating_bl.cbegin();
__u8 struct_v;
decode(struct_v, iter);
decode(rotating_ver, iter);
encode(auth, bl);
}
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
using ceph::encode;
encode(data, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
Mutex::Locker l(lock);
using ceph::decode;
decode(data, bl);
* this ServiceTicket with the result.
*/
bool CephXTicketHandler::verify_service_ticket_reply(CryptoKey& secret,
- bufferlist::iterator& indata)
+ bufferlist::const_iterator& indata)
{
__u8 service_ticket_v;
decode(service_ticket_v, indata);
} else {
decode(service_ticket_bl, indata);
}
- bufferlist::iterator iter = service_ticket_bl.begin();
+ auto iter = service_ticket_bl.cbegin();
decode(ticket, iter);
ldout(cct, 10) << " ticket.secret_id=" << ticket.secret_id << dendl;
* this ServiceTicket with the result.
*/
bool CephXTicketManager::verify_service_ticket_reply(CryptoKey& secret,
- bufferlist::iterator& indata)
+ bufferlist::const_iterator& indata)
{
__u8 service_ticket_reply_v;
decode(service_ticket_reply_v, indata);
* {timestamp + 1}^session_key
*/
bool cephx_verify_authorizer(CephContext *cct, KeyStore *keys,
- bufferlist::iterator& indata,
+ bufferlist::const_iterator& indata,
CephXServiceTicketInfo& ticket_info, bufferlist& reply_bl)
{
__u8 authorizer_v;
return true;
}
-bool CephXAuthorizer::verify_reply(bufferlist::iterator& indata)
+bool CephXAuthorizer::verify_reply(bufferlist::const_iterator& indata)
{
CephXAuthorizeReply reply;
encode(struct_v, bl);
encode(server_challenge, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
using ceph::encode;
encode(request_type, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(request_type, bl);
}
encode(request_type, bl);
encode(status, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(request_type, bl);
decode(status, bl);
encode(blob, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(key, bl);
encode(old_ticket, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(server_challenge, bl);
encode(client_challenge, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(server_challenge, bl);
decode(client_challenge, bl);
encode(struct_v, bl);
encode(keys, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(struct_v, bl);
encode(nonce_plus_one, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
: AuthAuthorizer(CEPH_AUTH_CEPHX), cct(cct_), nonce(0) {}
bool build_authorizer();
- bool verify_reply(bufferlist::iterator& reply) override;
+ bool verify_reply(bufferlist::const_iterator& reply) override;
};
// to build our ServiceTicket
bool verify_service_ticket_reply(CryptoKey& principal_secret,
- bufferlist::iterator& indata);
+ bufferlist::const_iterator& indata);
// to access the service
CephXAuthorizer *build_authorizer(uint64_t global_id) const;
explicit CephXTicketManager(CephContext *cct_) : global_id(0), cct(cct_) {}
bool verify_service_ticket_reply(CryptoKey& principal_secret,
- bufferlist::iterator& indata);
+ bufferlist::const_iterator& indata);
CephXTicketHandler& get_handler(uint32_t type) {
tickets_map_t::iterator i = tickets_map.find(type);
encode(session_key, bl);
encode(validity, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(ticket, bl);
encode(session_key, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
encode(struct_v, bl);
encode(nonce, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 struct_v;
decode(struct_v, bl);
* Verify authorizer and generate reply authorizer
*/
extern bool cephx_verify_authorizer(CephContext *cct, KeyStore *keys,
- bufferlist::iterator& indata,
+ bufferlist::const_iterator& indata,
CephXServiceTicketInfo& ticket_info, bufferlist& reply_bl);
if (key.decrypt(cct, bl_enc, bl, &error) < 0)
return;
- bufferlist::iterator iter2 = bl.begin();
+ auto iter2 = bl.cbegin();
__u8 struct_v;
decode(struct_v, iter2);
decode(magic, iter2);
template <typename T>
int decode_decrypt(CephContext *cct, T& t, const CryptoKey& key,
- bufferlist::iterator& iter, std::string &error)
+ bufferlist::const_iterator& iter, std::string &error)
{
bufferlist bl_enc;
try {
#undef dout_prefix
#define dout_prefix *_dout << "cephx server " << entity_name << ": "
-int CephxServiceHandler::start_session(EntityName& name, bufferlist::iterator& indata, bufferlist& result_bl, AuthCapsInfo& caps)
+int CephxServiceHandler::start_session(EntityName& name, bufferlist::const_iterator& indata, bufferlist& result_bl, AuthCapsInfo& caps)
{
entity_name = name;
return CEPH_AUTH_CEPHX;
}
-int CephxServiceHandler::handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid)
+int CephxServiceHandler::handle_request(bufferlist::const_iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid)
{
int ret = 0;
: AuthServiceHandler(cct_), key_server(ks), server_challenge(0) {}
~CephxServiceHandler() override {}
- int start_session(EntityName& name, bufferlist::iterator& indata, bufferlist& result_bl, AuthCapsInfo& caps) override;
- int handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) override;
+ int start_session(EntityName& name, bufferlist::const_iterator& indata, bufferlist& result_bl, AuthCapsInfo& caps) override;
+ int handle_request(bufferlist::const_iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) override;
void build_cephx_response_header(int request_type, int status, bufferlist& bl);
};
return -1;
}
- bufferlist::iterator ci = bl_ciphertext.begin();
+ auto ci = bl_ciphertext.cbegin();
decode(*psig, ci);
ldout(cct, 10) << __func__ << " seq " << m->get_seq()
EntityName& entity_name, uint64_t& global_id, AuthCapsInfo& caps_info, CryptoKey& session_key,
uint64_t *auid)
{
- bufferlist::iterator iter = authorizer_data.begin();
+ auto iter = authorizer_data.cbegin();
try {
__u8 struct_v = 1;
void prepare_build_request() override {}
int build_request(bufferlist& bl) const override { return 0; }
- int handle_response(int ret, bufferlist::iterator& iter) override { return 0; }
+ int handle_response(int ret, bufferlist::const_iterator& iter) override { return 0; }
bool build_rotating_request(bufferlist& bl) const override { return false; }
int get_protocol() const override { return CEPH_AUTH_NONE; }
encode(global_id, bl);
return 0;
}
- bool verify_reply(bufferlist::iterator& reply) override { return true; }
+ bool verify_reply(bufferlist::const_iterator& reply) override { return true; }
};
#endif
: AuthServiceHandler(cct_) {}
~AuthNoneServiceHandler() override {}
- int start_session(EntityName& name, bufferlist::iterator& indata, bufferlist& result_bl, AuthCapsInfo& caps) override {
+ int start_session(EntityName& name, bufferlist::const_iterator& indata, bufferlist& result_bl, AuthCapsInfo& caps) override {
entity_name = name;
caps.allow_all = true;
return CEPH_AUTH_NONE;
}
- int handle_request(bufferlist::iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) override {
+ int handle_request(bufferlist::const_iterator& indata, bufferlist& result_bl, uint64_t& global_id, AuthCapsInfo& caps, uint64_t *auid = NULL) override {
return 0;
}
void build_cephx_response_header(int request_type, int status, bufferlist& bl) { }
if (bl.read_file(dump_pg_log.c_str(), &error) >= 0) {
pg_log_entry_t e;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
while (!p.end()) {
uint64_t pos = p.get_off();
try {
if ((in->xattr_version == 0 || !(issued & CEPH_CAP_XATTR_EXCL)) &&
st->xattrbl.length() &&
st->xattr_version > in->xattr_version) {
- bufferlist::iterator p = st->xattrbl.begin();
+ auto p = st->xattrbl.cbegin();
decode(in->xattrs, p);
in->xattr_version = st->xattr_version;
}
assert(dirp);
// the extra buffer list is only set for readdir and lssnap replies
- bufferlist::iterator p = reply->get_extra_bl().begin();
+ auto p = reply->get_extra_bl().cbegin();
if (!p.end()) {
// snapdir?
if (request->head.op == CEPH_MDS_OP_LSSNAP) {
<< " is_dentry=" << (int)reply->head.is_dentry
<< dendl;
- bufferlist::iterator p = reply->get_trace_bl().begin();
+ auto p = reply->get_trace_bl().cbegin();
if (request->got_unsafe) {
ldout(cct, 10) << "insert_trace -- already got unsafe; ignoring" << dendl;
assert(p.end());
map<SnapRealm*, SnapContext> dirty_realms;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
while (!p.end()) {
SnapRealmInfo info;
decode(info, p);
if (m->head.op == CEPH_SNAP_OP_SPLIT) {
assert(m->head.split);
SnapRealmInfo info;
- bufferlist::iterator p = m->bl.begin();
+ auto p = m->bl.cbegin();
decode(info, p);
assert(info.ino() == m->head.split);
if ((issued & CEPH_CAP_XATTR_EXCL) == 0 &&
m->xattrbl.length() &&
m->head.xattr_version > in->xattr_version) {
- bufferlist::iterator p = m->xattrbl.begin();
+ auto p = m->xattrbl.cbegin();
decode(in->xattrs, p);
in->xattr_version = m->head.xattr_version;
}
if (ret == 0) {
if (op == CEPH_MDS_OP_GETFILELOCK) {
ceph_filelock filelock;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(filelock, p);
if (CEPH_LOCK_SHARED == filelock.type)
if (r == -ENOENT || existing_val_bl.length() == 0) {
set_val = true;
} else if (r >= 0) {
- bufferlist::iterator existing_p = existing_val_bl.begin();
+ auto existing_p = existing_val_bl.cbegin();
try {
A existing_val;
decode(existing_val, existing_p);
int r = 0;
// Decode `in`
- bufferlist::iterator q = in->begin();
+ auto q = in->cbegin();
AccumulateArgs args;
try {
args.decode(q);
protected:
std::string scrub_tag;
public:
- int init(bufferlist::iterator& params) override {
+ int init(bufferlist::const_iterator& params) override {
try {
InodeTagFilterArgs args;
args.decode(params);
if (!scrub_tag.empty() && xattr_data.length() > 0) {
std::string tag_ondisk;
- bufferlist::iterator q = xattr_data.begin();
+ auto q = xattr_data.cbegin();
try {
decode(tag_ondisk, q);
if (tag_ondisk == scrub_tag)
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p)
+ void decode(bufferlist::const_iterator &p)
{
DECODE_START(1, p);
decode(id, p);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl)
+ void decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(obj_xattr_name, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl)
+ void decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(scrub_tag, bl);
// Load scan_ceiling
try {
- bufferlist::iterator scan_ceiling_bl_iter = scan_ceiling_bl.begin();
+ auto scan_ceiling_bl_iter = scan_ceiling_bl.cbegin();
ObjCeiling ceiling;
ceiling.decode(scan_ceiling_bl_iter);
result->ceiling_obj_index = ceiling.id;
// Load scan_max_size
try {
- bufferlist::iterator scan_max_size_bl_iter = scan_max_size_bl.begin();
+ auto scan_max_size_bl_iter = scan_max_size_bl.cbegin();
decode(result->max_obj_size, scan_max_size_bl_iter);
} catch (const buffer::error &err) {
//dout(4) << "Invalid size attr on '" << oid << "'" << dendl;
// Load scan_max_mtime
try {
- bufferlist::iterator scan_max_mtime_bl_iter = scan_max_mtime_bl.begin();
+ auto scan_max_mtime_bl_iter = scan_max_mtime_bl.cbegin();
decode(result->max_mtime, scan_max_mtime_bl_iter);
} catch (const buffer::error &err) {
//dout(4) << "Invalid size attr on '" << oid << "'" << dendl;
// Deserialize backtrace
if (parent_bl.length()) {
try {
- bufferlist::iterator q = parent_bl.begin();
+ auto q = parent_bl.cbegin();
backtrace->decode(q);
} catch (buffer::error &e) {
//dout(4) << "Corrupt backtrace on '" << oid << "': " << e << dendl;
// Deserialize layout
if (layout_bl.length()) {
try {
- bufferlist::iterator q = layout_bl.begin();
+ auto q = layout_bl.cbegin();
decode(*layout, q);
} catch (buffer::error &e) {
return -EINVAL;
class PGLSHelloFilter : public PGLSFilter {
string val;
public:
- int init(bufferlist::iterator& params) override {
+ int init(bufferlist::const_iterator& params) override {
try {
decode(xattr, params);
decode(val, params);
}
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(*t, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode input parameters: %s", err.what());
}
cls::journal::Client client;
- bufferlist::iterator iter = val.second.begin();
+ auto iter = val.second.cbegin();
try {
decode(client, iter);
} catch (const buffer::error &err) {
for (auto &val : vals) {
cls::journal::Tag tag;
- bufferlist::iterator iter = val.second.begin();
+ auto iter = val.second.cbegin();
try {
decode(tag, iter);
} catch (const buffer::error &err) {
for (std::map<std::string, bufferlist>::iterator it = vals.begin();
it != vals.end(); ++it) {
try {
- bufferlist::iterator iter = it->second.begin();
+ auto iter = it->second.cbegin();
cls::journal::Client client;
decode(client, iter);
uint8_t splay_width;
int64_t pool_id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(order, iter);
decode(splay_width, iter);
decode(pool_id, iter);
bufferlist *out) {
uint64_t object_set;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(object_set, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode input parameters: %s", err.what());
bufferlist *out) {
uint64_t object_set;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(object_set, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode input parameters: %s", err.what());
bufferlist *out) {
std::string id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode input parameters: %s", err.what());
std::string id;
bufferlist data;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
decode(data, iter);
} catch (const buffer::error &err) {
std::string id;
bufferlist data;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
decode(data, iter);
} catch (const buffer::error &err) {
cls::journal::ClientState state;
bufferlist data;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
uint8_t state_raw;
decode(state_raw, iter);
bufferlist *out) {
std::string id;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode input parameters: %s", err.what());
std::string id;
cls::journal::ObjectSetPosition commit_position;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(id, iter);
decode(commit_position, iter);
} 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) {
bufferlist *out) {
uint64_t tag_tid;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(tag_tid, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode input parameters: %s", err.what());
uint64_t tag_class;
bufferlist data;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(tag_tid, iter);
decode(tag_class, iter);
decode(data, iter);
// handle compiler false positive about use-before-init
tag_class = boost::none;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(start_after_tag_tid, iter);
decode(max_return, iter);
decode(client_id, iter);
for (auto &val : vals) {
cls::journal::Tag tag;
- bufferlist::iterator iter = val.second.begin();
+ auto iter = val.second.cbegin();
try {
decode(tag, iter);
} catch (const buffer::error &err) {
bufferlist *out) {
uint64_t soft_max_size;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(soft_max_size, iter);
} catch (const buffer::error &err) {
CLS_ERR("failed to decode input parameters: %s", err.what());
}
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
std::set<cls::journal::Client> partial_clients;
decode(partial_clients, iter);
void finish(int r) override {
if (r == 0) {
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(*order, iter);
decode(*splay_width, iter);
decode(*pool_id, iter);
void finish(int r) override {
if (r == 0) {
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(*minimum_set, iter);
decode(*active_set, iter);
client_list->send("");
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = get_client_finish(&iter, client);
if (r < 0) {
return r;
op->exec("journal", "get_client", bl);
}
-int get_client_finish(bufferlist::iterator *iter,
+int get_client_finish(bufferlist::const_iterator *iter,
cls::journal::Client *client) {
try {
decode(*client, *iter);
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = get_next_tag_tid_finish(&iter, tag_tid);
if (r < 0) {
return r;
op->exec("journal", "get_next_tag_tid", bl);
}
-int get_next_tag_tid_finish(bufferlist::iterator *iter,
+int get_next_tag_tid_finish(bufferlist::const_iterator *iter,
uint64_t *tag_tid) {
try {
decode(*tag_tid, *iter);
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = get_tag_finish(&iter, tag);
if (r < 0) {
return r;
op->exec("journal", "get_tag", bl);
}
-int get_tag_finish(bufferlist::iterator *iter, cls::journal::Tag *tag) {
+int get_tag_finish(bufferlist::const_iterator *iter, cls::journal::Tag *tag) {
try {
decode(*tag, *iter);
} catch (const buffer::error &err) {
return r;
}
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
std::set<cls::journal::Tag> decode_tags;
r = tag_list_finish(&iter, &decode_tags);
if (r < 0) {
op->exec("journal", "tag_list", bl);
}
-int tag_list_finish(bufferlist::iterator *iter,
+int tag_list_finish(bufferlist::const_iterator *iter,
std::set<cls::journal::Tag> *tags) {
try {
decode(*tags, *iter);
const std::string &id, cls::journal::Client *client);
void get_client_start(librados::ObjectReadOperation *op,
const std::string &id);
-int get_client_finish(bufferlist::iterator *iter,
+int get_client_finish(bufferlist::const_iterator *iter,
cls::journal::Client *client);
int client_register(librados::IoCtx &ioctx, const std::string &oid,
int get_next_tag_tid(librados::IoCtx &ioctx, const std::string &oid,
uint64_t *tag_tid);
void get_next_tag_tid_start(librados::ObjectReadOperation *op);
-int get_next_tag_tid_finish(bufferlist::iterator *iter,
+int get_next_tag_tid_finish(bufferlist::const_iterator *iter,
uint64_t *tag_tid);
int get_tag(librados::IoCtx &ioctx, const std::string &oid,
uint64_t tag_tid, cls::journal::Tag *tag);
void get_tag_start(librados::ObjectReadOperation *op,
uint64_t tag_tid);
-int get_tag_finish(bufferlist::iterator *iter, cls::journal::Tag *tag);
+int get_tag_finish(bufferlist::const_iterator *iter, cls::journal::Tag *tag);
int tag_create(librados::IoCtx &ioctx, const std::string &oid,
uint64_t tag_tid, uint64_t tag_class,
uint64_t start_after_tag_tid, uint64_t max_return,
const std::string &client_id,
boost::optional<uint64_t> tag_class);
-int tag_list_finish(bufferlist::iterator *iter,
+int tag_list_finish(bufferlist::const_iterator *iter,
std::set<cls::journal::Tag> *tags);
// journal entry helpers
ENCODE_FINISH(bl);
}
-void ObjectPosition::decode(bufferlist::iterator& iter) {
+void ObjectPosition::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
decode(object_number, iter);
decode(tag_tid, iter);
ENCODE_FINISH(bl);
}
-void ObjectSetPosition::decode(bufferlist::iterator& iter) {
+void ObjectSetPosition::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
decode(object_positions, iter);
DECODE_FINISH(iter);
ENCODE_FINISH(bl);
}
-void Client::decode(bufferlist::iterator& iter) {
+void Client::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
decode(id, iter);
decode(data, iter);
ENCODE_FINISH(bl);
}
-void Tag::decode(bufferlist::iterator& iter) {
+void Tag::decode(bufferlist::const_iterator& iter) {
DECODE_START(1, iter);
decode(tid, iter);
decode(tag_class, iter);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& iter);
+ void decode(bufferlist::const_iterator& iter);
void dump(Formatter *f) const;
inline bool operator<(const ObjectPosition &rhs) const {
: object_positions(_object_positions) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& iter);
+ void decode(bufferlist::const_iterator& iter);
void dump(Formatter *f) const;
inline bool operator==(const ObjectSetPosition &rhs) const {
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& iter);
+ void decode(bufferlist::const_iterator& iter);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<Client *> &o);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& iter);
+ void decode(bufferlist::const_iterator& iter);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<Tag *> &o);
}
try {
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
decode(*lock, it);
} catch (const buffer::error &err) {
CLS_ERR("error decoding %s", key.c_str());
CLS_LOG(20, "lock_op");
cls_lock_lock_op op;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error &err) {
return -EINVAL;
CLS_LOG(20, "unlock_op");
cls_lock_unlock_op op;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error& err) {
return -EINVAL;
CLS_LOG(20, "break_lock");
cls_lock_break_op op;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error& err) {
return -EINVAL;
CLS_LOG(20, "get_info");
cls_lock_get_info_op op;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error& err) {
return -EINVAL;
cls_lock_assert_op op;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error& err) {
return -EINVAL;
cls_lock_set_cookie_op op;
try {
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error& err) {
return -EINVAL;
return r;
cls_lock_list_locks_reply ret;
- bufferlist::iterator iter = out.begin();
+ auto iter = cbegin(out);
try {
decode(ret, iter);
} catch (buffer::error& err) {
rados_op->exec("lock", "get_info", in);
}
- int get_lock_info_finish(bufferlist::iterator *iter,
+ int get_lock_info_finish(bufferlist::const_iterator *iter,
map<locker_id_t, locker_info_t> *lockers,
ClsLockType *type, string *tag)
{
int r = ioctx->operate(oid, &op, &out);
if (r < 0)
return r;
- bufferlist::iterator it = out.begin();
+ auto it = std::cbegin(out);
return get_lock_info_finish(&it, lockers, type, tag);
}
list<std::string> *locks);
extern void get_lock_info_start(librados::ObjectReadOperation *rados_op,
const std::string& name);
- extern int get_lock_info_finish(ceph::bufferlist::iterator *out,
+ extern int get_lock_info_finish(ceph::bufferlist::const_iterator *out,
map<locker_id_t, locker_info_t> *lockers,
ClsLockType *type, std::string *tag);
encode(flags, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(name, bl);
uint8_t t;
encode(cookie, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(name, bl);
decode(cookie, bl);
encode(cookie, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(name, bl);
decode(locker, bl);
encode(name, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(name, bl);
DECODE_FINISH(bl);
encode(tag, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(lockers, bl);
uint8_t t;
encode(locks, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(locks, bl);
DECODE_FINISH(bl);
encode(tag, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(name, bl);
uint8_t t;
encode(new_cookie, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(name, bl);
uint8_t t;
encode(cookie, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(locker, bl);
decode(cookie, bl);
encode(description, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(expiration, bl);
decode(addr, bl);
encode(tag, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, bl);
decode(lockers, bl);
uint8_t t;
return 0;
}
- bufferlist::iterator iter = header_bl.begin();
+ auto iter = header_bl.cbegin();
try {
decode(header, iter);
} catch (buffer::error& err) {
static int cls_log_add(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_log_add_op op;
try {
static int cls_log_list(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_log_list_op op;
try {
}
bufferlist& bl = iter->second;
- bufferlist::iterator biter = bl.begin();
+ auto biter = bl.cbegin();
try {
cls_log_entry e;
decode(e, biter);
static int cls_log_trim(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_log_trim_op op;
try {
static int cls_log_info(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_log_info_op op;
try {
if (r >= 0) {
cls_log_list_ret ret;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(ret, iter);
if (entries)
*entries = std::move(ret.entries);
if (r >= 0) {
cls_log_info_ret ret;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(ret, iter);
if (header)
*header = ret.header;
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(entries, bl);
if (struct_v >= 2) {
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(from_time, bl);
decode(marker, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
decode(marker, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(from_time, bl);
decode(to_time, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
// currently empty request
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(header, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(section, bl);
decode(name, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(max_marker, bl);
decode(max_time, bl);
cls_lua_eval_op op;
try {
- bufferlist::iterator it = ctx->inbl->begin();
+ auto it = ctx->inbl->cbegin();
decode(op, it);
} catch (const buffer::error &err) {
CLS_ERR("error: could not decode ceph encoded input");
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(script, bl);
decode(handler, bl);
{
string key, diff_str;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(key, iter);
decode(diff_str, iter);
{
string key, diff_str;
- bufferlist::iterator iter = in->begin();
+ auto iter = in->cbegin();
try {
decode(key, iter);
decode(diff_str, iter);
encode(ids, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(ids, bl);
DECODE_FINISH(bl);
encode(last_success, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(otp, bl);
decode(last_checks, bl);
}
try {
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
decode(*instance, it);
} catch (const buffer::error &err) {
CLS_ERR("ERROR: failed to decode %s", key.c_str());
return 0;
}
- auto iter = bl.begin();
+ auto iter = bl.cbegin();
try {
decode(*h, iter);
} catch (buffer::error& err) {
CLS_LOG(20, "%s", __func__);
cls_otp_set_otp_op op;
try {
- auto iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error &err) {
CLS_ERR("ERROR: %s(): failed to decode request", __func__);
CLS_LOG(20, "%s", __func__);
cls_otp_remove_otp_op op;
try {
- auto iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error &err) {
CLS_ERR("ERROR: %s(): failed to decode request", __func__);
CLS_LOG(20, "%s", __func__);
cls_otp_get_otp_op op;
try {
- auto iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error &err) {
CLS_ERR("ERROR: %s(): failed to decode request", __func__);
CLS_LOG(20, "%s", __func__);
cls_otp_check_otp_op op;
try {
- auto iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error &err) {
CLS_ERR("ERROR: %s(): failed to decode request", __func__);
CLS_LOG(20, "%s", __func__);
cls_otp_check_otp_op op;
try {
- auto iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error &err) {
CLS_ERR("ERROR: %s(): failed to decode request", __func__);
CLS_LOG(20, "%s", __func__);
cls_otp_get_current_time_op op;
try {
- auto iter = in->begin();
+ auto iter = in->cbegin();
decode(op, iter);
} catch (const buffer::error &err) {
CLS_ERR("ERROR: %s(): failed to decode request", __func__);
return r;
}
- auto iter = out.begin();
+ auto iter = out.cbegin();
cls_otp_get_result_reply ret;
try {
decode(ret, iter);
}
cls_otp_get_otp_reply ret;
- auto iter = out.begin();
+ auto iter = out.cbegin();
try {
decode(ret, iter);
} catch (buffer::error& err) {
}
cls_otp_get_current_time_reply ret;
- auto iter = out.begin();
+ auto iter = out.cbegin();
try {
decode(ret, iter);
} catch (buffer::error& err) {
encode(entries, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(entries, bl);
DECODE_FINISH(bl);
encode(token, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(id, bl);
decode(val, bl);
encode(token, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(token, bl);
DECODE_FINISH(bl);
encode(result, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(result, bl);
DECODE_FINISH(bl);
encode(ids, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(ids, bl);
DECODE_FINISH(bl);
encode(ids, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(get_all, bl);
decode(ids, bl);
encode(found_entries, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(found_entries, bl);
DECODE_FINISH(bl);
ENCODE_START(1, 1, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
DECODE_FINISH(bl);
}
encode(time, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(time, bl);
DECODE_FINISH(bl);
encode(window, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
uint8_t t;
decode(t, bl);
encode((char)result, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(token, bl);
decode(timestamp, bl);
encode(entries, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(entries, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(refs, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(refs, bl);
if (struct_v >= 2) {
return ret;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(*objr, iter);
} catch (buffer::error& err) {
CLS_LOG(0, "ERROR: read_refcount(): failed to decode refcount entry\n");
static int cls_rc_refcount_get(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_refcount_get_op op;
try {
static int cls_rc_refcount_put(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_refcount_put_op op;
try {
static int cls_rc_refcount_set(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_refcount_set_op op;
try {
static int cls_rc_refcount_read(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_refcount_read_op op;
try {
return ret;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(*objr, iter);
} catch (buffer::error& err) {
CLS_LOG(0, "ERROR: chunk_read_refcount(): failed to decode refcount entry\n");
static int cls_rc_chunk_refcount_get(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_chunk_refcount_get_op op;
try {
static int cls_rc_chunk_refcount_put(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_chunk_refcount_put_op op;
try {
static int cls_rc_chunk_refcount_set(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_chunk_refcount_set_op op;
try {
cls_refcount_read_ret ret;
try {
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
decode(ret, iter);
} catch (buffer::error& err) {
return -EIO;
cls_chunk_refcount_read_ret ret;
try {
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
decode(ret, iter);
} catch (buffer::error& err) {
return -EIO;
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(tag, bl);
decode(implicit_ref, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(tag, bl);
decode(implicit_ref, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(refs, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(implicit_ref, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(refs, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(source, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(source, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(refs, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(refs, bl);
DECODE_FINISH(bl);
return rc;
}
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(entry, iter);
} catch (buffer::error& err) {
CLS_LOG(0, "ERROR: failed to decode entry %s", obj_index.c_str());
static int cls_statelog_add(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_statelog_add_op op;
try {
static int cls_statelog_list(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_statelog_list_op op;
try {
marker = index;
bufferlist& bl = iter->second;
- bufferlist::iterator biter = bl.begin();
+ auto biter = bl.cbegin();
try {
cls_statelog_entry e;
decode(e, biter);
static int cls_statelog_remove(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_statelog_remove_op op;
try {
static int cls_statelog_check_state(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_statelog_check_state_op op;
try {
if (r >= 0) {
cls_statelog_list_ret ret;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(ret, iter);
if (entries)
*entries = ret.entries;
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(object, bl);
decode(client_id, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
decode(marker, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(client_id, bl);
decode(op_id, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(client_id, bl);
decode(op_id, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(client_id, bl);
decode(op_id, bl);
bufferlist * const in,
bufferlist * const out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_timeindex_add_op op;
try {
bufferlist * const in,
bufferlist * const out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_timeindex_list_op op;
try {
bufferlist * const in,
bufferlist * const out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_timeindex_trim_op op;
try {
if (r >= 0) {
cls_timeindex_list_ret ret;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(ret, iter);
if (entries)
*entries = ret.entries;
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(from_time, bl);
decode(marker, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
decode(marker, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(from_time, bl);
decode(to_time, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(key_ts, bl);
decode(key_ext, bl);
return rc;
}
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(entry, iter);
} catch (buffer::error& err) {
CLS_LOG(0, "ERROR: failed to decode entry %s", key.c_str());
static int cls_user_set_buckets_info(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_user_set_buckets_op op;
try {
static int cls_user_complete_stats_sync(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_user_complete_stats_sync_op op;
try {
static int cls_user_remove_bucket(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_user_remove_bucket_op op;
try {
static int cls_user_list_buckets(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_user_list_buckets_op op;
try {
}
bufferlist& bl = iter->second;
- bufferlist::iterator biter = bl.begin();
+ auto biter = bl.cbegin();
try {
cls_user_bucket_entry e;
decode(e, biter);
static int cls_user_get_header(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_user_get_header_op op;
try {
cls_user_reset_stats_op op;
try {
- auto bliter = in->begin();
+ auto bliter = in->cbegin();
decode(op, bliter);
} catch (buffer::error& err) {
CLS_LOG(0, "ERROR: cls_user_reset_op(): failed to decode op");
cls_user_bucket_entry e;
try {
auto bl = kv.second;
- auto bliter = bl.begin();
+ auto bliter = bl.cbegin();
decode(e, bliter);
} catch (buffer::error& err) {
CLS_LOG(0, "ERROR: failed to decode bucket entry for %s", kv.first.c_str());
if (r >= 0) {
cls_user_list_buckets_ret ret;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(ret, iter);
if (entries)
*entries = ret.entries;
if (r >= 0) {
cls_user_get_header_ret ret;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(ret, iter);
if (header)
*header = ret.header;
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
decode(add, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(bucket, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(marker, bl);
decode(max_entries, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
decode(marker, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
DECODE_FINISH(bl);
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(time, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(header, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(time, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(8, 3, 3, bl);
decode(name, bl);
if (struct_v < 8) {
//::encode(placement_rule, bl); removed in v9
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(9, 5, 5, bl);
__u32 mt;
uint64_t s;
encode(total_bytes_rounded, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(total_entries, bl);
decode(total_bytes, bl);
encode(last_stats_update, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(stats, bl);
decode(last_stats_sync, bl);
return ret;
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(*objv, iter);
} catch (buffer::error& err) {
CLS_LOG(0, "ERROR: read_version(): failed to decode version entry\n");
static int cls_version_set(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_version_set_op op;
try {
static int cls_version_inc(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_version_inc_op op;
try {
static int cls_version_check(cls_method_context_t hctx, bufferlist *in, bufferlist *out)
{
- bufferlist::iterator in_iter = in->begin();
+ auto in_iter = in->cbegin();
cls_version_check_op op;
try {
if (r >= 0) {
cls_version_read_ret ret;
try {
- bufferlist::iterator iter = outbl.begin();
+ auto iter = outbl.cbegin();
decode(ret, iter);
*objv = ret.objv;
} catch (buffer::error& err) {
cls_version_read_ret ret;
try {
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
decode(ret, iter);
} catch (buffer::error& err) {
return -EIO;
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(objv, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(objv, bl);
decode(conds, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(objv, bl);
decode(conds, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(objv, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(ver, bl);
decode(tag, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(ver, bl);
uint32_t c;
ENCODE_FINISH(bl);
}
-void DecayCounter::decode(const utime_t &t, bufferlist::iterator &p)
+void DecayCounter::decode(const utime_t &t, bufferlist::const_iterator &p)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 4, 4, p);
if (struct_v < 2) {
DecayRate rate;
void encode(bufferlist& bl) const;
- void decode(const utime_t &t, bufferlist::iterator& p);
+ void decode(const utime_t &t, bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<DecayCounter*>& ls);
// these two functions are for the use of our dencoder testing infrastructure
DecayCounter() : val(0), delta(0), vel(0), last_decay() {}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
utime_t fake_time;
decode(fake_time, p);
}
};
inline void encode(const DecayCounter &c, bufferlist &bl) { c.encode(bl); }
-inline void decode(DecayCounter &c, const utime_t &t, bufferlist::iterator &p) {
+inline void decode(DecayCounter &c, const utime_t &t, bufferlist::const_iterator &p) {
c.decode(t, p);
}
// for dencoder
-inline void decode(DecayCounter &c, bufferlist::iterator &p) {
+inline void decode(DecayCounter &c, bufferlist::const_iterator &p) {
utime_t t;
c.decode(t, p);
}
encode(seq, bl);
}
-void LogEntryKey::decode(bufferlist::iterator& bl)
+void LogEntryKey::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
decode(who, bl);
ENCODE_FINISH(bl);
}
-void LogEntry::decode(bufferlist::iterator& bl)
+void LogEntry::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
__u16 t;
ENCODE_FINISH(bl);
}
-void LogSummary::decode(bufferlist::iterator& bl)
+void LogSummary::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(version, bl);
}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<LogEntryKey*>& o);
void log_to_syslog(string level, string facility);
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<LogEntry*>& o);
static clog_type str_to_level(std::string const &str);
}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<LogSummary*>& o);
};
ENCODE_FINISH(bl);
}
-void SloppyCRCMap::decode(bufferlist::iterator& bl)
+void SloppyCRCMap::decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
uint32_t bs;
int read(uint64_t offset, uint64_t len, const bufferlist& bl, std::ostream *err);
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<SloppyCRCMap*>& ls);
};
ConstReference operator[](uint64_t offset) const;
void encode_header(bufferlist& bl) const;
- void decode_header(bufferlist::iterator& it);
+ void decode_header(bufferlist::const_iterator& it);
uint64_t get_header_length() const;
void encode_data(bufferlist& bl, uint64_t byte_offset,
uint64_t byte_length) const;
- void decode_data(bufferlist::iterator& it, uint64_t byte_offset);
+ void decode_data(bufferlist::const_iterator& it, uint64_t byte_offset);
void get_data_extents(uint64_t offset, uint64_t length,
uint64_t *byte_offset, uint64_t *byte_length) const;
void encode_footer(bufferlist& bl) const;
- void decode_footer(bufferlist::iterator& it);
+ void decode_footer(bufferlist::const_iterator& it);
uint64_t get_footer_offset() const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& it);
+ void decode(bufferlist::const_iterator& it);
void dump(Formatter *f) const;
bool operator==(const BitVector &b) const;
}
template <uint8_t _b>
-void BitVector<_b>::decode_header(bufferlist::iterator& it) {
+void BitVector<_b>::decode_header(bufferlist::const_iterator& it) {
using ceph::decode;
bufferlist header_bl;
decode(header_bl, it);
- bufferlist::iterator header_it = header_bl.begin();
+ auto header_it = header_bl.cbegin();
uint64_t size;
DECODE_START(1, header_it);
decode(size, header_it);
}
template <uint8_t _b>
-void BitVector<_b>::decode_data(bufferlist::iterator& it, uint64_t byte_offset) {
+void BitVector<_b>::decode_data(bufferlist::const_iterator& it, uint64_t byte_offset) {
assert(byte_offset % BLOCK_SIZE == 0);
if (it.end()) {
return;
}
template <uint8_t _b>
-void BitVector<_b>::decode_footer(bufferlist::iterator& it) {
+void BitVector<_b>::decode_footer(bufferlist::const_iterator& it) {
using ceph::decode;
bufferlist footer_bl;
decode(footer_bl, it);
m_crc_enabled = (footer_bl.length() > 0);
if (m_crc_enabled) {
- bufferlist::iterator footer_it = footer_bl.begin();
+ auto footer_it = footer_bl.cbegin();
__u32 header_crc;
decode(header_crc, footer_it);
}
template <uint8_t _b>
-void BitVector<_b>::decode(bufferlist::iterator& it) {
+void BitVector<_b>::decode(bufferlist::const_iterator& it) {
decode_header(it);
bufferlist data_bl;
decode_footer(it);
- bufferlist::iterator data_it = data_bl.begin();
+ auto data_it = data_bl.cbegin();
decode_data(data_it, 0);
}
ENCODE_FINISH(bl);
}
-void bloom_filter::decode(bufferlist::iterator& p)
+void bloom_filter::decode(bufferlist::const_iterator& p)
{
DECODE_START(2, p);
uint64_t v;
ENCODE_FINISH(bl);
}
-void compressible_bloom_filter::decode(bufferlist::iterator& p)
+void compressible_bloom_filter::decode(bufferlist::const_iterator& p)
{
DECODE_START(2, p);
bloom_filter::decode(p);
public:
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<bloom_filter*>& ls);
};
std::vector<std::size_t> size_list;
public:
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<compressible_bloom_filter*>& ls);
};
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
uint8_t t;
decode(t, bl);
encode(type, bl);
encode(id, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
uint32_t type_;
std::string id_;
ENCODE_FINISH(bl);
}
-void file_layout_t::decode(bufferlist::iterator& p)
+void file_layout_t::decode(bufferlist::const_iterator& p)
{
using ceph::decode;
if (*p == 0) {
ENCODE_FINISH(bl);
}
-void pow2_hist_t::decode(bufferlist::iterator& p)
+void pow2_hist_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(h, p);
void dump(Formatter *f) const;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
static void generate_test_instances(std::list<pow2_hist_t*>& o);
};
WRITE_CLASS_ENCODER(pow2_hist_t)
ENCODE_FINISH(bl);
}
-void hobject_t::decode(bufferlist::iterator& bl)
+void hobject_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 3, 3, bl);
if (struct_v >= 1)
return r;
}
-void ghobject_t::decode(bufferlist::iterator& bl)
+void ghobject_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, bl);
if (struct_v >= 1)
bool parse(const string& s);
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void decode(json_spirit::Value& v);
void dump(Formatter *f) const;
static void generate_test_instances(list<hobject_t*>& o);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void decode(json_spirit::Value& v);
size_t encoded_size() const;
void dump(Formatter *f) const;
}
return r;
}
- bufferlist::iterator p = object_data.begin();
+ auto p = object_data.cbegin();
decode(*object_size, p);
decode(*num_objects, p);
decode(*prevPid, p);
ENCODE_FINISH(bl);
}
-void object_id_wrapper::decode(bufferlist::iterator& bp)
+void object_id_wrapper::decode(bufferlist::const_iterator& bp)
{
DECODE_START(1, bp);
decode(name, bp);
ENCODE_FINISH(bl);
}
-void osd_shard_wrapper::decode(bufferlist::iterator& bp)
+void osd_shard_wrapper::decode(bufferlist::const_iterator& bp)
{
DECODE_START(1, bp);
decode(osd, bp);
ENCODE_FINISH(bl);
}
-void shard_info_wrapper::decode(bufferlist::iterator& bp)
+void shard_info_wrapper::decode(bufferlist::const_iterator& bp)
{
DECODE_START(3, bp);
decode(errors, bp);
ENCODE_FINISH(bl);
}
-void inconsistent_obj_wrapper::decode(bufferlist::iterator& bp)
+void inconsistent_obj_wrapper::decode(bufferlist::const_iterator& bp)
{
DECODE_START(2, bp);
DECODE_OLDEST(2);
ENCODE_FINISH(bl);
}
-void inconsistent_snapset_wrapper::decode(bufferlist::iterator& bp)
+void inconsistent_snapset_wrapper::decode(bufferlist::const_iterator& bp)
{
DECODE_START(2, bp);
decode(errors, bp);
ENCODE_FINISH(bl);
}
-void scrub_ls_arg_t::decode(bufferlist::iterator& bp)
+void scrub_ls_arg_t::decode(bufferlist::const_iterator& bp)
{
DECODE_START(1, bp);
decode(interval, bp);
ENCODE_FINISH(bl);
}
-void scrub_ls_result_t::decode(bufferlist::iterator& bp)
+void scrub_ls_result_t::decode(bufferlist::const_iterator& bp)
{
DECODE_START(1, bp);
decode(interval, bp);
: object_id_t{hoid.oid.name, hoid.nspace, hoid.get_key(), hoid.snap}
{}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
};
WRITE_CLASS_ENCODER(object_id_wrapper)
namespace librados {
-inline void decode(object_id_t& obj, bufferlist::iterator& bp) {
+inline void decode(object_id_t& obj, bufferlist::const_iterator& bp) {
reinterpret_cast<object_id_wrapper&>(obj).decode(bp);
}
}
struct osd_shard_wrapper : public librados::osd_shard_t {
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bp);
+ void decode(bufferlist::const_iterator& bp);
};
WRITE_CLASS_ENCODER(osd_shard_wrapper)
namespace librados {
- inline void decode(librados::osd_shard_t& shard, bufferlist::iterator& bp) {
+ inline void decode(librados::osd_shard_t& shard, bufferlist::const_iterator& bp) {
reinterpret_cast<osd_shard_wrapper&>(shard).decode(bp);
}
}
errors |= err_t::HINFO_CORRUPTED;
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bp);
+ void decode(bufferlist::const_iterator& bp);
};
WRITE_CLASS_ENCODER(shard_info_wrapper)
namespace librados {
inline void decode(librados::shard_info_t& shard,
- bufferlist::iterator& bp) {
+ bufferlist::const_iterator& bp) {
reinterpret_cast<shard_info_wrapper&>(shard).decode(bp);
}
}
const pg_shard_t &primary);
void set_version(uint64_t ver) { version = ver; }
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bp);
+ void decode(bufferlist::const_iterator& bp);
};
WRITE_CLASS_ENCODER(inconsistent_obj_wrapper)
inline void decode(librados::inconsistent_obj_t& obj,
- bufferlist::iterator& bp) {
+ bufferlist::const_iterator& bp) {
reinterpret_cast<inconsistent_obj_wrapper&>(obj).decode(bp);
}
void set_size_mismatch();
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bp);
+ void decode(bufferlist::const_iterator& bp);
};
WRITE_CLASS_ENCODER(inconsistent_snapset_wrapper)
namespace librados {
inline void decode(librados::inconsistent_snapset_t& snapset,
- bufferlist::iterator& bp) {
+ bufferlist::const_iterator& bp) {
reinterpret_cast<inconsistent_snapset_wrapper&>(snapset).decode(bp);
}
}
librados::object_id_t start_after;
uint64_t max_return;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
};
WRITE_CLASS_ENCODER(scrub_ls_arg_t);
epoch_t interval;
std::vector<bufferlist> vals;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
};
WRITE_CLASS_ENCODER(scrub_ls_result_t);
encode_nohead(prior_parent_snaps, bl);
}
-void SnapRealmInfo::decode(bufferlist::iterator& bl)
+void SnapRealmInfo::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
decode(h, bl);
snapid_t created() const { return snapid_t(h.created); }
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<SnapRealmInfo*>& o);
};
encode(seq, bl);
encode(snaps, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(seq, bl);
decode(snaps, bl);
}
static void decode_nohead(size_t len, value_type& s,
- buffer::ptr::iterator& p)
+ buffer::ptr::const_iterator& p)
{
s.reset();
if (len) {
}
static void decode(value_type& s,
- buffer::ptr::iterator& p,
+ buffer::ptr::const_iterator& p,
uint64_t f=0)
{
Size len;
encode(b.parent_span_id, bl);
}
-static inline void decode(blkin_trace_info& b, bufferlist::iterator& p)
+static inline void decode(blkin_trace_info& b, bufferlist::const_iterator& p)
{
decode(b.trace_id, p);
decode(b.span_id, p);
virtual int decompress(const ceph::bufferlist &in, ceph::bufferlist &out) = 0;
// this is a bit weird but we need non-const iterator to be in
// alignment with decode methods
- virtual int decompress(ceph::bufferlist::iterator &p, size_t compressed_len, ceph::bufferlist &out) = 0;
+ virtual int decompress(ceph::bufferlist::const_iterator &p, size_t compressed_len, ceph::bufferlist &out) = 0;
static CompressorRef create(CephContext *cct, const std::string &type);
static CompressorRef create(CephContext *cct, int alg);
return 0;
}
-int BrotliCompressor::decompress(bufferlist::iterator &p,
+int BrotliCompressor::decompress(bufferlist::const_iterator &p,
size_t compressed_size,
bufferlist &out)
{
int compress(const bufferlist &in, bufferlist &out) override;
int decompress(const bufferlist &in, bufferlist &out) override;
- int decompress(bufferlist::iterator &p, size_t compressed_len, bufferlist &out) override;
+ int decompress(bufferlist::const_iterator &p, size_t compressed_len, bufferlist &out) override;
};
#endif //CEPH_BROTLICOMPRESSOR_H
if (qat_enabled)
return qat_accel.decompress(src, dst);
#endif
- bufferlist::iterator i = const_cast<bufferlist&>(src).begin();
+ auto i = std::cbegin(src);
return decompress(i, src.length(), dst);
}
- int decompress(bufferlist::iterator &p,
+ int decompress(bufferlist::const_iterator &p,
size_t compressed_len,
bufferlist &dst) override {
#ifdef HAVE_QATZIP
#include "include/buffer.h"
class CEPH_BUFFER_API BufferlistSource : public snappy::Source {
- bufferlist::iterator pb;
+ bufferlist::const_iterator pb;
size_t remaining;
public:
- explicit BufferlistSource(bufferlist::iterator _pb, size_t _input_len)
+ explicit BufferlistSource(bufferlist::const_iterator _pb, size_t _input_len)
: pb(_pb),
remaining(_input_len) {
remaining = std::min(remaining, (size_t)pb.get_remaining());
remaining -= n;
}
- bufferlist::iterator get_pos() const {
+ bufferlist::const_iterator get_pos() const {
return pb;
}
};
if (qat_enabled)
return qat_accel.decompress(src, dst);
#endif
- bufferlist::iterator i = const_cast<bufferlist&>(src).begin();
+ auto i = src.begin();
return decompress(i, src.length(), dst);
}
- int decompress(bufferlist::iterator &p,
+ int decompress(bufferlist::const_iterator &p,
size_t compressed_len,
bufferlist &dst) override {
#ifdef HAVE_QATZIP
#endif
}
-int ZlibCompressor::decompress(bufferlist::iterator &p, size_t compressed_size, bufferlist &out)
+int ZlibCompressor::decompress(bufferlist::const_iterator &p, size_t compressed_size, bufferlist &out)
{
#ifdef HAVE_QATZIP
if (qat_enabled)
if (qat_enabled)
return qat_accel.decompress(in, out);
#endif
- bufferlist::iterator i = const_cast<bufferlist&>(in).begin();
+ auto i = std::cbegin(in);
return decompress(i, in.length(), out);
}
int compress(const bufferlist &in, bufferlist &out) override;
int decompress(const bufferlist &in, bufferlist &out) override;
- int decompress(bufferlist::iterator &p, size_t compressed_len, bufferlist &out) override;
+ int decompress(bufferlist::const_iterator &p, size_t compressed_len, bufferlist &out) override;
private:
int zlib_compress(const bufferlist &in, bufferlist &out);
int isal_compress(const bufferlist &in, bufferlist &out);
}
int decompress(const bufferlist &src, bufferlist &dst) override {
- bufferlist::iterator i = const_cast<bufferlist&>(src).begin();
+ auto i = std::cbegin(src);
return decompress(i, src.length(), dst);
}
- int decompress(bufferlist::iterator &p,
+ int decompress(bufferlist::const_iterator &p,
size_t compressed_len,
bufferlist &dst) override {
if (compressed_len < 4) {
}
}
-static void decode_32_or_64_string_map(map<int32_t,string>& m, bufferlist::iterator& blp)
+static void decode_32_or_64_string_map(map<int32_t,string>& m, bufferlist::const_iterator& blp)
{
m.clear();
__u32 n;
}
}
-void CrushWrapper::decode(bufferlist::iterator& blp)
+void CrushWrapper::decode(bufferlist::const_iterator& blp)
{
using ceph::decode;
create();
}
}
-void CrushWrapper::decode_crush_bucket(crush_bucket** bptr, bufferlist::iterator &blp)
+void CrushWrapper::decode_crush_bucket(crush_bucket** bptr, bufferlist::const_iterator &blp)
{
using ceph::decode;
__u32 alg;
encode(s.arg1, bl);
encode(s.arg2, bl);
}
-inline void decode(crush_rule_step &s, bufferlist::iterator &p)
+inline void decode(crush_rule_step &s, bufferlist::const_iterator &p)
{
using ceph::decode;
decode(s.op, p);
}
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &blp);
- void decode_crush_bucket(crush_bucket** bptr, bufferlist::iterator &blp);
+ void decode(bufferlist::const_iterator &blp);
+ void decode_crush_bucket(crush_bucket** bptr, bufferlist::const_iterator &blp);
void dump(Formatter *f) const;
void dump_rules(Formatter *f) const;
void dump_rule(int ruleset, Formatter *f) const;
encode(names, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(mask, bl);
decode(names, bl);
incompat.encode(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
compat.decode(bl);
ro_compat.decode(bl);
incompat.decode(bl);
}
}
template<class T, class U>
-inline void decode(btree::btree_map<T,U>& m, bufferlist::iterator& p)
+inline void decode(btree::btree_map<T,U>& m, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
}
template<class T, class U>
-inline void decode_nohead(int n, btree::btree_map<T,U>& m, bufferlist::iterator& p)
+inline void decode_nohead(int n, btree::btree_map<T,U>& m, bufferlist::const_iterator& p)
{
m.clear();
while (n--) {
else
encode((uint32_t)0, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
using ceph::decode_nohead;
uint32_t n;
m.encode(bl, features);
}
template<class Key, class T, class Map>
-inline void decode(compact_map_base<Key, T, Map>& m, bufferlist::iterator& p) {
+inline void decode(compact_map_base<Key, T, Map>& m, bufferlist::const_iterator& p) {
m.decode(p);
}
else
encode((uint32_t)0, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
uint32_t n;
decode(n, p);
m.encode(bl);
}
template<class T, class Set>
-inline void decode(compact_set_base<T, Set>& m, bufferlist::iterator& p) {
+inline void decode(compact_set_base<T, Set>& m, bufferlist::const_iterator& p) {
m.decode(p);
}
bl.append((char*)&t, sizeof(t));
}
template<class T>
-inline void decode_raw(T& t, bufferlist::iterator &p)
+inline void decode_raw(T& t, bufferlist::const_iterator &p)
{
p.copy(sizeof(t), (char*)&t);
}
#define WRITE_RAW_ENCODER(type) \
inline void encode(const type &v, ::ceph::bufferlist& bl, uint64_t features=0) { ::ceph::encode_raw(v, bl); } \
- inline void decode(type &v, ::ceph::bufferlist::iterator& p) { __ASSERT_FUNCTION ::ceph::decode_raw(v, p); }
+ inline void decode(type &v, ::ceph::bufferlist::const_iterator& p) { __ASSERT_FUNCTION ::ceph::decode_raw(v, p); }
WRITE_RAW_ENCODER(__u8)
#ifndef _CHAR_IS_SIGNED
__u8 vv = v;
encode_raw(vv, bl);
}
-inline void decode(bool &v, bufferlist::iterator& p) {
+inline void decode(bool &v, bufferlist::const_iterator& p) {
__u8 vv;
decode_raw(vv, p);
v = vv;
e = v; \
::ceph::encode_raw(e, bl); \
} \
- inline void decode(type &v, ::ceph::bufferlist::iterator& p) { \
+ inline void decode(type &v, ::ceph::bufferlist::const_iterator& p) { \
ceph_##etype e; \
::ceph::decode_raw(e, p); \
v = e; \
#define WRITE_CLASS_ENCODER(cl) \
inline void encode(const cl &c, ::ceph::bufferlist &bl, uint64_t features=0) { \
ENCODE_DUMP_PRE(); c.encode(bl); ENCODE_DUMP_POST(cl); } \
- inline void decode(cl &c, ::ceph::bufferlist::iterator &p) { c.decode(p); }
+ inline void decode(cl &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
#define WRITE_CLASS_MEMBER_ENCODER(cl) \
inline void encode(const cl &c, ::ceph::bufferlist &bl) const { \
ENCODE_DUMP_PRE(); c.encode(bl); ENCODE_DUMP_POST(cl); } \
- inline void decode(cl &c, ::ceph::bufferlist::iterator &p) { c.decode(p); }
+ inline void decode(cl &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
#define WRITE_CLASS_ENCODER_FEATURES(cl) \
inline void encode(const cl &c, ::ceph::bufferlist &bl, uint64_t features) { \
ENCODE_DUMP_PRE(); c.encode(bl, features); ENCODE_DUMP_POST(cl); } \
- inline void decode(cl &c, ::ceph::bufferlist::iterator &p) { c.decode(p); }
+ inline void decode(cl &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
#define WRITE_CLASS_ENCODER_OPTIONAL_FEATURES(cl) \
inline void encode(const cl &c, ::ceph::bufferlist &bl, uint64_t features = 0) { \
ENCODE_DUMP_PRE(); c.encode(bl, features); ENCODE_DUMP_POST(cl); } \
- inline void decode(cl &c, ::ceph::bufferlist::iterator &p) { c.decode(p); }
+ inline void decode(cl &c, ::ceph::bufferlist::const_iterator &p) { c.decode(p); }
// string
{
return encode(std::string_view(s), bl, features);
}
-inline void decode(std::string& s, bufferlist::iterator& p)
+inline void decode(std::string& s, bufferlist::const_iterator& p)
{
__u32 len;
decode(len, p);
{
encode_nohead(std::string_view(s), bl);
}
-inline void decode_nohead(int len, std::string& s, bufferlist::iterator& p)
+inline void decode_nohead(int len, std::string& s, bufferlist::const_iterator& p)
{
s.clear();
p.copy(len, s);
if (len)
bl.append(bp);
}
-inline void decode(buffer::ptr& bp, bufferlist::iterator& p)
+inline void decode(buffer::ptr& bp, bufferlist::const_iterator& p)
{
__u32 len;
decode(len, p);
encode(len, bl);
bl.claim_append(s);
}
-inline void decode(bufferlist& s, bufferlist::iterator& p)
+inline void decode(bufferlist& s, bufferlist::const_iterator& p)
{
__u32 len;
decode(len, p);
{
bl.append(s);
}
-inline void decode_nohead(int len, bufferlist& s, bufferlist::iterator& p)
+inline void decode_nohead(int len, bufferlist& s, bufferlist::const_iterator& p)
{
s.clear();
p.copy(len, s);
template<typename Clock, typename Duration,
typename std::enable_if_t<converts_to_timespec_v<Clock>>* = nullptr>
void decode(std::chrono::time_point<Clock, Duration>& t,
- bufferlist::iterator& p) {
+ bufferlist::const_iterator& p) {
uint32_t s;
uint32_t ns;
decode(s, p);
template<typename Rep, typename Period,
typename std::enable_if_t<std::is_integral_v<Rep>>* = nullptr>
void decode(std::chrono::duration<Rep, Period>& d,
- bufferlist::iterator& p) {
+ bufferlist::const_iterator& p) {
uint32_t s;
uint32_t ns;
decode(s, p);
template<typename T>
inline void encode(const boost::optional<T> &p, bufferlist &bl);
template<typename T>
-inline void decode(boost::optional<T> &p, bufferlist::iterator &bp);
+inline void decode(boost::optional<T> &p, bufferlist::const_iterator &bp);
template<class A, class B, class C>
inline void encode(const boost::tuple<A, B, C> &t, bufferlist& bl);
template<class A, class B, class C>
-inline void decode(boost::tuple<A, B, C> &t, bufferlist::iterator &bp);
+inline void decode(boost::tuple<A, B, C> &t, bufferlist::const_iterator &bp);
template<class A, class B,
typename a_traits=denc_traits<A>, typename b_traits=denc_traits<B>>
inline std::enable_if_t<!a_traits::supported || !b_traits::supported>
typename a_traits=denc_traits<A>, typename b_traits=denc_traits<B>>
inline std::enable_if_t<!a_traits::supported ||
!b_traits::supported>
-decode(std::pair<A,B> &pa, bufferlist::iterator &p);
+decode(std::pair<A,B> &pa, bufferlist::const_iterator &p);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::list<T, Alloc>& ls, bufferlist& bl);
encode(const std::list<T,Alloc>& ls, bufferlist& bl, uint64_t features);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
-decode(std::list<T,Alloc>& ls, bufferlist::iterator& p);
+decode(std::list<T,Alloc>& ls, bufferlist::const_iterator& p);
template<class T, class Alloc>
inline void encode(const std::list<ceph::shared_ptr<T>, Alloc>& ls,
bufferlist& bl);
bufferlist& bl, uint64_t features);
template<class T, class Alloc>
inline void decode(std::list<ceph::shared_ptr<T>, Alloc>& ls,
- bufferlist::iterator& p);
+ bufferlist::const_iterator& p);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::set<T,Comp,Alloc>& s, bufferlist& bl);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
-decode(std::set<T,Comp,Alloc>& s, bufferlist::iterator& p);
+decode(std::set<T,Comp,Alloc>& s, bufferlist::const_iterator& p);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode_nohead(const std::set<T,Comp,Alloc>& s, bufferlist& bl);
encode(const boost::container::flat_set<T, Comp, Alloc>& s, bufferlist& bl);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
-decode(boost::container::flat_set<T, Comp, Alloc>& s, bufferlist::iterator& p);
+decode(boost::container::flat_set<T, Comp, Alloc>& s, bufferlist::const_iterator& p);
template<class T, class Comp, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode_nohead(const boost::container::flat_set<T, Comp, Alloc>& s,
template<class T, class Comp, class Alloc>
inline void encode(const std::multiset<T,Comp,Alloc>& s, bufferlist& bl);
template<class T, class Comp, class Alloc>
-inline void decode(std::multiset<T,Comp,Alloc>& s, bufferlist::iterator& p);
+inline void decode(std::multiset<T,Comp,Alloc>& s, bufferlist::const_iterator& p);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::vector<T,Alloc>& v, bufferlist& bl, uint64_t features);
encode(const std::vector<T,Alloc>& v, bufferlist& bl);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
-decode(std::vector<T,Alloc>& v, bufferlist::iterator& p);
+decode(std::vector<T,Alloc>& v, bufferlist::const_iterator& p);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode_nohead(const std::vector<T,Alloc>& v, bufferlist& bl);
template<class T, class Alloc, typename traits=denc_traits<T>>
inline std::enable_if_t<!traits::supported>
-decode_nohead(int len, std::vector<T,Alloc>& v, bufferlist::iterator& p);
+decode_nohead(int len, std::vector<T,Alloc>& v, bufferlist::const_iterator& p);
template<class T,class Alloc>
inline void encode(const std::vector<ceph::shared_ptr<T>,Alloc>& v,
bufferlist& bl,
bufferlist& bl);
template<class T, class Alloc>
inline void decode(std::vector<ceph::shared_ptr<T>,Alloc>& v,
- bufferlist::iterator& p);
+ bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc,
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported ||
template<class T, class U, class Comp, class Alloc,
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
-decode(std::map<T,U,Comp,Alloc>& m, bufferlist::iterator& p);
+decode(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc>
-inline void decode_noclear(std::map<T,U,Comp,Alloc>& m, bufferlist::iterator& p);
+inline void decode_noclear(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc,
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
template<class T, class U, class Comp, class Alloc,
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
-decode_nohead(int n, std::map<T,U,Comp,Alloc>& m, bufferlist::iterator& p);
+decode_nohead(int n, std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc,
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
template<class T, class U, class Comp, class Alloc,
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
-decode(boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist::iterator& p);
+decode(boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc>
inline void decode_noclear(boost::container::flat_map<T,U,Comp,Alloc>& m,
- bufferlist::iterator& p);
+ bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc,
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
typename t_traits=denc_traits<T>, typename u_traits=denc_traits<U>>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
decode_nohead(int n, boost::container::flat_map<T,U,Comp,Alloc>& m,
- bufferlist::iterator& p);
+ bufferlist::const_iterator& p);
template<class T, class U, class Comp, class Alloc>
inline void encode(const std::multimap<T,U,Comp,Alloc>& m, bufferlist& bl);
template<class T, class U, class Comp, class Alloc>
-inline void decode(std::multimap<T,U,Comp,Alloc>& m, bufferlist::iterator& p);
+inline void decode(std::multimap<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class U, class Hash, class Pred, class Alloc>
inline void encode(const unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist& bl,
uint64_t features);
template<class T, class U, class Hash, class Pred, class Alloc>
inline void encode(const unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist& bl);
template<class T, class U, class Hash, class Pred, class Alloc>
-inline void decode(unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist::iterator& p);
+inline void decode(unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class Hash, class Pred, class Alloc>
inline void encode(const ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist& bl);
template<class T, class Hash, class Pred, class Alloc>
-inline void decode(ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist::iterator& p);
+inline void decode(ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p);
template<class T, class Alloc>
inline void encode(const std::deque<T,Alloc>& ls, bufferlist& bl, uint64_t features);
template<class T, class Alloc>
inline void encode(const std::deque<T,Alloc>& ls, bufferlist& bl);
template<class T, class Alloc>
-inline void decode(std::deque<T,Alloc>& ls, bufferlist::iterator& p);
+inline void decode(std::deque<T,Alloc>& ls, bufferlist::const_iterator& p);
template<class T, size_t N, typename traits = denc_traits<T>>
inline std::enable_if_t<!traits::supported>
encode(const std::array<T, N>& v, bufferlist& bl, uint64_t features);
encode(const std::array<T, N>& v, bufferlist& bl);
template<class T, size_t N, typename traits = denc_traits<T>>
inline std::enable_if_t<!traits::supported>
-decode(std::array<T, N>& v, bufferlist::iterator& p);
+decode(std::array<T, N>& v, bufferlist::const_iterator& p);
// full bl decoder
template<class T>
-inline void decode(T &o, bufferlist& bl)
+inline void decode(T &o, const bufferlist& bl)
{
- bufferlist::iterator p = bl.begin();
+ auto p = bl.begin();
decode(o, p);
assert(p.end());
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
template<typename T>
-inline void decode(boost::optional<T> &p, bufferlist::iterator &bp)
+inline void decode(boost::optional<T> &p, bufferlist::const_iterator &bp)
{
__u8 present;
decode(present, bp);
});
}
template<typename... Ts>
-inline void decode(std::tuple<Ts...> &t, bufferlist::iterator &bp)
+inline void decode(std::tuple<Ts...> &t, bufferlist::const_iterator &bp)
{
ceph::for_each(t, [&bp](auto& e) {
decode(e, bp);
encode(boost::get<2>(t), bl);
}
template<class A, class B, class C>
-inline void decode(boost::tuple<A, B, C> &t, bufferlist::iterator &bp)
+inline void decode(boost::tuple<A, B, C> &t, bufferlist::const_iterator &bp)
{
decode(boost::get<0>(t), bp);
decode(boost::get<1>(t), bp);
template<class A, class B, typename a_traits, typename b_traits>
inline std::enable_if_t<!a_traits::supported ||
!b_traits::supported>
- decode(std::pair<A,B> &pa, bufferlist::iterator &p)
+ decode(std::pair<A,B> &pa, bufferlist::const_iterator &p)
{
decode(pa.first, p);
decode(pa.second, p);
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
- decode(std::list<T,Alloc>& ls, bufferlist::iterator& p)
+ decode(std::list<T,Alloc>& ls, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
template<class T, class Alloc>
inline void decode(std::list<ceph::shared_ptr<T>, Alloc>& ls,
- bufferlist::iterator& p)
+ bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
- decode(std::set<T,Comp,Alloc>& s, bufferlist::iterator& p)
+ decode(std::set<T,Comp,Alloc>& s, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
- decode_nohead(int len, std::set<T,Comp,Alloc>& s, bufferlist::iterator& p)
+ decode_nohead(int len, std::set<T,Comp,Alloc>& s, bufferlist::const_iterator& p)
{
for (int i=0; i<len; i++) {
T v;
}
template<class T, class Comp, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
-decode(boost::container::flat_set<T, Comp, Alloc>& s, bufferlist::iterator& p)
+decode(boost::container::flat_set<T, Comp, Alloc>& s, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
encode(*p, bl);
}
template<class T, class Comp, class Alloc>
-inline void decode(std::multiset<T,Comp,Alloc>& s, bufferlist::iterator& p)
+inline void decode(std::multiset<T,Comp,Alloc>& s, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
- decode(std::vector<T,Alloc>& v, bufferlist::iterator& p)
+ decode(std::vector<T,Alloc>& v, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
template<class T, class Alloc, typename traits>
inline std::enable_if_t<!traits::supported>
- decode_nohead(int len, std::vector<T,Alloc>& v, bufferlist::iterator& p)
+ decode_nohead(int len, std::vector<T,Alloc>& v, bufferlist::const_iterator& p)
{
v.resize(len);
for (__u32 i=0; i<v.size(); i++)
}
template<class T, class Alloc>
inline void decode(std::vector<ceph::shared_ptr<T>,Alloc>& v,
- bufferlist::iterator& p)
+ bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
template<class T, class U, class Comp, class Alloc,
typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
- decode(std::map<T,U,Comp,Alloc>& m, bufferlist::iterator& p)
+ decode(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
}
template<class T, class U, class Comp, class Alloc>
-inline void decode_noclear(std::map<T,U,Comp,Alloc>& m, bufferlist::iterator& p)
+inline void decode_noclear(std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
template<class T, class U, class Comp, class Alloc,
typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
- decode_nohead(int n, std::map<T,U,Comp,Alloc>& m, bufferlist::iterator& p)
+ decode_nohead(int n, std::map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
m.clear();
while (n--) {
template<class T, class U, class Comp, class Alloc,
typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
- decode(boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist::iterator& p)
+ decode(boost::container::flat_map<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
template<class T, class U, class Comp, class Alloc>
inline void decode_noclear(boost::container::flat_map<T,U,Comp,Alloc>& m,
- bufferlist::iterator& p)
+ bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
typename t_traits, typename u_traits>
inline std::enable_if_t<!t_traits::supported || !u_traits::supported>
decode_nohead(int n, boost::container::flat_map<T,U,Comp,Alloc>& m,
- bufferlist::iterator& p)
+ bufferlist::const_iterator& p)
{
m.clear();
while (n--) {
}
}
template<class T, class U, class Comp, class Alloc>
-inline void decode(std::multimap<T,U,Comp,Alloc>& m, bufferlist::iterator& p)
+inline void decode(std::multimap<T,U,Comp,Alloc>& m, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
}
template<class T, class U, class Hash, class Pred, class Alloc>
-inline void decode(unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist::iterator& p)
+inline void decode(unordered_map<T,U,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
encode(*p, bl);
}
template<class T, class Hash, class Pred, class Alloc>
-inline void decode(ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist::iterator& p)
+inline void decode(ceph::unordered_set<T,Hash,Pred,Alloc>& m, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
encode(*p, bl);
}
template<class T, class Alloc>
-inline void decode(std::deque<T,Alloc>& ls, bufferlist::iterator& p)
+inline void decode(std::deque<T,Alloc>& ls, bufferlist::const_iterator& p)
{
__u32 n;
decode(n, p);
}
template<class T, size_t N, typename traits>
inline std::enable_if_t<!traits::supported>
-decode(std::array<T, N>& v, bufferlist::iterator& p)
+decode(std::array<T, N>& v, bufferlist::const_iterator& p)
{
for (auto& e : v)
decode(e, p);
bufferlist bl;
__u32 len = 0;
bl.read_fd(fd, sizeof(len));
- decode(len, bl);
+ decode(len, bl);
bl.read_fd(fd, len);
- bufferlist::iterator bli = bl.begin();
+ auto bli = std::cbegin(bl);
- decode(bp, bli);
+ decode(bp, bli);
return bl.length();
}
}
encode(ino, bl);
encode(path, bl);
}
- void decode(bufferlist::iterator& blp) {
+ void decode(bufferlist::const_iterator& blp) {
using ceph::decode;
bits.clear();
__u8 struct_v;
}
inline void encode(const frag_t &f, bufferlist& bl) { encode_raw(f._enc, bl); }
-inline void decode(frag_t &f, bufferlist::iterator& p) {
+inline void decode(frag_t &f, bufferlist::const_iterator& p) {
__u32 v;
decode_raw(v, p);
f._enc = v;
using ceph::encode;
encode(_splits, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(_splits, p);
}
encode(p->second, bl);
}
}
- void decode_nohead(int n, bufferlist::iterator& p) {
+ void decode_nohead(int n, bufferlist::const_iterator& p) {
using ceph::decode;
_splits.clear();
while (n-- > 0) {
using ceph::encode;
encode(val, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(val, p);
}
static void encode(const inodeno_t &o, buffer::list::contiguous_appender& p) {
denc(o.val, p);
}
- static void decode(inodeno_t& o, buffer::ptr::iterator &p) {
+ static void decode(inodeno_t& o, buffer::ptr::const_iterator &p) {
denc(o.val, p);
}
};
bool is_valid() const;
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<file_layout_t*>& o);
};
uint8_t v = hs;
encode(v, bl);
}
-inline void decode(health_status_t& hs, bufferlist::iterator& p) {
+inline void decode(health_status_t& hs, bufferlist::const_iterator& p) {
using ceph::decode;
uint8_t v;
decode(v, p);
uint64_t f=0) {
::denc((uint8_t)v, p);
}
- static void decode(health_status_t& v, buffer::ptr::iterator& p,
+ static void decode(health_status_t& v, buffer::ptr::const_iterator& p,
uint64_t f=0) {
uint8_t tmp;
::denc(tmp, p);
v = health_status_t(tmp);
}
- static void decode(health_status_t& v, buffer::list::iterator& p,
+ static void decode(health_status_t& v, buffer::list::const_iterator& p,
uint64_t f=0) {
uint8_t tmp;
::denc(tmp, p);
void encode(bufferlist::contiguous_appender& p) const {
denc(m, p);
}
- void decode(bufferptr::iterator& p) {
+ void decode(bufferptr::const_iterator& p) {
denc(m, p);
_size = 0;
for (const auto& i : m) {
void encode_nohead(bufferlist::contiguous_appender& p) const {
denc_traits<Map>::encode_nohead(m, p);
}
- void decode_nohead(int n, bufferptr::iterator& p) {
+ void decode_nohead(int n, bufferptr::const_iterator& p) {
denc_traits<Map>::decode_nohead(n, m, p);
_size = 0;
for (const auto& i : m) {
bufferlist::contiguous_appender& p) {
v.encode(p);
}
- static void decode(interval_set<T,Map>& v, bufferptr::iterator& p) {
+ static void decode(interval_set<T,Map>& v, bufferptr::const_iterator& p) {
v.decode(p);
}
template<typename U=T>
v.encode_nohead(p);
}
static void decode_nohead(size_t n, interval_set<T,Map>& v,
- bufferptr::iterator& p) {
+ bufferptr::const_iterator& p) {
v.decode_nohead(n, p);
}
};
using ceph::encode;
encode(name, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(name, bl);
}
};
inline void encode(snapid_t i, bufferlist &bl) { encode(i.val, bl); }
-inline void decode(snapid_t &i, bufferlist::iterator &p) { decode(i.val, p); }
+inline void decode(snapid_t &i, bufferlist::const_iterator &p) { decode(i.val, p); }
template<>
struct denc_traits<snapid_t> {
static void encode(const snapid_t &o, buffer::list::contiguous_appender& p) {
denc(o.val, p);
}
- static void decode(snapid_t& o, buffer::ptr::iterator &p) {
+ static void decode(snapid_t& o, buffer::ptr::const_iterator &p) {
denc(o.val, p);
}
};
encode(oid, bl);
encode(snap, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(oid, bl);
decode(snap, bl);
using ceph::encode;
encode(v, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(v, bl);
}
using ceph::encode;
encode(id, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(id, bl);
}
__s32 newcode = hostos_to_ceph_errno(code);
encode(newcode, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(code, bl);
code = ceph_to_hostos_errno(code);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(byte_total, p);
decode(byte_used, p);
encode(tv.tv_nsec, bl);
#endif
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
#if defined(CEPH_LITTLE_ENDIAN)
p.copy(sizeof(__u32) + sizeof(__u32), (char *)(this));
#else
::encode_raw(uuid, bl);
}
- void decode(bufferlist::iterator& p) const {
+ void decode(bufferlist::const_iterator& p) const {
::decode_raw(uuid, p);
}
};
assert(get_fixed_size() + m_data.length() + bl_offset == bl.length());
}
-void Entry::decode(bufferlist::iterator &iter) {
+void Entry::decode(bufferlist::const_iterator &iter) {
using ceph::decode;
uint32_t start_offset = iter.get_off();
uint64_t bl_preamble;
f->dump_string("data", data.str());
}
-bool Entry::is_readable(bufferlist::iterator iter, uint32_t *bytes_needed) {
+bool Entry::is_readable(bufferlist::const_iterator iter, uint32_t *bytes_needed) {
using ceph::decode;
uint32_t start_off = iter.get_off();
if (iter.get_remaining() < HEADER_FIXED_SIZE) {
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &iter);
+ void decode(bufferlist::const_iterator &iter);
void dump(ceph::Formatter *f) const;
bool operator==(const Entry& rhs) const;
- static bool is_readable(bufferlist::iterator iter, uint32_t *bytes_needed);
+ static bool is_readable(bufferlist::const_iterator iter, uint32_t *bytes_needed);
static void generate_test_instances(std::list<Entry *> &o);
private:
ldout(cct, 20) << "C_GetClient: " << __func__ << ": r=" << r << dendl;
if (r == 0) {
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
r = client::get_client_finish(&it, client);
}
complete(r);
ldout(cct, 20) << "C_AllocateTag: " << __func__ << ": r=" << r << dendl;
if (r == 0) {
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = client::get_next_tag_tid_finish(&iter, &tag->tid);
}
if (r < 0) {
ldout(cct, 20) << "C_AllocateTag: " << __func__ << ": r=" << r << dendl;
if (r == 0) {
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
cls::journal::Tag journal_tag;
r = client::get_tag_finish(&iter, &journal_tag);
void handle_get_tag(int r) {
if (r == 0) {
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = client::get_tag_finish(&iter, tag);
}
complete(r);
void handle_tag_list(int r) {
if (r == 0) {
std::set<cls::journal::Tag> journal_tags;
- bufferlist::iterator iter = out_bl.begin();
+ auto iter = out_bl.cbegin();
r = client::tag_list_finish(&iter, &journal_tags);
if (r == 0) {
for (auto &journal_tag : journal_tags) {
std::set<cls::journal::Tag> tags;
if (r == 0) {
- bufferlist::iterator it = out_bl.begin();
+ auto it = out_bl.cbegin();
r = client::tag_list_finish(&it, &tags);
}
uint32_t invalid_start_off = 0;
clear_invalid_range(m_read_bl_off, m_read_bl.length());
- bufferlist::iterator iter(&m_read_bl, 0);
+ bufferlist::const_iterator iter{&m_read_bl, 0};
while (!iter.end()) {
uint32_t bytes_needed;
uint32_t bl_off = iter.get_off();
r = cls_cxx_map_get_val(hctx, key_data(key).encoded(), &raw_val);
if (r == 0){
CLS_LOG(20, "%s is already in the index: %d", key.c_str(), r);
- bufferlist::iterator b = raw_val.begin();
+ auto b = raw_val.cbegin();
idata.decode(b);
if (!kvmap.empty()) {
- bufferlist::iterator b = kvmap.begin()->second.begin();
+ auto b = kvmap.begin()->second.cbegin();
next_idata.decode(b);
}
return r;
} else if (r == -ENOENT || r == -ENODATA) {
- bufferlist::iterator b = kvmap.begin()->second.begin();
+ auto b = kvmap.begin()->second.cbegin();
idata.decode(b);
if (idata.kdata.prefix != "1") {
- bufferlist::iterator nb = (++kvmap.begin())->second.begin();
+ auto nb = (++kvmap.begin())->second.cbegin();
next_idata.decode(nb);
}
r = 0;
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "get_idata_from_key_op");
idata_from_key_args op;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error& err) {
if (!kvs.empty()) {
out_data.kdata.parse(kvs.begin()->first);
- bufferlist::iterator b = kvs.begin()->second.begin();
+ auto b = kvs.begin()->second.cbegin();
out_data.decode(b);
} else {
r = -EOVERFLOW;
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "get_next_idata_op");
idata_from_idata_args op;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error& err) {
--it;
}
out_data.kdata.parse(it->first);
- bufferlist::iterator b = it->second.begin();
+ auto b = it->second.cbegin();
out_data.decode(b);
return 0;
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "get_next_idata_op");
idata_from_idata_args op;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error& err) {
CLS_LOG(20, "read_many_op");
set<string> op;
map<string, bufferlist> outmap;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error & err) {
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "assert_size_in_bound_op");
assert_size_args op;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error& err) {
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "omap_insert");
omap_set_args op;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error& err) {
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "omap_insert");
map<string, bufferlist> omap;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(omap, it);
} catch (buffer::error& err) {
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "omap_remove");
omap_rm_args op;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error& err) {
bufferlist *in, bufferlist *out) {
CLS_LOG(20, "maybe_read_for_balance");
rebalance_args op;
- bufferlist::iterator it = in->begin();
+ auto it = in->cbegin();
try {
decode(op, it);
} catch (buffer::error& err) {
}
if (!kvs.empty()) {
out_data->kdata.parse(kvs.begin()->first);
- bufferlist::iterator b = kvs.begin()->second.begin();
+ auto b = kvs.begin()->second.cbegin();
out_data->decode(b);
if (idata.is_timed_out(ceph_clock_now(), timeout)) {
if (verbose) cout << client_name << " THINKS THE OTHER CLIENT DIED."
}
return err;
}
- bufferlist::iterator it = outbl.begin();
+ auto it = outbl.cbegin();
in_args.decode(it);
*out_data = in_args.next_idata;
if (verbose) cout << "\t\t" << client_name << "-prev: prev is "
it != kvmap.end();
++it) {
bufferlist bl = it->second;
- bufferlist::iterator blit = bl.begin();
+ auto blit = bl.cbegin();
index_data this_idata;
this_idata.decode(blit);
if (this_idata.is_timed_out(mytime, timeout)) {
icache.push(this_idata);
icache_lock.Unlock();
}
- bufferlist::iterator b = kvmap.begin()->second.begin();
+ auto b = kvmap.begin()->second.cbegin();
idata->decode(b);
idata->kdata.parse(kvmap.begin()->first);
if (verbose) cout << "\t" << client_name << "-read_index: kvmap_size is "
if (next_idata != NULL && idata->kdata.prefix != "1") {
next_idata->kdata.parse((++kvmap.begin())->first);
- bufferlist::iterator nb = (++kvmap.begin())->second.begin();
+ auto nb = (++kvmap.begin())->second.cbegin();
next_idata->decode(nb);
icache_lock.Lock();
icache.push(*next_idata);
a->release();
return err;
}
- bufferlist::iterator it = outbl.begin();
+ auto it = outbl.cbegin();
args->decode(it);
args->odata.name = obj;
args->odata.version = a->get_version64();
}
map<string, bufferlist> imap;//read from the index
- bufferlist::iterator blit = outbl.begin();
+ auto blit = outbl.cbegin();
decode(imap, blit);
if (verbose) cout << "finished reading index for objects. there are "
sub.remove();
}
index_data idata;
- bufferlist::iterator b = it->second.begin();
+ auto b = it->second.cbegin();
idata.decode(b);
io_ctx.operate(idata.obj, &sub);
}
std::set<std::string> ret;
sub.omap_get_keys2("",LONG_MAX,&ret, nullptr, &err);
index_data idata;
- bufferlist::iterator b = it->second.begin();
+ auto b = it->second.cbegin();
idata.decode(b);
io_ctx.operate(idata.obj, &sub, NULL);
keys->insert(ret.begin(), ret.end());
it != index.end(); ++it) {
if (it->first != "") {
index_data idata;
- bufferlist::iterator b = it->second.begin();
+ auto b = it->second.cbegin();
idata.decode(b);
if (idata.prefix != "") {
for(vector<delete_data>::iterator dit = idata.to_delete.begin();
for (map<std::string,bufferlist>::iterator it = index.begin();
it != index.end(); ++it){
index_data idata;
- bufferlist::iterator b = it->second.begin();
+ auto b = it->second.cbegin();
idata.decode(b);
string s = idata.str();
ret << "|" << string((148 -
encode(prefix, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(raw_key, p);
decode(prefix, p);
encode(size, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(min_kdata, p);
decode(max_kdata, p);
encode(obj, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(min, p);
decode(max, p);
encode(version, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(min, p);
decode(max, p);
encode(obj, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(prefix, p);
decode(min_kdata, p);
encode(comparator, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(bound, p);
decode(comparator, p);
encode(next_idata, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(key, p);
decode(idata, p);
encode(next_idata, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(idata, p);
decode(next_idata, p);
encode(exclusive, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(omap, p);
decode(bound, p);
encode(bound, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(omap, p);
decode(bound, p);
encode(comparator, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(odata,p);
decode(bound, p);
const std::string &prefix, ///< [in] prefix, or CF name
bufferlist& to_set_bl ///< [in] encoded key/values to set
) {
- bufferlist::iterator p = to_set_bl.begin();
+ auto p = std::cbegin(to_set_bl);
uint32_t num;
decode(num, p);
while (num--) {
const std::string &prefix, ///< [in] Prefix or CF to search for
bufferlist &keys_bl ///< [in] Keys to remove
) {
- bufferlist::iterator p = keys_bl.begin();
+ auto p = std::cbegin(keys_bl);
uint32_t num;
decode(num, p);
while (num--) {
if (r < 0)
return r;
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(m, iter);
return m.size();
void decode_payload() override {
using ceph::encode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(protocol, p);
decode(auth_payload, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(protocol, p);
decode(result, p);
decode(global_id, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid.pgid, p);
decode(query_epoch, p);
decode(type, p);
encode(dirs, bl);
encode(dentries, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(inodes, bl);
decode(dirs, bl);
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(from, p);
decode(realms, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(head, p);
decode_nohead(head.num, caps, p);
if (header.version >= 2) {
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(head, p);
ceph_mds_caps_body_legacy body;
decode(body, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(h, p);
decode(dname, p);
}
encode(quota, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
decode(rstat.rctime, p);
decode(rstat.rbytes, p);
encode_nohead(realms, data);
}
void decode_payload() override {
- bufferlist::iterator p = data.begin();
+ auto p = data.cbegin();
if (header.version >= 3) {
// new protocol
decode(caps, p);
encode(duration_ms, bl);
encode(seq, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(mask, bl);
decode(duration_ms, bl);
set<__s32> dist;
DirStat() : auth(CDIR_AUTH_PARENT) {}
- DirStat(bufferlist::iterator& p) {
+ DirStat(bufferlist::const_iterator& p) {
decode(p);
}
encode(auth, bl);
encode(dist, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(frag, p);
decode(auth, p);
public:
InodeStat() {}
- InodeStat(bufferlist::iterator& p, uint64_t features) {
+ InodeStat(bufferlist::const_iterator& p, uint64_t features) {
decode(p, features);
}
- void decode(bufferlist::iterator &p, uint64_t features) {
+ void decode(bufferlist::const_iterator &p, uint64_t features) {
using ceph::decode;
decode(vino.ino, p);
decode(vino.snapid, p);
// serialization
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(head, p);
decode(trace_bl, p);
decode(extra_bl, p);
encode(item, bl);
encode_nohead(dname, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(item, bl);
decode_nohead(item.dname_len, dname, bl);
bool is_queued_for_replay() { return queued_for_replay; }
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
if (header.version >= 4) {
decode(head, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dest_mds, p);
decode(num_fwd, p);
decode(client_must_resend, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(head, p);
if (header.version >= 2) {
decode(client_meta, p);
encode_nohead(bl, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(head, p);
decode_nohead(head.num_split_inos, split_inos, p);
decode_nohead(head.num_split_realms, split_realms, p);
encode(cmd, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(cmd, p);
}
encode(rs, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(r, p);
decode(rs, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(config, p);
}
public:
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(tag, p);
decode(counter, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(subtree, p);
decode(dirfrag, p);
decode(dn, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(dn, p);
decode(straybl, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(from_mds, p);
decode(dirfrag, p);
decode(dir_rep, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(base_ino, p);
decode(base_dir_frag, p);
decode(snapid, p);
// ...
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(base_ino, p);
decode(base_dir_frag, p);
decode(wanted_base_dir, p);
encode(client_map, payload, features);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
decode(cap_bl, p);
decode(client_map, p);
encode(ino, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
}
encode(client_map, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(bounds, p);
decode(export_data, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(imported_caps, p);
}
encode(dirfrag, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
}
};
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(from, p);
decode(dirfrag, p);
decode(path, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(success, p);
}
encode(last, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(last, p);
}
encode(bounds, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(base, p);
decode(ack, p);
decode(old_auth, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(new_auth, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(basedir, p);
decode(bounds, p);
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(dirfrag, p);
decode(success, p);
}
// marshalling
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(fsmap, p);
}
// marshalling
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(fsmap, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(tid, p);
decode(client, p);
decode(client_caps, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(name, p);
decode(host, p);
decode(device_class, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(pools, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(pool_stats, p);
encode(import_map, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
utime_t now(ceph_clock_now());
decode(load, now, p);
decode(beat, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
decode(caps, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(asker, p);
decode(action, p);
decode(reqid, p);
encode(entries, payload, features);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(entries, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(last, p);
if (!p.end())
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode((uint16_t&)type, bl);
assert(type != MDS_HEALTH_NULL);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(metrics, bl);
DECODE_FINISH(bl);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(global_id, p);
encode(nestlock, bl);
encode(dftlock, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(nonce, bl);
decode(caps_wanted, bl);
encode(nonce, bl);
encode(dir_rep, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(nonce, bl);
decode(dir_rep, bl);
encode(nonce, bl);
encode(lock, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(first, bl);
decode(ino, bl);
encode(first, bl);
encode(ino, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(first, bl);
decode(ino, bl);
encode(nest, bl);
encode(dft, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(file, bl);
decode(nest, bl);
encode(reqid, bl);
encode(attempt, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(reqid, bl);
decode(attempt, bl);
encode(xlocked_dentries, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
using ceph::decode;
decode(op, p);
decode(strong_inodes, p);
encode(ino, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(tid, p);
decode(ino, p);
}
encode(path, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(tid, p);
decode(path, p);
}
encode(basebl, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
decode(basefrag, p);
decode(bits, p);
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(global_id, p);
decode(targets, p);
// marshalling
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(epoch, p);
decode(encoded, p);
encode(ancestors, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
decode(ancestors, p);
}
encode(error, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
decode(ancestors, p);
decode(hint, p);
encode(inode_caps, bl);
encode(committing, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(inode_caps, bl);
decode(committing, bl);
encode(type, bl);
encode(pending_commits, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(type, bl);
decode(pending_commits, bl);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(subtrees, p);
decode(ambiguous_imports, p);
decode(slave_requests, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(commit, p);
decode(abort, p);
}
encode(desti_snapbl, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(reqid, p);
decode(attempt, p);
decode(op, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(ino, p);
decode(snap_op, p);
decode(snap_blob, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(table, p);
decode(op, p);
decode(reqid, p);
encode(modules, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(server_addr, p);
decode(gid, p);
void decode_payload() override
{
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(daemon_name, p);
decode(service_name, p);
}
void decode_payload() override
{
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(stats_period, p);
if (header.version >= 2) {
decode(stats_threshold, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(mon_status_json, p);
decode(health_json, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(map, p);
}
void encode_payload(uint64_t features) override {
void decode_payload() override
{
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(daemon_name, p);
if (header.version >= 2) {
decode(service_name, p);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p)
+ void decode(bufferlist::const_iterator &p)
{
DECODE_START(3, p);
decode(path, p);
void decode_payload() override
{
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(daemon_name, p);
decode(declare_types, p);
decode(packed, p);
encode(cmd, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(cmd, p);
encode(cmd, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(r, p);
decode(rs, p);
encode(metadata, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(op, p);
decode(epoch, p);
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(full_first, p);
decode(full_last, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(handle, p);
decode(what, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(handle, p);
decode(version, p);
if (header.version >= 2)
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(old_max_id, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
service_decode(p);
decode(service_type, p);
decode(service_op, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(health_checks, p);
}
encode(addr, payload, features);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(name, p);
encode(monmapbl, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(monmapbl, p);
}
};
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(data, p);
}
};
encode(service_map_bl, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(health_checks, p);
decode(service_map_bl, p);
encode(feature_map, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(op, p);
decode(first_committed, p);
encode(required_features, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(op, p);
decode(name, p);
encode(round, payload);
}
- void service_decode(bufferlist::iterator &p) {
+ void service_decode(bufferlist::const_iterator &p) {
decode(epoch, p);
decode(round, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
uint8_t o;
decode(o, p);
op = (op_type_t)o;
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
if (header.version < 2) {
map<string, ceph_mon_subscribe_item_old> oldwhat;
decode(oldwhat, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(interval, p);
decode(fsid, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(op, p);
decode(cookie, p);
decode(last_committed, p);
}
void decode_payload() {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(tag, p);
}
encode(want, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(want, p);
}
}
void decode_payload() override {
- auto p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(op, p);
encode(min_last_epoch_clean, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(pgs, p);
decode(min_last_epoch_clean, p);
encode(osd_features, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(sb, p);
decode(hb_back_addr, p);
{}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(op, p);
{}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(op, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(op, p);
{}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(op, p);
epoch_t get_epoch() const { return epoch; }
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(target_osd, p);
encode(options, payload);
}
void decode_payload() {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
if (header.version == 1) {
vector<pg_t> pgs;
decode(fsid, p);
encode(state, payload);
}
void decode_payload() {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(map_epoch, p);
decode(state, p);
public:
// marshalling
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(incremental_maps, p);
decode(maps, p);
p != incremental_maps.end();
++p) {
OSDMap::Incremental inc;
- bufferlist::iterator q = p->second.begin();
+ auto q = p->second.cbegin();
inc.decode(q);
// always encode with subset of osdmaps canonical features
uint64_t f = inc.encode_features & features;
if (inc.crush.length()) {
// embedded crush map
CrushWrapper c;
- auto p = inc.crush.begin();
+ auto p = inc.crush.cbegin();
c.decode(p);
inc.crush.clear();
c.encode(inc.crush, f);
epoch_t get_epoch() const { return epoch; }
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(target_osd, p);
hobject_t hobj;
spg_t pgid;
- bufferlist::iterator p;
+ bufferlist::const_iterator p;
// Decoding flags. Decoding is only needed for messages catched by pipe reader.
// Transition from true -> false without locks being held
// Can never see final_decode_needed == false and partial_decode_needed == true
void decode_payload() override {
assert(partial_decode_needed && final_decode_needed);
- p = payload.begin();
+ p = std::cbegin(payload);
// Always keep here the newest version of decoding order/rule
if (header.version == HEAD_VERSION) {
}
void decode_payload() override {
using ceph::decode;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
// Always keep here the newest version of decoding order/rule
if (header.version == HEAD_VERSION) {
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(op, p);
decode(map_epoch, p);
decode(query_epoch, p);
encode(ls, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(ls, p);
encode(ctimes, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(mkpg, p);
decode(ctimes, p);
encode(pgs, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
using ceph::decode;
decode(epoch, p);
decode(pgs, p);
encode(pgid, payload);
}
void decode_payload() override {
- auto p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(pgid, p);
}
encode(pg_list, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(pg_list, p);
}
encode(from, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(info, p);
log.decode(p, info.pgid.pool());
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(pg_list, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid.pgid, p);
decode(map_epoch, p);
decode(pulls, p);
{}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid.pgid, p);
decode(map_epoch, p);
decode(pushes, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid.pgid, p);
decode(map_epoch, p);
decode(replies, p);
encode(pg_list, payload, features);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(pg_list, p);
}
encode(objects, payload);
}
void decode_payload() {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(from, p);
decode(pgid, p);
decode(map_epoch, p);
{}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid.pgid, p);
decode(map_epoch, p);
decode(min_epoch, p);
encode(pg_list, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(pg_list, p);
}
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(op, p);
decode(map_epoch, p);
decode(query_epoch, p);
encode(forced, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(map_epoch, p);
decode(pg_temp, p);
encode(pgid.shard, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(epoch, p);
decode(pgid.pgid, p);
decode(trim_to, p);
encode(pg_roll_forward_to, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(map_epoch, p);
decode(pgid, p);
decode(from, p);
encode(last_complete_ondisk, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(map_epoch, p);
decode(pgid, p);
decode(from, p);
public:
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(map_epoch, p);
decode(op, p);
spg_t pgid;
- bufferlist::iterator p;
+ bufferlist::const_iterator p;
// Decoding flags. Decoding is only needed for messages catched by pipe reader.
bool final_decode_needed;
}
void decode_payload() override {
- p = payload.begin();
+ p = payload.cbegin();
// splitted to partial and final
decode(map_epoch, p);
if (header.version >= 2) {
// piggybacked osd state
eversion_t last_complete_ondisk;
- bufferlist::iterator p;
+ bufferlist::const_iterator p;
// Decoding flags. Decoding is only needed for messages catched by pipe reader.
bool final_decode_needed;
}
void decode_payload() override {
- p = payload.begin();
+ p = payload.cbegin();
decode(map_epoch, p);
if (header.version >= 2) {
decode(min_epoch, p);
encode(high_priority, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid.pgid, p);
decode(scrub_from, p);
decode(scrub_to, p);
encode(preempted, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(from, p);
encode(deep, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(scrub_pgs, p);
decode(repair, p);
encode(deep, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(fsid, p);
decode(epoch, p);
decode(scrub_pgs, p);
}
void decode_payload() {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid, p);
decode(map_epoch, p);
decode(type, p);
encode(had_map_for, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(osd_stat, p);
encode(pg_stat, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pg_stat, p);
}
};
encode(crush_rule, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(pool, p);
encode(false, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
decode(replyCode, p);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(pgid.pgid, p);
decode(query_epoch, p);
decode(type, p);
encode(snaps, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(snaps, p);
assert(p.end());
session_mon_tid(0),
dest(i),
send_osdmap_first(0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
msg = decode_message(NULL, 0, p);
}
private:
public:
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(session_mon_tid, p);
decode(dest, p);
bool m;
encode(service_map, payload, features);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(service_map, p);
}
};
encode(data_pool, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
decode(fsid, p);
if (header.version >= 2) {
encode(h, payload);
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(h, p);
}
};
}
void decode_payload() override {
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(op, p);
decode(epoch, p);
decode(round, p);
public:
void decode_payload() override {
uint8_t msg_ver;
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
decode(msg_ver, p);
decode(opcode, p);
decode(cookie, p);
encode(deprecated_session_mon_tid, payload);
}
- void paxos_decode( bufferlist::iterator& p ) {
+ void paxos_decode(bufferlist::const_iterator& p ) {
decode(version, p);
decode(deprecated_session_mon, p);
decode(deprecated_session_mon_tid, p);
void decode_payload() override {
ceph_abort();
- bufferlist::iterator p = payload.begin();
+ auto p = payload.cbegin();
paxos_decode(p);
}
s->caps.set_allow_all();
}
if (caps_info.caps.length() > 0) {
- bufferlist::iterator p = caps_info.caps.begin();
+ auto p = caps_info.caps.cbegin();
string str;
try {
decode(str, p);
}
}
- auto p = m->config_bl.begin();
+ auto p = m->config_bl.cbegin();
if (p != m->config_bl.end()) {
decode(daemon->config, p);
decode(daemon->ignored_mon_config, p);
auto &daemon_counters = daemon->perf_counters;
daemon_counters.update(m);
- auto p = m->config_bl.begin();
+ auto p = m->config_bl.cbegin();
if (p != m->config_bl.end()) {
decode(daemon->config, p);
decode(daemon->ignored_mon_config, p);
const auto now = ceph_clock_now();
// Parse packed data according to declared set of types
- bufferlist::iterator p = report->packed.begin();
+ auto p = report->packed.cbegin();
DECODE_START(1, p);
for (const auto &t_path : session->declared_types) {
const auto &t = types.at(t_path);
const std::map<std::string,std::string>& get_config_defaults() {
if (config_defaults.empty() &&
config_defaults_bl.length()) {
- auto p = config_defaults_bl.begin();
+ auto p = config_defaults_bl.cbegin();
try {
decode(config_defaults, p);
} catch (buffer::error& e) {
CrushWrapper crush;
assert(self->inc->crush.length()); // see new_incremental
- auto p = self->inc->crush.begin();
+ auto p = self->inc->crush.cbegin();
decode(crush, p);
crush.create_choose_args(CrushWrapper::DEFAULT_CHOOSE_ARGS, 1);
for (auto i : wm) {
ENCODE_FINISH(bl);
}
-void ServiceMap::Daemon::decode(bufferlist::iterator& p)
+void ServiceMap::Daemon::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(gid, p);
ENCODE_FINISH(bl);
}
-void ServiceMap::Service::decode(bufferlist::iterator& p)
+void ServiceMap::Service::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(daemons, p);
ENCODE_FINISH(bl);
}
-void ServiceMap::decode(bufferlist::iterator& p)
+void ServiceMap::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(epoch, p);
std::map<std::string,std::string> metadata; ///< static metadata
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<Daemon*>& ls);
};
std::string summary; ///< summary status string for 'ceph -s'
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<Service*>& ls);
map<std::string,Service> services;
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<ServiceMap*>& ls);
// fail hard only if there's an error we're not expecting to see
assert(ret == 0);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(*keyring, p);
}
assert(latest_bl.length() != 0);
dout(7) << __func__ << " loading summary e " << latest_full << dendl;
dout(7) << __func__ << " latest length " << latest_bl.length() << dendl;
- bufferlist::iterator p = latest_bl.begin();
+ auto p = latest_bl.cbegin();
__u8 struct_v;
decode(struct_v, p);
decode(max_global_id, p);
dout(20) << __func__ << " walking through version " << (keys_ver+1)
<< " len " << bl.length() << dendl;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u8 v;
decode(v, p);
while (!p.end()) {
case AUTH_DATA:
{
KeyServerData::Incremental auth_inc;
- bufferlist::iterator iter = inc.auth_data.begin();
+ auto iter = inc.auth_data.cbegin();
decode(auth_inc, iter);
mon->key_server.apply_data_incremental(auth_inc);
break;
AuthCapsInfo caps_info;
MAuthReply *reply;
bufferlist response_bl;
- bufferlist::iterator indata = m->auth_payload.begin();
+ auto indata = m->auth_payload.cbegin();
__u32 proto = m->protocol;
bool start = false;
bool finished = false;
goto done;
}
if (caps_info.caps.length()) {
- bufferlist::iterator p = caps_info.caps.begin();
+ auto p = caps_info.caps.cbegin();
string str;
try {
decode(str, p);
for (auto& p : pending_auth) {
if (p.inc_type == AUTH_DATA) {
KeyServerData::Incremental inc;
- bufferlist::iterator q = p.auth_data.begin();
+ auto q = p.auth_data.cbegin();
decode(inc, q);
if (inc.op == KeyServerData::AUTH_INC_ADD &&
inc.name == entity) {
mon->reply_command(op, -EINVAL, rs, get_last_committed());
return true;
}
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
KeyRing keyring;
try {
decode(keyring, iter);
KeyRing new_keyring;
if (has_keyring) {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
try {
decode(new_keyring, iter);
} catch (const buffer::error &ex) {
++p) {
if (p->inc_type == AUTH_DATA) {
KeyServerData::Incremental auth_inc;
- bufferlist::iterator q = p->auth_data.begin();
+ auto q = p->auth_data.cbegin();
decode(auth_inc, q);
if (auth_inc.op == KeyServerData::AUTH_INC_ADD &&
auth_inc.name == entity) {
if (p->second.caps.count("mon") == 0)
continue;
try {
- bufferlist::iterator it = p->second.caps["mon"].begin();
+ auto it = p->second.caps["mon"].cbegin();
decode(mon_caps, it);
}
catch (const buffer::error&) {
if (n.find("mgr.") == 0 &&
p->second.caps.count("mon")) {
// the kraken ceph-mgr@.service set the mon cap to 'allow *'.
- auto blp = p->second.caps["mon"].begin();
+ auto blp = p->second.caps["mon"].cbegin();
string oldcaps;
decode(oldcaps, blp);
if (oldcaps == "allow *") {
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
__u32 _type;
decode(_type, bl);
while (it->valid() && it->key().find(prefix) == 0) {
if (it->key() == prefix) {
bufferlist bl = it->value();
- auto p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(ch->stamp, p);
decode(ch->name, p);
encode(start, bl);
encode(end, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(created, p);
decode(modified, p);
encode(queue, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(last_scan_epoch, bl);
decode(pgs, bl);
// stash leader's commands
assert(m->sharing_bl.length());
vector<MonCommand> new_cmds;
- bufferlist::iterator bi = m->sharing_bl.begin();
+ auto bi = m->sharing_bl.cbegin();
MonCommand::decode_vector(new_cmds, bi);
mon->set_leader_commands(new_cmds);
}
<< dendl;
CompatSet other;
- bufferlist::iterator bi = m->sharing_bl.begin();
+ auto bi = m->sharing_bl.cbegin();
other.decode(bi);
CompatSet diff = Monitor::get_supported_features().unsupported(other);
bufferlist qbl;
mon->store->get(service_name, "quorum", qbl);
if (qbl.length()) {
- auto p = qbl.begin();
+ auto p = qbl.cbegin();
decode(quorum_checks, p);
} else {
quorum_checks.clear();
bufferlist lbl;
mon->store->get(service_name, "leader", lbl);
if (lbl.length()) {
- auto p = lbl.begin();
+ auto p = lbl.cbegin();
decode(leader_checks, p);
} else {
leader_checks.clear();
get_version_full(latest_full, latest_bl);
assert(latest_bl.length() != 0);
dout(7) << __func__ << " loading summary e" << latest_full << dendl;
- bufferlist::iterator p = latest_bl.begin();
+ auto p = latest_bl.cbegin();
decode(summary, p);
dout(7) << __func__ << " loaded summary e" << summary.version << dendl;
}
assert(err == 0);
assert(bl.length());
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u8 v;
decode(v, p);
while (!p.end()) {
int err = get_version(sv, bl);
assert(err == 0);
assert(bl.length());
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u8 v;
decode(v,p);
while (!p.end()) {
derr << "Missing health data for MDS " << gid << dendl;
continue;
}
- bufferlist::iterator bl_i = bl.begin();
+ auto bl_i = bl.cbegin();
health.decode(bl_i);
}
for (const auto &metric : health.metrics) {
return r;
}
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
ceph::decode(m, it);
return 0;
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(name, bl);
decode(can_run, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p)
+ void decode(bufferlist::const_iterator& p)
{
DECODE_START(3, p);
decode(gid, p);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p)
+ void decode(bufferlist::const_iterator& p)
{
DECODE_START(4, p);
decode(epoch, p);
bool old_available = map.get_available();
uint64_t old_gid = map.get_active_gid();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
map.decode(p);
dout(4) << "active server: " << map.active_addr
if (r < 0) {
derr << "Failed to load mgr commands: " << cpp_strerror(r) << dendl;
} else {
- auto p = loaded_commands.begin();
+ auto p = loaded_commands.cbegin();
decode(command_descs, p);
}
}
goto reply;
}
MgrMap m;
- auto p = bl.begin();
+ auto p = bl.cbegin();
m.decode(p);
f->dump_object("mgrmap", m);
}
if (r < 0)
return r;
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(m, p);
}
catch (buffer::error& e) {
if (version) {
assert(bl.length());
try {
- auto p = bl.begin();
+ auto p = bl.cbegin();
decode(digest, p);
decode(service_map, p);
dout(10) << __func__ << " v" << version
{
auto m = static_cast<MMonMgrReport*>(op->get_req());
bufferlist bl = m->get_data();
- auto p = bl.begin();
+ auto p = bl.cbegin();
decode(pending_digest, p);
pending_health_checks.swap(m->health_checks);
if (m->service_map_bl.length()) {
ENCODE_FINISH(bl);
}
-void MonCap::decode(bufferlist::iterator& bl)
+void MonCap::decode(bufferlist::const_iterator& bl)
{
string s;
DECODE_START(4, bl);
bool op_may_read, bool op_may_write, bool op_may_exec) const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<MonCap*>& ls);
};
auto peer = m->get_source_addr();
string cur_mon = monmap.get_name(peer);
- bufferlist::iterator p = m->monmapbl.begin();
+ auto p = m->monmapbl.cbegin();
decode(monmap, p);
ldout(cct, 10) << " got monmap " << monmap.epoch
auth->set_global_id(global_id);
ldout(cct, 10) << "my global_id is " << m->global_id << dendl;
}
- auto p = m->result_bl.begin();
+ auto p = m->result_bl.cbegin();
int ret = auth->handle_response(m->result, p);
if (ret == -EAGAIN) {
auto ma = new MAuth;
bufferlist &payload = m->get_payload();
if (result && payload.length() > 0) {
- bufferlist::iterator p = payload.begin();
+ auto p = std::cbegin(payload);
decode(*result, p);
}
done = true;
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode_bare(bl);
decode(flags, bl);
encode(req_perms, bl);
encode(availability, bl);
}
- void decode_bare(bufferlist::iterator &bl) {
+ void decode_bare(bufferlist::const_iterator &bl) {
using ceph::decode;
decode(cmdstring, bl);
decode(helpstring, bl);
ENCODE_FINISH(bl);
}
static void decode_array(MonCommand **cmds, int *size,
- bufferlist::iterator &bl) {
+ bufferlist::const_iterator &bl) {
DECODE_START(2, bl);
uint16_t s = 0;
decode(s, bl);
ENCODE_FINISH(bl);
}
static void decode_vector(std::vector<MonCommand> &cmds,
- bufferlist::iterator &bl) {
+ bufferlist::const_iterator &bl) {
DECODE_START(2, bl);
uint16_t s = 0;
decode(s, bl);
ENCODE_FINISH(bl);
}
-void mon_info_t::decode(bufferlist::iterator& p)
+void mon_info_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(name, p);
ENCODE_FINISH(blist);
}
-void MonMap::decode(bufferlist::iterator &p)
+void MonMap::decode(bufferlist::const_iterator& p)
{
map<string,entity_addr_t> mon_addr;
DECODE_START_LEGACY_COMPAT_LEN_16(5, 3, 3, p);
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void print(ostream& out) const;
};
WRITE_CLASS_ENCODER_FEATURES(mon_info_t)
void encode(bufferlist& blist, uint64_t con_features) const;
void decode(bufferlist& blist) {
- bufferlist::iterator p = blist.begin();
+ auto p = std::cbegin(blist);
decode(p);
}
- void decode(bufferlist::iterator &p);
+ void decode(bufferlist::const_iterator& p);
void generate_fsid() {
fsid.generate_random();
t->put(MONITOR_NAME, COMPAT_SET_LOC, featuresbl);
store->apply_transaction(t);
} else {
- bufferlist::iterator it = featuresbl.begin();
+ auto it = featuresbl.cbegin();
features->decode(it);
}
}
if (err == 0 && bl.length() > 0) {
// Attempt to decode and extract keyring only if it is found.
KeyRing keyring;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(keyring, p);
extract_save_mon_key(keyring);
}
int r = store->get(MONITOR_NAME, "cluster_fingerprint", bl);
if (r >= 0) {
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(fingerprint, p);
}
catch (buffer::error& e) {
}
delete rr;
} else {
- bufferlist::iterator q = rr->request_bl.begin();
+ auto q = rr->request_bl.cbegin();
PaxosServiceMessage *req = (PaxosServiceMessage *)decode_message(cct, 0, q);
rr->op->mark_event("resend forwarded message to leader");
dout(10) << " resend to mon." << mon << " tid " << rr->tid << " " << *req << dendl;
int r = store->get(MONITOR_STORE_PREFIX, "last_metadata", bl);
if (r)
return r;
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
decode(mon_metadata, it);
pending_metadata = mon_metadata;
bufferlist bl;
bl.append(keyring_plaintext);
try {
- bufferlist::iterator i = bl.begin();
+ auto i = bl.cbegin();
keyring.decode_plaintext(i);
}
catch (const buffer::error& e) {
bufferlist ticket_data;
encode(blob, ticket_data);
- bufferlist::iterator iter = ticket_data.begin();
+ auto iter = ticket_data.cbegin();
CephXTicketHandler handler(g_ceph_context, service_id);
decode(handler.ticket, iter);
// monitor, and cephx is enabled
isvalid = false;
if (protocol == CEPH_AUTH_CEPHX) {
- bufferlist::iterator iter = authorizer_data.begin();
+ auto iter = authorizer_data.cbegin();
CephXServiceTicketInfo auth_ticket_info;
if (authorizer_data.length()) {
ENCODE_FINISH(encode_bl);
}
- void decode(bufferlist::iterator& decode_bl) {
+ void decode(bufferlist::const_iterator& decode_bl) {
DECODE_START(2, decode_bl);
decode(type, decode_bl);
decode(prefix, decode_bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(ops, bl);
if (struct_v >= 2) {
void append_from_encoded(bufferlist& bl) {
auto other(std::make_shared<Transaction>());
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
other->decode(it);
append(other);
}
assert(bl.length());
version_t ver;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(ver, p);
return ver;
}
else
osdmap.crush->encode(bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
newcrush.decode(p);
}
bufferlist bl;
if (!mon->store->get(OSD_PG_CREATING_PREFIX, "creating", bl)) {
- auto p = bl.begin();
+ auto p = bl.cbegin();
std::lock_guard<std::mutex> l(creating_pgs_lock);
creating_pgs.decode(p);
dout(7) << __func__ << " loading creating_pgs last_scan_epoch "
if (r < 0)
return r;
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(m, p);
}
catch (buffer::error& e) {
bufferlist v;
mon->store->get(OSD_SNAP_PREFIX, k, v);
if (v.length()) {
- auto q = v.begin();
+ auto q = v.cbegin();
OSDMap::snap_interval_set_t snaps;
decode(snaps, q);
t.union_of(snaps);
void OSDMonitor::reencode_incremental_map(bufferlist& bl, uint64_t features)
{
OSDMap::Incremental inc;
- bufferlist::iterator q = bl.begin();
+ auto q = bl.cbegin();
inc.decode(q);
// always encode with subset of osdmap's canonical features
uint64_t f = features & inc.encode_features;
if (inc.crush.length()) {
// embedded crush map
CrushWrapper c;
- auto p = inc.crush.begin();
+ auto p = inc.crush.cbegin();
c.decode(p);
inc.crush.clear();
c.encode(inc.crush, f);
void OSDMonitor::reencode_full_map(bufferlist& bl, uint64_t features)
{
OSDMap m;
- bufferlist::iterator q = bl.begin();
+ auto q = bl.cbegin();
m.decode(q);
// always encode with subset of osdmap's canonical features
uint64_t f = features & m.get_encoding_features();
ceph_assert(err == 0);
ceph_assert(inc_bl.length());
- bufferlist::iterator p = inc_bl.begin();
+ auto p = inc_bl.cbegin();
inc.decode(p);
dout(10) << __func__ << " "
<< " epoch " << inc.epoch
return -ENOENT;
}
bufferlist v = it->value();
- auto p = v.begin();
+ auto p = v.cbegin();
decode(*begin, p);
decode(*end, p);
if (snap < *begin || snap >= *end) {
bufferlist data(m->get_data());
CrushWrapper crush;
try {
- bufferlist::iterator bl(data.begin());
+ auto bl = data.cbegin();
crush.decode(bl);
}
catch (const std::exception &e) {
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl)
+ void decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
decode(pinned, bl);
}
void decode(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(p);
}
ENCODE_FINISH(bl);
}
-void PGMapDigest::decode(bufferlist::iterator& p)
+void PGMapDigest::decode(bufferlist::const_iterator& p)
{
DECODE_START(3, p);
decode(num_pg, p);
ENCODE_FINISH(bl);
}
-void PGMap::decode(bufferlist::iterator &bl)
+void PGMap::decode(bufferlist::const_iterator &bl)
{
DECODE_START(7, bl);
decode(version, bl);
encode(up, bl);
encode(primary, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(acting, p);
decode(up, p);
}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<PGMapDigest*>& ls);
};
void stat_osd_sub(int osd, const osd_stat_t &s);
void encode(bufferlist &bl, uint64_t features=-1) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
/// encode subset of our data to a PGMapDigest
void encode_digest(const OSDMap& osdmap,
t->dump(&f);
f.flush(*_dout);
auto debug_tx(std::make_shared<MonitorDBStore::Transaction>());
- bufferlist::iterator new_value_it = new_value.begin();
+ auto new_value_it = new_value.cbegin();
debug_tx->decode(new_value_it);
debug_tx->dump(&f);
*_dout << "\nbl dump:\n";
} else if (acked_lease.count(from) == 0) {
acked_lease.insert(from);
if (ack->feature_map.length()) {
- auto p = ack->feature_map.begin();
+ auto p = ack->feature_map.cbegin();
FeatureMap& t = mon->quorum_feature_map[from];
decode(t, p);
}
static void decode_append_transaction(MonitorDBStore::TransactionRef t,
bufferlist& bl) {
auto vt(std::make_shared<MonitorDBStore::Transaction>());
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
vt->decode(it);
t->append(vt);
}
<< " queued " << (ceph_clock_now() - p.proposal_time)
<< " tx dump:\n";
auto t(std::make_shared<MonitorDBStore::Transaction>());
- bufferlist::iterator p_it = p.bl.begin();
+ auto p_it = p.bl.cbegin();
t->decode(p_it);
JSONFormatter f(true);
t->dump(&f);
bufferlist bl;
mon->store->get("health", service_name, bl);
if (bl.length()) {
- auto p = bl.begin();
+ auto p = bl.cbegin();
decode(health_checks, p);
}
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(1, p);
decode(m, p);
DECODE_FINISH(p);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
decode(bytes_total, p);
decode(bytes_sst, p);
encode(store_stats, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
DECODE_START(1, p);
// we moved from having fields in kb to fields in byte
if (struct_v > 2) {
encode(prefix_keys, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(1, p);
decode(prefix_crc, p);
decode(prefix_keys, p);
encode(features, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(COMPAT_VERSION, p);
decode(features, p);
DECODE_FINISH(p);
encode(*p, bl);
}
-void Message::decode_trace(bufferlist::iterator &p, bool create)
+void Message::decode_trace(bufferlist::const_iterator &p, bool create)
{
blkin_trace_info info = {};
decode(info, p);
// We've slipped in a 0 signature at this point, so any signature checking after this will
// fail. PLR
-Message *decode_message(CephContext *cct, int crcflags, bufferlist::iterator& p)
+Message *decode_message(CephContext *cct, int crcflags, bufferlist::const_iterator& p)
{
ceph_msg_header h;
ceph_msg_footer_old fo;
// zipkin tracing
ZTracer::Trace trace;
void encode_trace(bufferlist &bl, uint64_t features) const;
- void decode_trace(bufferlist::iterator &p, bool create = false);
+ void decode_trace(bufferlist::const_iterator &p, bool create = false);
class CompletionHook : public Context {
protected:
extern void encode_message(Message *m, uint64_t features, bufferlist& bl);
extern Message *decode_message(CephContext *cct, int crcflags,
- bufferlist::iterator& bl);
+ bufferlist::const_iterator& bl);
#endif
bufferlist bl;
bl.append(state_buffer+banner_len, sizeof(ceph_entity_addr)*2);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(paddr, p);
decode(peer_addr_for_me, p);
}
authorizer_reply.append(state_buffer, connect_reply.authorizer_len);
- bufferlist::iterator iter = authorizer_reply.begin();
+ auto iter = authorizer_reply.cbegin();
if (authorizer && !authorizer->verify_reply(iter)) {
ldout(async_msgr->cct, 0) << __func__ << " failed verifying authorize reply" << dendl;
goto fail;
addr_bl.append(state_buffer+strlen(CEPH_BANNER), sizeof(ceph_entity_addr));
try {
- bufferlist::iterator ti = addr_bl.begin();
+ auto ti = addr_bl.cbegin();
decode(peer_addr, ti);
} catch (const buffer::error& e) {
lderr(async_msgr->cct) << __func__ << " decode peer_addr failed " << dendl;
encode(v, bl, features);
}
-void entity_addrvec_t::decode(bufferlist::iterator& bl)
+void entity_addrvec_t::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
__u8 marker;
::encode_raw(ss, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
struct ceph_sockaddr_storage ss;
::decode_raw(ss, bl);
ss.ss_family = ntohs(ss.ss_family);
encode(ss, bl);
#endif
}
-static inline void decode(sockaddr_storage& a, bufferlist::iterator& bl) {
+static inline void decode(sockaddr_storage& a, bufferlist::const_iterator& bl) {
#if defined(__linux__)
::decode_raw(a, bl);
a.ss_family = ntohs(a.ss_family);
bool parse(const char *s, const char **end = 0);
- void decode_legacy_addr_after_marker(bufferlist::iterator& bl)
+ void decode_legacy_addr_after_marker(bufferlist::const_iterator& bl)
{
using ceph::decode;
__u8 marker;
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 marker;
decode(marker, bl);
bool empty() const { return v.empty(); }
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<entity_addrvec_t*>& ls);
};
encode(name, bl);
encode(addr, bl, features);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(name, bl);
decode(addr, bl);
goto fail_unlocked;
}
try {
- bufferlist::iterator ti = addrbl.begin();
+ auto ti = addrbl.cbegin();
decode(peer_addr, ti);
} catch (const buffer::error& e) {
ldout(msgr->cct,2) << __func__ << " decode peer_addr failed: " << e.what()
goto fail;
}
try {
- bufferlist::iterator p = addrbl.begin();
+ auto p = addrbl.cbegin();
decode(paddr, p);
decode(peer_addr_for_me, p);
}
}
if (authorizer) {
- bufferlist::iterator iter = authorizer_reply.begin();
+ auto iter = authorizer_reply.cbegin();
if (!authorizer->verify_reply(iter)) {
ldout(msgr->cct,0) << "failed verifying authorize reply" << dendl;
goto fail;
ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
if (ret < 0)
return ret;
- bufferlist::iterator iter = ops[0].outdata.begin();
+ auto iter = ops[0].outdata.cbegin();
utime_t ut;
uint64_t s;
try {
ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
if (ret < 0)
return ret;
- bufferlist::iterator iter = ops[0].outdata.begin();
+ auto iter = ops[0].outdata.cbegin();
real_time ut;
uint64_t s;
try {
if (r < 0)
return r;
- bufferlist::iterator iter = op.outdata.begin();
+ auto iter = op.outdata.cbegin();
try {
decode(*attrset, iter);
} catch (buffer::error& err) {
if (ret < 0)
return ret;
- bufferlist::iterator iter = op.outdata.begin();
+ auto iter = op.outdata.cbegin();
try {
decode(*vals, iter);
decode(*more, iter);
if (ret < 0)
return ret;
- bufferlist::iterator iter = op.outdata.begin();
+ auto iter = op.outdata.cbegin();
try {
decode(*keys, iter);
decode(*more, iter);
if (ret < 0)
return ret;
- bufferlist::iterator iter = op.outdata.begin();
+ auto iter = op.outdata.cbegin();
try {
decode(*vals, iter);
decode(*more, iter);
if (ret < 0)
return ret;
- bufferlist::iterator iter = op.outdata.begin();
+ auto iter = op.outdata.cbegin();
try {
map<string, bufferlist> m;
if (r < 0)
return r;
- bufferlist::iterator iter = op.outdata.begin();
+ auto iter = op.outdata.cbegin();
try {
decode(*watchers, iter);
} catch (buffer::error& err) {
* handle any encoding errors, and return an appropriate error code,
* or 0 on valid input.
*/
- virtual int init(bufferlist::iterator ¶ms) = 0;
+ virtual int init(bufferlist::const_iterator ¶ms) = 0;
/**
* xattr key, or empty string. If non-empty, this xattr will be fetched
#endif
#include "kstore/KStore.h"
-void decode_str_str_map_to_bl(bufferlist::iterator& p,
+void decode_str_str_map_to_bl(bufferlist::const_iterator& p,
bufferlist *out)
{
- bufferlist::iterator start = p;
+ auto start = p;
__u32 n;
decode(n, p);
unsigned len = 4;
start.copy(len, *out);
}
-void decode_str_set_to_bl(bufferlist::iterator& p,
+void decode_str_set_to_bl(bufferlist::const_iterator& p,
bufferlist *out)
{
- bufferlist::iterator start = p;
+ auto start = p;
__u32 n;
decode(n, p);
unsigned len = 4;
}
// this isn't the best place for these, but...
-void decode_str_str_map_to_bl(bufferlist::iterator& p, bufferlist *out);
-void decode_str_set_to_bl(bufferlist::iterator& p, bufferlist *out);
+void decode_str_str_map_to_bl(bufferlist::const_iterator& p, bufferlist *out);
+void decode_str_set_to_bl(bufferlist::const_iterator& p, bufferlist *out);
// Flag bits
typedef uint32_t osflagbits_t;
void encode(bufferlist& bl) const {
bl.append((char*)this, sizeof(TransactionData));
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
bl.copy(sizeof(TransactionData), (char*)this);
}
} __attribute__ ((packed)) ;
public:
Transaction() = default;
- explicit Transaction(bufferlist::iterator &dp) {
+ explicit Transaction(bufferlist::const_iterator &dp) {
decode(dp);
}
explicit Transaction(bufferlist &nbl) {
- bufferlist::iterator dp = nbl.begin();
+ auto dp = nbl.cbegin();
decode(dp);
}
uint64_t ops;
char* op_buffer_p;
- bufferlist::iterator data_bl_p;
+ bufferlist::const_iterator data_bl_p;
public:
vector<coll_t> colls;
private:
explicit iterator(Transaction *t)
: t(t),
- data_bl_p(t->data_bl.begin()),
+ data_bl_p(t->data_bl.cbegin()),
colls(t->coll_index.size()),
objects(t->object_index.size()) {
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(9, bl);
DECODE_OLDEST(9);
f->dump_unsigned("type", type);
bufferlist hint;
i.decode_bl(hint);
- bufferlist::iterator hiter = hint.begin();
+ auto hiter = hint.cbegin();
if (type == Transaction::COLL_HINT_EXPECTED_NUM_OBJECTS) {
uint32_t pg_num;
uint64_t num_objs;
string k = it->key();
if (k == "bytes_per_block") {
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(bytes_per_block, p);
dout(10) << __func__ << " bytes_per_block 0x" << std::hex
<< bytes_per_block << std::dec << dendl;
} else if (k == "blocks") {
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(blocks, p);
dout(10) << __func__ << " blocks 0x" << std::hex << blocks << std::dec
<< dendl;
} else if (k == "size") {
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(size, p);
dout(10) << __func__ << " size 0x" << std::hex << size << std::dec
<< dendl;
} else if (k == "blocks_per_key") {
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(blocks_per_key, p);
dout(10) << __func__ << " blocks_per_key 0x" << std::hex << blocks_per_key
<< std::dec << dendl;
if (r < 0)
return r;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(super, p);
{
bufferlist t;
uint64_t seq;
uuid_d uuid;
{
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u8 a, b;
uint32_t len;
decode(a, p);
}
bluefs_transaction_t t;
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(t, p);
}
catch (buffer::error& e) {
<< ": " << t << std::endl;
}
- bufferlist::iterator p = t.op_bl.begin();
+ auto p = t.op_bl.cbegin();
while (!p.end()) {
__u8 op;
decode(op, p);
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
#ifndef CACHE_BLOB_BL
void BlueStore::Blob::decode(
Collection *coll,
- bufferptr::iterator& p,
+ bufferptr::const_iterator& p,
uint64_t struct_v,
uint64_t* sbid,
bool include_ref_map)
}
void BlueStore::ExtentMap::decode_spanning_blobs(
- bufferptr::iterator& p)
+ bufferptr::const_iterator& p)
{
__u8 struct_v;
denc(struct_v, p);
sb->loaded = true;
sb->persistent = new bluestore_shared_blob_t(sbid);
- bufferlist::iterator p = v.begin();
+ auto p = v.cbegin();
decode(*(sb->persistent), p);
ldout(store->cct, 10) << __func__ << " sbid 0x" << std::hex << sbid
<< std::dec << " loaded shared_blob " << *sb << dendl;
assert(r >= 0);
on = new Onode(this, oid, key);
on->exists = true;
- bufferptr::iterator p = v.front().begin_deep();
+ auto p = v.front().begin_deep();
on->onode.decode(p);
for (auto& i : on->onode.attrs) {
i.second.reassign_to_mempool(mempool::mempool_bluestore_cache_other);
}
uint32_t crc, expected_crc;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(*label, p);
bufferlist t;
cache_shards[cid.hash_to_shard(cache_shards.size())],
cid));
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(c->cnode, p);
} catch (buffer::error& e) {
int r = db->get(PREFIX_STAT, "bluestore_statfs", &bl);
if (r >= 0) {
if (size_t(bl.length()) >= sizeof(vstatfs.values)) {
- auto it = bl.begin();
+ auto it = bl.cbegin();
vstatfs.decode(it);
} else {
dout(10) << __func__ << " store_statfs is corrupt, using empty" << dendl;
sb_info_t& sbi = p->second;
bluestore_shared_blob_t shared_blob(sbid);
bufferlist bl = it->value();
- bufferlist::iterator blp = bl.begin();
+ auto blp = bl.cbegin();
try {
decode(shared_blob, blp);
} catch (buffer::error& e) {
if (it) {
for (it->lower_bound(string()); it->valid(); it->next()) {
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
bluestore_deferred_transaction_t wt;
try {
decode(wt, p);
{
int r = 0;
utime_t start = ceph_clock_now();
- bufferlist::iterator i = source.begin();
+ auto i = source.cbegin();
bluestore_compression_header_t chdr;
decode(chdr, i);
int alg = int(chdr.type);
nid_max = 0;
bufferlist bl;
db->get(PREFIX_SUPER, "nid_max", &bl);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
uint64_t v;
decode(v, p);
blobid_max = 0;
bufferlist bl;
db->get(PREFIX_SUPER, "blobid_max", &bl);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
uint64_t v;
decode(v, p);
bluefs_extents.clear();
bufferlist bl;
db->get(PREFIX_SUPER, "bluefs_extents", &bl);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(bluefs_extents, p);
}
ondisk_format = 1;
compat_ondisk_format = 1;
} else {
- auto p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(ondisk_format, p);
} catch (buffer::error& e) {
{
r = db->get(PREFIX_SUPER, "min_compat_ondisk_format", &bl);
assert(!r);
- auto p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(compat_ondisk_format, p);
} catch (buffer::error& e) {
{
bufferlist bl;
db->get(PREFIX_SUPER, "min_alloc_size", &bl);
- auto p = bl.begin();
+ auto p = bl.cbegin();
try {
uint64_t val;
decode(val, p);
{
bufferlist bl;
db->get(PREFIX_SUPER, "min_min_alloc_size", &bl);
- auto p = bl.begin();
+ auto p = bl.cbegin();
try {
uint64_t val;
decode(val, p);
bluestore_deferred_transaction_t *deferred_txn =
new bluestore_deferred_transaction_t;
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(*deferred_txn, p);
} catch (buffer::error& e) {
uint32_t type = op->hint_type;
bufferlist hint;
i.decode_bl(hint);
- bufferlist::iterator hiter = hint.begin();
+ auto hiter = hint.cbegin();
if (type == Transaction::COLL_HINT_EXPECTED_NUM_OBJECTS) {
uint32_t pg_num;
uint64_t num_objs;
{
dout(15) << __func__ << " " << c->cid << " " << o->oid << dendl;
int r;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u32 num;
if (!o->onode.has_omap()) {
o->onode.set_omap_flag();
{
dout(15) << __func__ << " " << c->cid << " " << o->oid << dendl;
int r = 0;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u32 num;
string final_key;
}
void decode(
Collection */*coll*/,
- bufferptr::iterator& p,
+ bufferptr::const_iterator& p,
bool include_ref_map) {
const char *start = p.get_pos();
denc(blob, p);
}
void decode(
Collection *coll,
- bufferptr::iterator& p,
+ bufferptr::const_iterator& p,
uint64_t struct_v,
uint64_t* sbid,
bool include_ref_map);
void bound_encode_spanning_blobs(size_t& p);
void encode_spanning_blobs(bufferlist::contiguous_appender& p);
- void decode_spanning_blobs(bufferptr::iterator& p);
+ void decode_spanning_blobs(bufferptr::const_iterator& p);
BlobRef get_spanning_blob(int id) {
auto p = spanning_blob_map.find(id);
values[STATFS_COMPRESSED_ORIGINAL] == 0 &&
values[STATFS_COMPRESSED_ALLOCATED] == 0;
}
- void decode(bufferlist::iterator& it) {
+ void decode(bufferlist::const_iterator& it) {
using ceph::decode;
for (size_t i = 0; i < STATFS_LAST; i++) {
decode(values[i], it);
ENCODE_FINISH(bl);
}
-void bluefs_super_t::decode(bufferlist::iterator& p)
+void bluefs_super_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(uuid, p);
ENCODE_FINISH(bl);
}
-void bluefs_transaction_t::decode(bufferlist::iterator& p)
+void bluefs_transaction_t::decode(bufferlist::const_iterator& p)
{
uint32_t crc;
DECODE_START(1, p);
_denc_friend(*this, p);
DENC_DUMP_POST(bluefs_fnode_t);
}
- void decode(buffer::ptr::iterator& p) {
+ void decode(buffer::ptr::const_iterator& p) {
_denc_friend(*this, p);
recalc_allocated();
}
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<bluefs_super_t*>& ls);
};
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instance(list<bluefs_transaction_t*>& ls);
};
ENCODE_FINISH(bl);
}
-void bluestore_bdev_label_t::decode(bufferlist::iterator& p)
+void bluestore_bdev_label_t::decode(bufferlist::const_iterator& p)
{
p.advance(60); // see above
DECODE_START(2, p);
map<string,string> meta; ///< {read,write}_meta() content from ObjectStore
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<bluestore_bdev_label_t*>& o);
};
denc(i, p);
}
}
- static void decode(PExtentVector& v, bufferptr::iterator& p) {
+ static void decode(PExtentVector& v, bufferptr::const_iterator& p) {
unsigned num;
denc_varint(num, p);
v.clear();
}
}
void encode(bufferlist::contiguous_appender& p) const {
- uint32_t n = ref_map.size();
+ const uint32_t n = ref_map.size();
denc_varint(n, p);
if (n) {
auto i = ref_map.begin();
denc_varint_lowz(i->first, p);
i->second.encode(p);
int64_t pos = i->first;
- while (--n) {
- ++i;
+ while (++i != ref_map.end()) {
denc_varint_lowz((int64_t)i->first - pos, p);
i->second.encode(p);
pos = i->first;
}
}
}
- void decode(bufferptr::iterator& p) {
+ void decode(bufferptr::const_iterator& p) {
uint32_t n;
denc_varint(n, p);
if (n) {
}
}
}
- void decode(bufferptr::iterator& p) {
+ void decode(bufferptr::const_iterator& p) {
clear();
denc_varint(au_size, p);
if (au_size) {
}
}
- void decode(bufferptr::iterator& p, uint64_t struct_v) {
+ void decode(bufferptr::const_iterator& p, uint64_t struct_v) {
assert(struct_v == 1 || struct_v == 2);
denc(extents, p);
denc_varint(flags, p);
_Header header;
bufferlist bl = iter->value();
while (true) {
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
header.decode(bliter);
if (header.seq != 0)
parent_to_actual_num_children[header.seq] = header.num_children;
// decode header to get oid
_Header hdr;
bufferlist bl = iter->value();
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
hdr.decode(bliter);
string newkey(ghobject_key(hdr.oid));
if (r < 0)
return r;
if (!result.empty()) {
- bufferlist::iterator bliter = result.begin()->second.begin();
+ auto bliter = result.begin()->second.cbegin();
state.decode(bliter);
} else {
// New store
}
Header ret(header, RemoveOnDelete(this));
- bufferlist::iterator iter = out.begin();
-
+ auto iter = out.cbegin();
ret->decode(iter);
{
Mutex::Locker l(cache_lock);
}
Header header = Header(new _Header(), RemoveOnDelete(this));
- bufferlist::iterator iter = out.begin()->second.begin();
+ auto iter = out.begin()->second.cbegin();
header->decode(iter);
assert(header->seq == input->parent);
dout(20) << "lookup_parent: parent seq is " << header->seq << " with parent "
KeyValueDB::Iterator iter = db->get_iterator(HOBJECT_TO_SEQ);
for (iter->seek_to_first(); iter->valid(); iter->next()) {
bufferlist bl = iter->value();
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
_Header header;
header.decode(bliter);
out->push_back(header.oid);
KeyValueDB::Iterator iter = db->get_iterator(HOBJECT_TO_SEQ);
for (iter->seek_to_first(); iter->valid(); iter->next()) {
bufferlist bl = iter->value();
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
_Header header;
header.decode(bliter);
out->push_back(header);
break;
} else {
bl = got.begin()->second;
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
header.decode(bliter);
out->push_back(header);
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(3, bl);
if (struct_v >= 2)
decode(v, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
coll_t unused;
DECODE_START(2, bl);
decode(seq, bl);
f.dump_unsigned("bl.length", bl.length());
} else {
f.open_array_section("transactions");
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
int trans_num = 0;
while (!p.end()) {
ObjectStore::Transaction t(p);
bl.push_back(std::move(bp));
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(*hdr, p);
}
catch (buffer::error& e) {
}
encode(em, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u32 v;
decode(v, bl);
}
bufferlist em;
decode(em, bl);
- bufferlist::iterator t = em.begin();
+ auto t = em.cbegin();
decode(flags, t);
decode(fsid, t);
decode(block_size, t);
bufferlist bl;
bl.push_back(std::move(bp));
- bufferlist::iterator i = bl.begin();
+ auto i = bl.cbegin();
decode(superblock, i);
return 0;
}
}
bufferlist bl;
bl.push_back(std::move(bp));
- bufferlist::iterator i = bl.begin();
+ auto i = bl.cbegin();
decode(*version, i);
dout(10) << __FUNC__ << ": was " << *version << " vs target "
<< target_version << dendl;
bl.append(buf, r);
SequencerPosition opos;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(opos, p);
VOID_TEMP_FAILURE_RETRY(::close(fd));
bl.append(buf, r);
SequencerPosition opos;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(opos, p);
bool in_progress = false;
if (!p.end()) // older journals don't have this
uint32_t type = op->hint_type;
bufferlist hint;
i.decode_bl(hint);
- bufferlist::iterator hiter = hint.begin();
+ auto hiter = hint.cbegin();
if (type == Transaction::COLL_HINT_EXPECTED_NUM_OBJECTS) {
uint32_t pg_num;
uint64_t num_objs;
ENCODE_FINISH(bl);
}
-void FSSuperblock::decode(bufferlist::iterator &bl)
+void FSSuperblock::decode(bufferlist::const_iterator &bl)
{
DECODE_START(2, bl);
compat_features.decode(bl);
FSSuperblock() { }
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<FSSuperblock*>& o);
};
}
bufferlist bl;
bl.append(std::move(bp));
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(*cm, p);
}
// No in progress operations!
return 0;
}
- bufferlist::iterator i = bl.begin();
+ auto i = bl.cbegin();
InProgressOp in_progress(i);
subdir_info_s info;
r = get_info(in_progress.path, &info);
derr << __func__ << " error reading settings: " << cpp_strerror(r) << dendl;
return r;
}
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
settings.decode(it);
dout(20) << __func__ << " split_rand_factor = " << settings.split_rand_factor << dendl;
return 0;
int r = get_attr_path(path, SUBDIR_ATTR, buf);
if (r < 0)
return r;
- bufferlist::iterator bufiter = buf.begin();
+ auto bufiter = buf.cbegin();
info->decode(bufiter);
assert(path.size() == (unsigned)info->hash_level);
return 0;
encode(hash_level, bl);
}
- void decode(bufferlist::iterator &bl)
+ void decode(bufferlist::const_iterator &bl)
{
using ceph::decode;
__u8 v;
encode(v, bl);
encode(split_rand_factor, bl);
}
- void decode(bufferlist::iterator &bl)
+ void decode(bufferlist::const_iterator &bl)
{
using ceph::decode;
__u8 v;
InProgressOp(int op, const vector<string> &path)
: op(op), path(path) {}
- explicit InProgressOp(bufferlist::iterator &bl) {
+ explicit InProgressOp(bufferlist::const_iterator &bl) {
decode(bl);
}
encode(path, bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
using ceph::decode;
__u8 v;
decode(v, bl);
bp.set_length(r);
bufferlist bl;
bl.push_back(bp);
- bufferlist::iterator i = bl.begin();
+ auto i = bl.cbegin();
decode(*version, i);
return 0;
}
assert(op_seq == seq-1);
dout(3) << "journal_replay: applying op seq " << seq << dendl;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
vector<ObjectStore::Transaction> tls;
while (!p.end()) {
tls.emplace_back(Transaction(p));
encode(op, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(1, p);
decode(seq, p);
decode(trans, p);
assert(r >=0);
on = new Onode(store->cct, oid, key);
on->exists = true;
- bufferlist::iterator p = v.begin();
+ auto p = v.cbegin();
decode(on->onode, p);
}
o.reset(on);
if (cid.parse(it->key())) {
CollectionRef c(new Collection(this, cid));
bufferlist bl = it->value();
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(c->cnode, p);
} catch (buffer::error& e) {
nid_max = 0;
bufferlist bl;
db->get(PREFIX_SUPER, "nid_max", &bl);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(nid_max, p);
} catch (buffer::error& e) {
uint32_t type = op->hint_type;
bufferlist hint;
i.decode_bl(hint);
- bufferlist::iterator hiter = hint.begin();
+ auto hiter = hint.cbegin();
if (type == Transaction::COLL_HINT_EXPECTED_NUM_OBJECTS) {
uint32_t pg_num;
uint64_t num_objs;
{
dout(15) << __func__ << " " << c->cid << " " << o->oid << dendl;
int r;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u32 num;
if (!o->onode.omap_head) {
o->onode.omap_head = o->onode.nid;
int KStore::_omap_rmkeys(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- bufferlist& bl)
+ const bufferlist& bl)
{
dout(15) << __func__ << " " << c->cid << " " << o->oid << dendl;
int r = 0;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u32 num;
if (!o->onode.omap_head) {
int _omap_rmkeys(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
- bufferlist& bl);
+ const bufferlist& bl);
int _omap_rmkey_range(TransContext *txc,
CollectionRef& c,
OnodeRef& o,
ENCODE_FINISH(bl);
}
-void kstore_cnode_t::decode(bufferlist::iterator& p)
+void kstore_cnode_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(bits, p);
ENCODE_FINISH(bl);
}
-void kstore_onode_t::decode(bufferlist::iterator& p)
+void kstore_onode_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(nid, p);
explicit kstore_cnode_t(int b=0) : bits(b) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<kstore_cnode_t*>& o);
};
alloc_hint_flags(0) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<kstore_onode_t*>& o);
};
return r;
set<coll_t> collections;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(collections, p);
for (set<coll_t>::iterator q = collections.begin();
if (r < 0)
return r;
CollectionRef c(new Collection(cct, *q));
- bufferlist::iterator p = cbl.begin();
+ auto p = cbl.cbegin();
c->decode(p);
coll_map[*q] = c;
used_bytes += c->used_bytes();
uint32_t type = op->hint_type;
bufferlist hint;
i.decode_bl(hint);
- bufferlist::iterator hiter = hint.begin();
+ auto hiter = hint.cbegin();
if (type == Transaction::COLL_HINT_EXPECTED_NUM_OBJECTS) {
uint32_t pg_num;
uint64_t num_objs;
if (!o)
return -ENOENT;
std::lock_guard<std::mutex> lock(o->omap_mutex);
- bufferlist::iterator p = aset_bl.begin();
+ auto p = aset_bl.cbegin();
__u32 num;
decode(num, p);
while (num--) {
if (!o)
return -ENOENT;
std::lock_guard<std::mutex> lock(o->omap_mutex);
- bufferlist::iterator p = keys_bl.begin();
+ auto p = keys_bl.cbegin();
__u32 num;
decode(num, p);
while (num--) {
encode_base(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) override {
+ void decode(bufferlist::const_iterator& p) override {
DECODE_START(1, p);
decode(data, p);
decode_base(p);
encode_base(bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) override {
+ void decode(bufferlist::const_iterator& p) override {
DECODE_START(1, p);
decode(data_len, p);
data.decode(p);
uint64_t dstoff) = 0;
virtual int truncate(uint64_t offset) = 0;
virtual void encode(bufferlist& bl) const = 0;
- virtual void decode(bufferlist::iterator& p) = 0;
+ virtual void decode(bufferlist::const_iterator& p) = 0;
void encode_base(bufferlist& bl) const {
using ceph::encode;
encode(omap_header, bl);
encode(omap, bl);
}
- void decode_base(bufferlist::iterator& p) {
+ void decode_base(bufferlist::const_iterator& p) {
using ceph::decode;
decode(xattr, p);
decode(omap_header, p);
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(1, p);
decode(xattr, p);
decode(use_page_set, p);
bl.append(buffer::copy(data, page_size));
encode(offset, bl);
}
- void decode(bufferlist::iterator &p, size_t page_size) {
+ void decode(bufferlist::const_iterator &p, size_t page_size) {
using ceph::decode;
p.copy(page_size, data);
decode(offset, p);
for (auto p = pages.rbegin(); p != pages.rend(); ++p)
p->encode(bl, page_size);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
using ceph::decode;
assert(empty());
decode(page_size, p);
ECUtil::HashInfo hinfo(ec_impl->get_chunk_count());
if (op.obc->obs.oi.size > 0) {
assert(op.xattrs.count(ECUtil::get_hinfo_key()));
- bufferlist::iterator bp = op.xattrs[ECUtil::get_hinfo_key()].begin();
+ auto bp = op.xattrs[ECUtil::get_hinfo_key()].cbegin();
decode(hinfo, bp);
}
op.hinfo = unstable_hashinfo_registry.lookup_or_create(hoid, hinfo);
}
}
if (bl.length() > 0) {
- bufferlist::iterator bp = bl.begin();
+ auto bp = bl.cbegin();
try {
decode(hinfo, bp);
} catch(...) {
ENCODE_FINISH(bl);
}
-void ECSubWrite::decode(bufferlist::iterator &bl)
+void ECSubWrite::decode(bufferlist::const_iterator &bl)
{
DECODE_START(4, bl);
decode(from, bl);
ENCODE_FINISH(bl);
}
-void ECSubWriteReply::decode(bufferlist::iterator &bl)
+void ECSubWriteReply::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(from, bl);
ENCODE_FINISH(bl);
}
-void ECSubRead::decode(bufferlist::iterator &bl)
+void ECSubRead::decode(bufferlist::const_iterator &bl)
{
DECODE_START(3, bl);
decode(from, bl);
ENCODE_FINISH(bl);
}
-void ECSubReadReply::decode(bufferlist::iterator &bl)
+void ECSubReadReply::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(from, bl);
backfill_or_async_recovery = other.backfill_or_async_recovery;
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ECSubWrite*>& o);
private:
bool applied;
ECSubWriteReply() : tid(0), committed(false), applied(false) {}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ECSubWriteReply*>& o);
};
set<hobject_t> attrs_to_read;
map<hobject_t, vector<pair<int, int>>> subchunks;
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ECSubRead*>& o);
};
map<hobject_t, map<string, bufferlist>> attrs_read;
map<hobject_t, int> errors;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ECSubReadReply*>& o);
};
ENCODE_FINISH(bl);
}
-void ECUtil::HashInfo::decode(bufferlist::iterator &bl)
+void ECUtil::HashInfo::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(total_chunk_size, bl);
-1);
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(std::list<HashInfo*>& o);
uint32_t get_chunk_hash(int shard) const {
ENCODE_FINISH(bl);
}
-void HitSet::decode(bufferlist::iterator &bl)
+void HitSet::decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
decode(sealed, bl);
// instead.
bufferlist bl;
o.impl->encode(bl);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
impl->decode(p);
} // else we don't need to do anything
}
// instead.
bufferlist bl;
o.impl->encode(bl);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
impl->decode(p);
}
return *this;
return true;
}
-void HitSet::Params::decode(bufferlist::iterator &bl)
+void HitSet::Params::decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
__u8 type;
virtual unsigned insert_count() const = 0;
virtual unsigned approx_unique_insert_count() const = 0;
virtual void encode(bufferlist &bl) const = 0;
- virtual void decode(bufferlist::iterator& p) = 0;
+ virtual void decode(bufferlist::const_iterator& p) = 0;
virtual void dump(Formatter *f) const = 0;
virtual Impl* clone() const = 0;
virtual void seal() {}
virtual impl_type_t get_type() const = 0;
virtual HitSet::Impl *get_new_impl() const = 0;
virtual void encode(bufferlist &bl) const {}
- virtual void decode(bufferlist::iterator& p) {}
+ virtual void decode(bufferlist::const_iterator& p) {}
virtual void dump(Formatter *f) const {}
virtual void dump_stream(ostream& o) const {}
virtual ~Impl() {}
const Params& operator=(const Params& o);
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<HitSet::Params*>& o);
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<HitSet*>& o);
encode(hits, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) override {
+ void decode(bufferlist::const_iterator &bl) override {
DECODE_START(1, bl);
decode(count, bl);
decode(hits, bl);
encode(hits, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) override {
+ void decode(bufferlist::const_iterator& bl) override {
DECODE_START(1, bl);
decode(count, bl);
decode(hits, bl);
encode(seed, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) override {
+ void decode(bufferlist::const_iterator& bl) override {
DECODE_START(1, bl);
decode(fpp_micro, bl);
decode(target_size, bl);
// oh god
bufferlist bl;
o.encode(bl);
- bufferlist::iterator bli = bl.begin();
+ auto bli = std::cbegin(bl);
this->decode(bli);
}
encode(bloom, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) override {
+ void decode(bufferlist::const_iterator& bl) override {
DECODE_START(1, bl);
decode(bloom, bl);
DECODE_FINISH(bl);
bufferlist bl;
int r = store->read(meta_ch, oid, 0, 0, bl);
ceph_assert(r >= 0);
- auto blp = bl.begin();
+ auto blp = bl.cbegin();
pg_pool_t pi;
::decode(pi, blp);
deleted_pool_pg_nums[pool] = pi.get_pg_num();
}
/* if we already have superblock, check content of superblock */
dout(0) << " have superblock" << dendl;
- bufferlist::iterator p;
- p = sbbl.begin();
+ auto p = sbbl.cbegin();
decode(sb, p);
if (whoami != sb.whoami) {
derr << "provided osd id " << whoami << " != superblock's " << sb.whoami
if (r < 0)
return r;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(superblock, p);
dout(10) << "read_superblock " << superblock << dendl;
return nullptr;
}
ceph_assert(r >= 0);
- auto p = bl.begin();
+ auto p = bl.cbegin();
decode(pi, p);
decode(name, p);
if (p.end()) { // dev release v13.0.2 did not include ec_profile
s->auid = auid;
if (caps_info.caps.length() > 0) {
- bufferlist::iterator p = caps_info.caps.begin();
+ auto p = caps_info.caps.cbegin();
string str;
try {
decode(str, p);
}
OSDMap::Incremental inc;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
inc.decode(p);
if (o->apply_incremental(inc) < 0) {
derr << "ERROR: bad fsid? i have " << osdmap->get_fsid() << " and inc has " << inc.fsid << dendl;
encode(lost_at, bl);
}
-void osd_info_t::decode(bufferlist::iterator& bl)
+void osd_info_t::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
__u8 struct_v;
ENCODE_FINISH(bl);
}
-void osd_xinfo_t::decode(bufferlist::iterator& bl)
+void osd_xinfo_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START(3, bl);
decode(down_stamp, bl);
have_crc = true;
}
-void OSDMap::Incremental::decode_classic(bufferlist::iterator &p)
+void OSDMap::Incremental::decode_classic(bufferlist::const_iterator &p)
{
using ceph::decode;
__u32 n, t;
decode(new_hb_front_up, p);
}
-void OSDMap::Incremental::decode(bufferlist::iterator& bl)
+void OSDMap::Incremental::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
/**
f->open_object_section("full_map");
OSDMap full;
bufferlist fbl = fullmap; // kludge around constness.
- auto p = fbl.begin();
+ auto p = fbl.cbegin();
full.decode(p);
full.dump(f);
f->close_section();
f->open_object_section("crush");
CrushWrapper c;
bufferlist tbl = crush; // kludge around constness.
- auto p = tbl.begin();
+ auto p = tbl.cbegin();
c.decode(p);
c.dump(f);
f->close_section();
// do new crush map last (after up/down stuff)
if (inc.crush.length()) {
bufferlist bl(inc.crush);
- auto blp = bl.begin();
+ auto blp = bl.cbegin();
crush.reset(new CrushWrapper);
crush->decode(blp);
if (require_osd_release >= CEPH_RELEASE_LUMINOUS) {
void OSDMap::decode(bufferlist& bl)
{
- auto p = bl.begin();
+ auto p = bl.cbegin();
decode(p);
}
-void OSDMap::decode_classic(bufferlist::iterator& p)
+void OSDMap::decode_classic(bufferlist::const_iterator& p)
{
using ceph::decode;
__u32 n, t;
// crush
bufferlist cbl;
decode(cbl, p);
- auto cblp = cbl.begin();
+ auto cblp = cbl.cbegin();
crush->decode(cblp);
// extended
post_decode();
}
-void OSDMap::decode(bufferlist::iterator& bl)
+void OSDMap::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
/**
// crush
bufferlist cbl;
decode(cbl, bl);
- auto cblp = cbl.begin();
+ auto cblp = cbl.cbegin();
crush->decode(cblp);
if (struct_v >= 3) {
decode(erasure_code_profiles, bl);
void dump(Formatter *f) const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
static void generate_test_instances(list<osd_info_t*>& o);
};
WRITE_CLASS_ENCODER(osd_info_t)
void dump(Formatter *f) const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
static void generate_test_instances(list<osd_xinfo_t*>& o);
};
WRITE_CLASS_ENCODER(osd_xinfo_t)
bl.append((char*)p.second, (*p.second + 1) * sizeof(int32_t));
}
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
data.clear();
map.clear();
decode(n, p);
if (!n)
return;
- bufferlist::iterator pstart = p;
+ auto pstart = p;
size_t start_off = pstart.get_off();
vector<pair<pg_t,size_t>> offsets;
offsets.resize(n);
void rebuild() {
bufferlist bl;
encode(bl);
- auto p = bl.begin();
+ auto p = std::cbegin(bl);
decode(p);
}
friend bool operator==(const PGTempMap& l, const PGTempMap& r) {
void encode(bufferlist& bl) const {
encode(pg_temp, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
decode(pg_temp, p);
}
friend bool operator==(const PGTempMap& l, const PGTempMap& r) {
void encode_client_old(bufferlist& bl) const;
void encode_classic(bufferlist& bl, uint64_t features) const;
void encode(bufferlist& bl, uint64_t features=CEPH_FEATURES_ALL) const;
- void decode_classic(bufferlist::iterator &p);
- void decode(bufferlist::iterator &bl);
+ void decode_classic(bufferlist::const_iterator &p);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<Incremental*>& o);
have_crc(false), full_crc(0), inc_crc(0) {
}
explicit Incremental(bufferlist &bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = std::cbegin(bl);
decode(p);
}
- explicit Incremental(bufferlist::iterator &p) {
+ explicit Incremental(bufferlist::const_iterator &p) {
decode(p);
}
private:
void encode_client_old(bufferlist& bl) const;
void encode_classic(bufferlist& bl, uint64_t features) const;
- void decode_classic(bufferlist::iterator& p);
+ void decode_classic(bufferlist::const_iterator& p);
void post_decode();
public:
void encode(bufferlist& bl, uint64_t features=CEPH_FEATURES_ALL) const;
void decode(bufferlist& bl);
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
/**** mapping facilities ****/
assert(values.size() == 2);
// sanity check version
- bufferlist::iterator bp = values[infover_key].begin();
+ auto bp = values[infover_key].cbegin();
__u8 struct_v = 0;
decode(struct_v, bp);
assert(struct_v >= 8);
assert(values.size() == 3 ||
values.size() == 4);
- bufferlist::iterator p = values[infover_key].begin();
+ auto p = values[infover_key].cbegin();
decode(struct_v, p);
assert(struct_v >= 10);
assert(i->snaps.length() > 0);
vector<snapid_t> snaps;
bufferlist snapbl = i->snaps;
- bufferlist::iterator p = snapbl.begin();
+ auto p = snapbl.cbegin();
try {
decode(snaps, p);
} catch (...) {
op->mark_started();
- bufferlist::iterator p = const_cast<bufferlist&>(m->get_data()).begin();
+ auto p = const_cast<bufferlist&>(m->get_data()).cbegin();
scrubber.received_maps[m->from].decode(p, info.pgid.pool());
dout(10) << "map version is "
<< scrubber.received_maps[m->from].valid_through
continue;
}
bl.push_back(o.attrs[SS_ATTR]);
- auto p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(snapset, p);
} catch(...) {
bv.push_back(po.attrs[OI_ATTR]);
object_info_t oi;
try {
- bufferlist::iterator bliter = bv.begin();
+ auto bliter = bv.cbegin();
decode(oi, bliter);
} catch (...) {
dout(0) << __func__ << ": Need version of replica, bad object_info_t: " << soid << dendl;
} else {
ss_bl.push_back(k->second);
try {
- bufferlist::iterator bliter = ss_bl.begin();
+ auto bliter = ss_bl.cbegin();
decode(ss, bliter);
if (first_ss_bl.length() == 0) {
first_ss_bl.append(ss_bl);
} else {
hk_bl.push_back(k->second);
try {
- bufferlist::iterator bliter = hk_bl.begin();
+ auto bliter = hk_bl.cbegin();
decode(hi, bliter);
if (first_hk_bl.length() == 0) {
first_hk_bl.append(hk_bl);
}
bl.push_back(k->second);
try {
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
decode(oi, bliter);
} catch (...) {
// invalid object info, probably corrupt
if (p->key()[0] == '_')
continue;
bufferlist bl = p->value();//Copy bufferlist before creating iterator
- bufferlist::iterator bp = bl.begin();
+ auto bp = bl.cbegin();
if (p->key() == "divergent_priors") {
decode(divergent_priors, bp);
ldpp_dout(dpp, 20) << "read_log_and_missing " << divergent_priors.size()
class PGLSPlainFilter : public PGLSFilter {
string val;
public:
- int init(bufferlist::iterator ¶ms) override
+ int init(bufferlist::const_iterator ¶ms) override
{
try {
decode(xattr, params);
explicit PGLSParentFilter(CephContext* cct) : cct(cct) {
xattr = "_parent";
}
- int init(bufferlist::iterator ¶ms) override
+ int init(bufferlist::const_iterator ¶ms) override
{
try {
decode(parent_ino, params);
bool PGLSParentFilter::filter(const hobject_t &obj,
bufferlist& xattr_data, bufferlist& outdata)
{
- bufferlist::iterator iter = xattr_data.begin();
+ auto iter = xattr_data.cbegin();
inode_backtrace_t bt;
generic_dout(0) << "PGLSParentFilter::filter" << dendl;
return filter->filter(sobj, bl, outdata);
}
-int PrimaryLogPG::get_pgls_filter(bufferlist::iterator& iter, PGLSFilter **pfilter)
+int PrimaryLogPG::get_pgls_filter(bufferlist::const_iterator& iter, PGLSFilter **pfilter)
{
string type;
PGLSFilter *filter;
for (vector<OSDOp>::iterator p = ops.begin(); p != ops.end(); ++p) {
OSDOp& osd_op = *p;
- bufferlist::iterator bp = p->indata.begin();
+ auto bp = p->indata.cbegin();
switch (p->op.op) {
case CEPH_OSD_OP_PGNLS_FILTER:
try {
dout(10) << " scrubls pg=" << m->get_pg() << " != " << info.pgid << dendl;
return -EINVAL; // hmm?
}
- auto bp = osd_op->indata.begin();
+ auto bp = osd_op->indata.cbegin();
scrub_ls_arg_t arg;
try {
arg.decode(bp);
BackfillInterval& bi = peer_backfill_info[from];
bi.begin = m->begin;
bi.end = m->end;
- bufferlist::iterator p = const_cast<bufferlist&>(m->get_data()).begin();
+ auto p = m->get_data().cbegin();
// take care to preserve ordering!
bi.clear_objects();
return do_osd_ops(ctx, ops);
}
-int PrimaryLogPG::do_tmapup_slow(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd_op,
- bufferlist& bl)
+int PrimaryLogPG::do_tmapup_slow(OpContext *ctx, bufferlist::const_iterator& bp,
+ OSDOp& osd_op, bufferlist& bl)
{
// decode
bufferlist header;
map<string, bufferlist> m;
if (bl.length()) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(header, p);
decode(m, p);
assert(p.end());
return 0;
}
-int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd_op)
+int PrimaryLogPG::do_tmapup(OpContext *ctx, bufferlist::const_iterator& bp, OSDOp& osd_op)
{
- bufferlist::iterator orig_bp = bp;
+ bufferlist::const_iterator orig_bp = bp;
int result = 0;
if (bp.end()) {
dout(10) << "tmapup is a no-op" << dendl;
newop.outdata.hexdump(*_dout);
*_dout << dendl;
- bufferlist::iterator ip = newop.outdata.begin();
+ auto ip = newop.outdata.cbegin();
bufferlist obl;
dout(30) << "the update command is: \n";
*_dout << dendl;
// sanity check
- bufferlist::iterator tp = obl.begin();
+ auto tp = obl.cbegin();
bufferlist h;
decode(h, tp);
map<string,bufferlist> d;
fill_extent_ctx = nullptr;
if (osd_op.rval >= 0) {
- bufferlist::iterator init_value_bl_it = init_value_bl.begin();
+ bufferlist::const_iterator init_value_bl_it = init_value_bl.begin();
osd_op.rval = primary_log_pg->finish_checksum(osd_op, csum_type,
&init_value_bl_it, read_bl);
}
};
int PrimaryLogPG::do_checksum(OpContext *ctx, OSDOp& osd_op,
- bufferlist::iterator *bl_it)
+ bufferlist::const_iterator *bl_it)
{
dout(20) << __func__ << dendl;
}
}
- bufferlist::iterator init_value_bl_it = init_value_bl.begin();
+ bufferlist::const_iterator init_value_bl_it = init_value_bl.begin();
return finish_checksum(osd_op, csum_type, &init_value_bl_it,
read_op.outdata);
}
int PrimaryLogPG::finish_checksum(OSDOp& osd_op,
Checksummer::CSumType csum_type,
- bufferlist::iterator *init_value_bl_it,
+ bufferlist::const_iterator *init_value_bl_it,
const bufferlist &read_bl) {
dout(20) << __func__ << dendl;
dout(10) << "do_osd_op " << osd_op << dendl;
- bufferlist::iterator bp = osd_op.indata.begin();
+ auto bp = osd_op.indata.cbegin();
// user-visible modifcation?
switch (op.op) {
result = -EEXIST; /* this is an exclusive create */
} else {
if (osd_op.indata.length()) {
- bufferlist::iterator p = osd_op.indata.begin();
+ auto p = osd_op.indata.cbegin();
string category;
try {
decode(category, p);
if (cct->_conf->subsys.should_gather<dout_subsys, 20>()) {
dout(20) << "setting vals: " << dendl;
map<string,bufferlist> to_set;
- bufferlist::iterator pt = to_set_bl.begin();
+ bufferlist::const_iterator pt = to_set_bl.begin();
decode(to_set, pt);
for (map<string, bufferlist>::iterator i = to_set.begin();
i != to_set.end();
newop.op.op = CEPH_OSD_OP_TMAPGET;
do_osd_ops(ctx, nops);
try {
- bufferlist::iterator i = newop.outdata.begin();
+ bufferlist::const_iterator i = newop.outdata.begin();
decode(*header, i);
(*vals).substr_of(newop.outdata, i.get_off(), i.get_remaining());
} catch (...) {
}
};
-int PrimaryLogPG::do_copy_get(OpContext *ctx, bufferlist::iterator& bp,
+int PrimaryLogPG::do_copy_get(OpContext *ctx, bufferlist::const_iterator& bp,
OSDOp& osd_op, ObjectContextRef &obc)
{
object_info_t& oi = obc->obs.oi;
}
if (cop->omap_data.length()) {
map<string,bufferlist> omap;
- bufferlist::iterator p = cop->omap_data.begin();
+ bufferlist::const_iterator p = cop->omap_data.begin();
decode(omap, p);
t->omap_setkeys(cop->results.temp_oid, omap);
cop->omap_data.clear();
object_info_t oi;
try {
- bufferlist::iterator bliter = bv.begin();
+ bufferlist::const_iterator bliter = bv.begin();
decode(oi, bliter);
} catch (...) {
dout(0) << __func__ << ": obc corrupt: " << soid << dendl;
ssc = new SnapSetContext(oid.get_snapdir());
_register_snapset_context(ssc);
if (bv.length()) {
- bufferlist::iterator bvp = bv.begin();
+ bufferlist::const_iterator bvp = bv.begin();
try {
ssc->snapset.decode(bvp);
} catch (buffer::error& e) {
assert(r >= 0);
}
HitSetRef hs(new HitSet);
- bufferlist::iterator pbl = bl.begin();
+ bufferlist::const_iterator pbl = bl.begin();
decode(*hs, pbl);
agent_state->add_hit_set(p->begin.sec(), hs);
}
} else {
bufferlist bl;
bl.push_back(p->second.attrs[SS_ATTR]);
- bufferlist::iterator blp = bl.begin();
+ auto blp = bl.cbegin();
try {
snapset = SnapSet(); // Initialize optional<> before decoding into it
decode(snapset.get(), blp);
dout(0) << __func__ << ": Need version of replica, objects_get_attr failed: "
<< soid << " error=" << r << dendl;
} else try {
- bufferlist::iterator bliter = bv.begin();
+ auto bliter = bv.cbegin();
decode(oi, bliter);
v = oi.version;
} catch (...) {
// -- copyfrom --
map<hobject_t, CopyOpRef> copy_ops;
- int do_copy_get(OpContext *ctx, bufferlist::iterator& bp, OSDOp& op,
+ int do_copy_get(OpContext *ctx, bufferlist::const_iterator& bp, OSDOp& op,
ObjectContextRef& obc);
int finish_copy_get();
int do_xattr_cmp_str(int op, string& v1s, bufferlist& xattr);
// -- checksum --
- int do_checksum(OpContext *ctx, OSDOp& osd_op, bufferlist::iterator *bl_it);
+ int do_checksum(OpContext *ctx, OSDOp& osd_op, bufferlist::const_iterator *bl_it);
int finish_checksum(OSDOp& osd_op, Checksummer::CSumType csum_type,
- bufferlist::iterator *init_value_bl_it,
+ bufferlist::const_iterator *init_value_bl_it,
const bufferlist &read_bl);
friend class C_ChecksumRead;
int do_writesame(OpContext *ctx, OSDOp& osd_op);
bool pgls_filter(PGLSFilter *filter, hobject_t& sobj, bufferlist& outdata);
- int get_pgls_filter(bufferlist::iterator& iter, PGLSFilter **pfilter);
+ int get_pgls_filter(bufferlist::const_iterator& iter, PGLSFilter **pfilter);
map<hobject_t, list<OpRequestRef>> in_progress_proxy_ops;
void kick_proxy_ops_blocked(hobject_t& soid);
int _get_tmap(OpContext *ctx, bufferlist *header, bufferlist *vals);
int do_tmap2omap(OpContext *ctx, unsigned flags);
- int do_tmapup(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd_op);
- int do_tmapup_slow(OpContext *ctx, bufferlist::iterator& bp, OSDOp& osd_op, bufferlist& bl);
+ int do_tmapup(OpContext *ctx, bufferlist::const_iterator& bp, OSDOp& osd_op);
+ int do_tmapup_slow(OpContext *ctx, bufferlist::const_iterator& bp, OSDOp& osd_op, bufferlist& bl);
void do_osd_op_effects(OpContext *ctx, const ConnectionRef& conn);
private:
// shipped transaction and log entries
vector<pg_log_entry_t> log;
- bufferlist::iterator p = const_cast<bufferlist&>(m->get_data()).begin();
+ auto p = const_cast<bufferlist&>(m->get_data()).cbegin();
decode(rm->opt, p);
if (m->new_temp_oid != hobject_t()) {
bufferlist bv = out_op->attrset[OI_ATTR];
object_info_t oi;
try {
- bufferlist::iterator bliter = bv.begin();
+ auto bliter = bv.cbegin();
decode(oi, bliter);
} catch (...) {
dout(0) << __func__ << ": bad object_info_t: " << recovery_info.soid << dendl;
encode(hoid, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(snap, bl);
decode(hoid, bl);
{
Mapping map;
bufferlist bl(image.second);
- bufferlist::iterator bp(bl.begin());
+ auto bp = bl.cbegin();
decode(map, bp);
return make_pair(map.snap, map.hoid);
}
ENCODE_FINISH(bl);
}
-void SnapMapper::object_snaps::decode(bufferlist::iterator &bl)
+void SnapMapper::object_snaps::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(oid, bl);
return -ENOENT;
}
if (out) {
- bufferlist::iterator bp = got.begin()->second.begin();
+ auto bp = got.begin()->second.cbegin();
decode(*out, bp);
dout(20) << __func__ << " " << oid << " " << out->snaps << dendl;
if (out->snaps.empty()) {
: oid(oid), snaps(snaps) {}
object_snaps() {}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bp);
+ void decode(bufferlist::const_iterator &bp);
};
private:
encode(shard, bl);
ENCODE_FINISH(bl);
}
-void pg_shard_t::decode(bufferlist::iterator &bl)
+void pg_shard_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(osd, bl);
ENCODE_FINISH_NEW_COMPAT(bl, encode_compat);
}
-void object_locator_t::decode(bufferlist::iterator& p)
+void object_locator_t::decode(bufferlist::const_iterator& p)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 3, 3, p);
if (struct_v < 2) {
ENCODE_FINISH(bl);
}
-void request_redirect_t::decode(bufferlist::iterator& bl)
+void request_redirect_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
decode(redirect_locator, bl);
ENCODE_FINISH(bl);
}
-void objectstore_perf_stat_t::decode(bufferlist::iterator &bl)
+void objectstore_perf_stat_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START(2, bl);
if (struct_v >= 2) {
ENCODE_FINISH(bl);
}
-void osd_stat_t::decode(bufferlist::iterator &bl)
+void osd_stat_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 2, 2, bl);
decode(kb, bl);
return r;
}
-void coll_t::decode(bufferlist::iterator& bl)
+void coll_t::decode(bufferlist::const_iterator& bl)
{
using ceph::decode;
__u8 struct_v;
ENCODE_FINISH(bl);
}
-void pool_snap_info_t::decode(bufferlist::iterator& bl)
+void pool_snap_info_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(snapid, bl);
ENCODE_FINISH(bl);
}
-void pool_opts_t::decode(bufferlist::iterator& bl) {
+void pool_opts_t::decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
__u32 n;
decode(n, bl);
ENCODE_FINISH(bl);
}
-void pg_pool_t::decode(bufferlist::iterator& bl)
+void pg_pool_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(27, 5, 5, bl);
decode(type, bl);
ENCODE_FINISH(bl);
}
-void object_stat_sum_t::decode(bufferlist::iterator& bl)
+void object_stat_sum_t::decode(bufferlist::const_iterator& bl)
{
bool decode_finish = false;
DECODE_START(18, bl); // make sure to also update fast decode below
ENCODE_FINISH(bl);
}
-void object_stat_collection_t::decode(bufferlist::iterator& bl)
+void object_stat_collection_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(sum, bl);
ENCODE_FINISH(bl);
}
-void pg_stat_t::decode(bufferlist::iterator &bl)
+void pg_stat_t::decode(bufferlist::const_iterator &bl)
{
bool tmp;
uint32_t old_state;
ENCODE_FINISH(bl);
}
-void pool_stat_t::decode(bufferlist::iterator &bl)
+void pool_stat_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 5, 5, bl);
if (struct_v >= 4) {
ENCODE_FINISH(bl);
}
-void pg_history_t::decode(bufferlist::iterator &bl)
+void pg_history_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(9, 4, 4, bl);
decode(epoch_created, bl);
ENCODE_FINISH(bl);
}
-void pg_info_t::decode(bufferlist::iterator &bl)
+void pg_info_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START(32, bl);
decode(pgid.pgid, bl);
ENCODE_FINISH(bl);
}
-void pg_notify_t::decode(bufferlist::iterator &bl)
+void pg_notify_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START(2, bl);
decode(query_epoch, bl);
ENCODE_FINISH(bl);
}
-void PastIntervals::pg_interval_t::decode(bufferlist::iterator& bl)
+void PastIntervals::pg_interval_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
decode(first, bl);
encode(acting, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(first, bl);
decode(last, bl);
encode(intervals, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) override {
+ void decode(bufferlist::const_iterator &bl) override {
DECODE_START(1, bl);
decode(first, bl);
decode(last, bl);
<< ")";
}
-void PastIntervals::decode(bufferlist::iterator &bl)
+void PastIntervals::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
__u8 type = 0;
ENCODE_FINISH(bl);
}
-void pg_query_t::decode(bufferlist::iterator &bl) {
+void pg_query_t::decode(bufferlist::const_iterator &bl) {
DECODE_START(3, bl);
decode(type, bl);
decode(since, bl);
// -- ObjectModDesc --
void ObjectModDesc::visit(Visitor *visitor) const
{
- bufferlist::iterator bp = bl.begin();
+ auto bp = bl.cbegin();
try {
while (!bp.end()) {
DECODE_START(max_required_version, bp);
encode(bl, _bl);
ENCODE_FINISH(_bl);
}
-void ObjectModDesc::decode(bufferlist::iterator &_bl)
+void ObjectModDesc::decode(bufferlist::const_iterator &_bl)
{
DECODE_START(2, _bl);
max_required_version = struct_v;
encode(crc, bl);
}
-void pg_log_entry_t::decode_with_checksum(bufferlist::iterator& p)
+void pg_log_entry_t::decode_with_checksum(bufferlist::const_iterator& p)
{
using ceph::decode;
bufferlist bl;
decode(crc, p);
if (crc != bl.crc32c(0))
throw buffer::malformed_input("bad checksum on pg_log_entry_t");
- bufferlist::iterator q = bl.begin();
+ auto q = bl.cbegin();
this->decode(q);
}
ENCODE_FINISH(bl);
}
-void pg_log_entry_t::decode(bufferlist::iterator &bl)
+void pg_log_entry_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(11, 4, 4, bl);
decode(op, bl);
if (snaps.length() > 0) {
vector<snapid_t> v;
bufferlist c = snaps;
- bufferlist::iterator p = c.begin();
+ auto p = c.cbegin();
try {
using ceph::decode;
decode(v, p);
if (e.snaps.length()) {
vector<snapid_t> snaps;
bufferlist c = e.snaps;
- bufferlist::iterator p = c.begin();
+ auto p = c.cbegin();
try {
decode(snaps, p);
} catch (...) {
ENCODE_FINISH(bl);
}
-void pg_log_dup_t::decode(bufferlist::iterator &bl)
+void pg_log_dup_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(reqid, bl);
ENCODE_FINISH(bl);
}
-void pg_log_t::decode(bufferlist::iterator &bl, int64_t pool)
+void pg_log_t::decode(bufferlist::const_iterator &bl, int64_t pool)
{
DECODE_START_LEGACY_COMPAT_LEN(7, 3, 3, bl);
decode(head, bl);
ENCODE_FINISH(bl);
}
-void object_copy_cursor_t::decode(bufferlist::iterator &bl)
+void object_copy_cursor_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(attr_complete, bl);
ENCODE_FINISH(bl);
}
-void object_copy_data_t::decode(bufferlist::iterator& bl)
+void object_copy_data_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START(7, bl);
if (struct_v < 5) {
ENCODE_FINISH(bl);
}
-void pg_create_t::decode(bufferlist::iterator &bl)
+void pg_create_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(created, bl);
ENCODE_FINISH(bl);
}
-void pg_hit_set_info_t::decode(bufferlist::iterator& p)
+void pg_hit_set_info_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(2, p);
decode(begin, p);
ENCODE_FINISH(bl);
}
-void pg_hit_set_history_t::decode(bufferlist::iterator& p)
+void pg_hit_set_history_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(current_last_update, p);
ENCODE_FINISH(bl);
}
-void OSDSuperblock::decode(bufferlist::iterator &bl)
+void OSDSuperblock::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(8, 5, 5, bl);
if (struct_v < 3) {
ENCODE_FINISH(bl);
}
-void SnapSet::decode(bufferlist::iterator& bl)
+void SnapSet::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(seq, bl);
ENCODE_FINISH(bl);
}
-void watch_info_t::decode(bufferlist::iterator& bl)
+void watch_info_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 3, 3, bl);
decode(cookie, bl);
ENCODE_FINISH(bl);
}
-void chunk_info_t::decode(bufferlist::iterator& bl)
+void chunk_info_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
decode(offset, bl);
ENCODE_FINISH(bl);
}
-void object_manifest_t::decode(bufferlist::iterator& bl)
+void object_manifest_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START(1, bl);
decode(type, bl);
ENCODE_FINISH(bl);
}
-void object_info_t::decode(bufferlist::iterator& bl)
+void object_info_t::decode(bufferlist::const_iterator& bl)
{
object_locator_t myoloc;
DECODE_START_LEGACY_COMPAT_LEN(17, 8, 8, bl);
ENCODE_FINISH(bl);
}
-void ObjectRecoveryProgress::decode(bufferlist::iterator &bl)
+void ObjectRecoveryProgress::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(first, bl);
ENCODE_FINISH(bl);
}
-void ObjectRecoveryInfo::decode(bufferlist::iterator &bl,
+void ObjectRecoveryInfo::decode(bufferlist::const_iterator &bl,
int64_t pool)
{
DECODE_START(2, bl);
ENCODE_FINISH(bl);
}
-void PushReplyOp::decode(bufferlist::iterator &bl)
+void PushReplyOp::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(soid, bl);
ENCODE_FINISH(bl);
}
-void PullOp::decode(bufferlist::iterator &bl)
+void PullOp::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(soid, bl);
ENCODE_FINISH(bl);
}
-void PushOp::decode(bufferlist::iterator &bl)
+void PushOp::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(soid, bl);
ENCODE_FINISH(bl);
}
-void ScrubMap::decode(bufferlist::iterator& bl, int64_t pool)
+void ScrubMap::decode(bufferlist::const_iterator& bl, int64_t pool)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(objects, bl);
ENCODE_FINISH(bl);
}
-void ScrubMap::object::decode(bufferlist::iterator& bl)
+void ScrubMap::object::decode(bufferlist::const_iterator& bl)
{
DECODE_START(9, bl);
decode(size, bl);
}
string get_osd() const { return (osd == NO_OSD ? "NONE" : to_string(osd)); }
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const {
f->dump_unsigned("osd", osd);
if (shard != shard_id_t::NO_SHARD) {
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<object_locator_t*>& o);
};
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<request_redirect_t*>& o);
};
void encode(bufferlist& bl) const {
::encode_raw(v, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
::decode_raw(v, bl);
}
};
encode(m_seed, bl);
encode((int32_t)-1, bl); // was preferred
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 v;
decode(v, bl);
decode(m_seed, bl);
bl.advance(sizeof(int32_t)); // was preferred
}
- void decode_old(bufferlist::iterator& bl) {
+ void decode_old(bufferlist::const_iterator& bl) {
using ceph::decode;
old_pg_t opg;
decode(opg, bl);
encode(shard, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(pgid, bl);
decode(shard, bl);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
size_t encoded_size() const;
inline bool operator==(const coll_t& rhs) const {
encode(epoch, bl);
#endif
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
#if defined(CEPH_LITTLE_ENDIAN)
bl.copy(sizeof(version_t) + sizeof(epoch_t), (char *)this);
#else
#endif
}
void decode(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = std::cbegin(bl);
decode(p);
}
};
}
void dump(Formatter *f) const;
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
static void generate_test_instances(std::list<objectstore_perf_stat_t*>& o);
};
WRITE_CLASS_ENCODER_FEATURES(objectstore_perf_stat_t)
void dump(Formatter *f) const;
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
static void generate_test_instances(std::list<osd_stat_t*>& o);
};
WRITE_CLASS_ENCODER_FEATURES(osd_stat_t)
void dump(Formatter *f) const;
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
static void generate_test_instances(list<pool_snap_info_t*>& o);
};
WRITE_CLASS_ENCODER_FEATURES(pool_snap_info_t)
void dump(Formatter *f) const;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
private:
typedef std::map<key_t, value_t> opts_t;
uint32_t get_random_pg_position(pg_t pgid, uint32_t seed) const;
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
static void generate_test_instances(list<pg_pool_t*>& o);
};
"object_stat_sum_t have padding");
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
static void generate_test_instances(list<object_stat_sum_t*>& o);
};
WRITE_CLASS_ENCODER(object_stat_sum_t)
void dump(Formatter *f) const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
static void generate_test_instances(list<object_stat_collection_t*>& o);
bool is_zero() const {
void dump(Formatter *f) const;
void dump_brief(Formatter *f) const;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
static void generate_test_instances(list<pg_stat_t*>& o);
};
WRITE_CLASS_ENCODER(pg_stat_t)
void dump(Formatter *f) const;
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
static void generate_test_instances(list<pool_stat_t*>& o);
};
WRITE_CLASS_ENCODER_FEATURES(pool_stat_t)
: using_gmt(using_gmt) {}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_hit_set_info_t*>& o);
};
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_hit_set_history_t*>& o);
};
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_history_t*>& o);
};
bool is_incomplete() const { return !last_backfill.is_max(); }
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
bool overlaps_with(const pg_info_t &oinfo) const {
return last_update > oinfo.log_tail ?
encode(stats.stats.sum.num_objects_dirty, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(1, p);
decode(last_update, p);
decode(last_complete, p);
assert(from == info.pgid.shard);
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &p);
+ void decode(bufferlist::const_iterator &p);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_notify_t*> &o);
};
{}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_interval_t*>& o);
};
virtual unique_ptr<interval_rep> clone() const = 0;
virtual ostream &print(ostream &out) const = 0;
virtual void encode(bufferlist &bl) const = 0;
- virtual void decode(bufferlist::iterator &bl) = 0;
+ virtual void decode(bufferlist::const_iterator &bl) = 0;
virtual void dump(Formatter *f) const = 0;
virtual void iterate_mayberw_back_to(
bool ec_pool,
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const {
assert(past_intervals);
}
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_query_t*>& o);
bl.rebuild();
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ObjectModDesc*>& o);
};
string get_key_name() const;
void encode_with_checksum(bufferlist& bl) const;
- void decode_with_checksum(bufferlist::iterator& p);
+ void decode_with_checksum(bufferlist::const_iterator& p);
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_log_entry_t*>& o);
string get_key_name() const;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_log_dup_t*>& o);
ostream& print(ostream& out) const;
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl, int64_t pool = -1);
+ void decode(bufferlist::const_iterator &bl, int64_t pool = -1);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_log_t*>& o);
};
encode(have, bl);
}
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
eversion_t e;
decode(e, bl);
encode(may_include_deletes, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl, int64_t pool = -1) {
+ void decode(bufferlist::const_iterator &bl, int64_t pool = -1) {
for (auto const &i: missing)
tracker.changed(i.first);
DECODE_START_LEGACY_COMPAT_LEN(4, 2, 2, bl);
ENCODE_DUMP_POST(cl);
}
template <bool TrackChanges>
-void decode(pg_missing_set<TrackChanges> &c, bufferlist::iterator &p) {
+void decode(pg_missing_set<TrackChanges> &c, bufferlist::const_iterator &p) {
c.decode(p);
}
template <bool TrackChanges>
}
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(handle, bl);
__u32 n;
encode(handle, bl);
encode(entries, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
__u8 v;
decode(v, bl);
static void generate_test_instances(list<object_copy_cursor_t*>& o);
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
};
WRITE_CLASS_ENCODER(object_copy_cursor_t)
static void generate_test_instances(list<object_copy_data_t*>& o);
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
};
WRITE_CLASS_ENCODER_FEATURES(object_copy_data_t)
: created(c), parent(p), split_bits(s) {}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<pg_create_t*>& o);
};
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<OSDSuperblock*>& o);
};
SnapSet() : seq(0) {}
explicit SnapSet(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = std::cbegin(bl);
decode(p);
}
uint64_t get_clone_bytes(snapid_t clone) const;
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<SnapSet*>& o);
watch_info_t(uint64_t c, uint32_t t, const entity_addr_t& a) : cookie(c), timeout_seconds(t), addr(a) {}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<watch_info_t*>& o);
};
return r;
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
friend ostream& operator<<(ostream& out, const chunk_info_t& ci);
};
}
static void generate_test_instances(list<object_manifest_t*>& o);
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
friend ostream& operator<<(ostream& out, const object_info_t& oi);
};
}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void decode(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = std::cbegin(bl);
decode(p);
}
void dump(Formatter *f) const;
static void generate_test_instances(list<ObjectRecoveryInfo*>& o);
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl, int64_t pool = -1);
+ void decode(bufferlist::const_iterator &bl, int64_t pool = -1);
ostream &print(ostream &out) const;
void dump(Formatter *f) const;
};
static void generate_test_instances(list<ObjectRecoveryProgress*>& o);
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
ostream &print(ostream &out) const;
void dump(Formatter *f) const;
};
static void generate_test_instances(list<PushReplyOp*>& o);
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
ostream &print(ostream &out) const;
void dump(Formatter *f) const;
static void generate_test_instances(list<PullOp*>& o);
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
ostream &print(ostream &out) const;
void dump(Formatter *f) const;
static void generate_test_instances(list<PushOp*>& o);
void encode(bufferlist &bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
ostream &print(ostream &out) const;
void dump(Formatter *f) const;
ec_size_mismatch(false), large_omap_object_found(false) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<object*>& o);
};
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl, int64_t pool=-1);
+ void decode(bufferlist::const_iterator& bl, int64_t pool=-1);
void dump(Formatter *f) const;
static void generate_test_instances(list<ScrubMap*>& o);
};
encode(addr, bl, features);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(2, bl);
decode(name, bl);
decode(cookie, bl);
encode(entries, bl, features);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(entries, bl);
DECODE_FINISH(bl);
encode(size, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(cloneid, bl);
decode(snaps, bl);
encode(seq, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(2, bl);
decode(clones, bl);
if (struct_v >= 2)
// unpack header
if (r == 0) {
Header h;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(h, p);
} catch (const buffer::error &e) {
// unpack header
bool corrupt = false;
Header h;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(h, p);
uint32_t entry_size = 0;
uint64_t entry_sentinel = 0;
- bufferlist::iterator p = read_buf.begin();
+ auto p = read_buf.cbegin();
// Do we have enough data to decode an entry prefix?
if (format >= JOURNAL_FORMAT_RESILIENT) {
uint32_t entry_size = 0;
// Consume envelope prefix: entry_size and entry_sentinel
- bufferlist::iterator from_ptr = from.begin();
+ auto from_ptr = from.cbegin();
if (format >= JOURNAL_FORMAT_RESILIENT) {
uint64_t entry_sentinel = 0;
decode(entry_sentinel, from_ptr);
encode(stream_format, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(magic, bl);
decode(trimmed_pos, bl);
if (!info->is_watch) {
// make note of the notify_id
- bufferlist::iterator p = outbl.begin();
+ auto p = outbl.cbegin();
try {
decode(info->notify_id, p);
ldout(cct, 10) << "_linger_commit notify_id=" << info->notify_id
{
ldout(cct, 10) << __func__ << " " << list_context << dendl;
- bufferlist::iterator iter = list_context->bl.begin();
+ auto iter = list_context->bl.cbegin();
pg_nls_response_t response;
bufferlist extra_info;
decode(response, iter);
void finish(int r) override {
if (r == 0) {
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(*psnapid, p);
} catch (buffer::error&) {
r = -EIO;
assert(next != NULL);
// Decode the results
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
pg_nls_response_t response;
// XXX extra_info doesn't seem used anywhere?
void do_decode(std::vector<T>& items, std::vector<bufferlist>& bls)
{
for (auto bl : bls) {
- auto p = bl.begin();
+ auto p = bl.cbegin();
T t;
decode(t, p);
items.push_back(t);
private:
void decode() {
scrub_ls_result_t result;
- auto p = bl.begin();
+ auto p = bl.cbegin();
result.decode(p);
*interval = result.interval;
if (objects) {
: psize(ps), pmtime(pm), ptime(pt), pts(_pts), prval(prval) {}
void finish(int r) override {
if (r >= 0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
uint64_t size;
ceph::real_time mtime;
int *prval)
: data_bl(data_bl), extents(extents), prval(prval) {}
void finish(int r) override {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
if (r >= 0) {
// NOTE: it's possible the sub-op has not been executed but the result
// code remains zeroed. Avoid the costly exception handling on a
}
void finish(int r) override {
if (r >= 0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
if (pattrs)
decode(*pattrs, p);
}
void finish(int r) override {
if (r >= 0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
if (pattrs)
decode(*pattrs, p);
: pwatchers(pw), prval(pr) {}
void finish(int r) override {
if (r >= 0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
obj_list_watch_response_t resp;
decode(resp, p);
: psnaps(ps), prval(pr) {}
void finish(int r) override {
if (r >= 0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
obj_list_snap_response_t resp;
decode(resp, p);
if (r < 0 && r != -ENOENT)
return;
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
object_copy_data_t copy_reply;
decode(copy_reply, p);
if (r == -ENOENT) {
if (r < 0)
return;
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
bool isdirty;
decode(isdirty, p);
if (pisdirty)
if (r < 0)
return;
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
std::list< std::pair<ceph::real_time, ceph::real_time> > ls;
decode(ls, p);
if (ptls) {
psize(ps), pmtime(pm), fin(c) {}
void finish(int r) override {
if (r >= 0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
uint64_t s;
ceph::real_time m;
decode(s, p);
fin(c) {}
void finish(int r) override {
if (r >= 0) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(attrset, p);
}
fin->complete(r);
test_denc.cc
)
add_ceph_unittest(unittest_denc)
-target_link_libraries(unittest_denc os global)
+target_link_libraries(unittest_denc global)
# unittest_mempool
add_executable(unittest_mempool
static int read_bl(bufferlist& bl, int *i)
{
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
try {
decode(*i, iter);
seeds[0] = 0;
}
- explicit ObjectContents(bufferlist::iterator &bp) {
+ explicit ObjectContents(bufferlist::const_iterator &bp) {
decode(_size, bp);
decode(seeds, bp);
decode(written, bp);
bufferlist header_bl;
header_bl.substr_of(bl, 0, bit_vector.get_header_length());
- bufferlist::iterator header_it = header_bl.begin();
+ auto header_it = header_bl.cbegin();
bit_vector.decode_header(header_it);
bufferlist footer_bl;
footer_bl.substr_of(bl, bit_vector.get_footer_offset(),
bl.length() - bit_vector.get_footer_offset());
- bufferlist::iterator footer_it = footer_bl.begin();
+ auto footer_it = footer_bl.cbegin();
bit_vector.decode_footer(footer_it);
typedef std::pair<uint64_t, uint64_t> Extent;
bufferlist data_bl;
data_bl.substr_of(bl, bit_vector.get_header_length() + byte_offset,
byte_length);
- bufferlist::iterator data_it = data_bl.begin();
+ auto data_it = data_bl.cbegin();
bit_vector.decode_data(data_it, byte_offset);
data_bl.clear();
updated_bl.append(footer_bl);
ASSERT_EQ(bl, updated_bl);
- bufferlist::iterator updated_it = updated_bl.begin();
+ auto updated_it = updated_bl.cbegin();
decode(bit_vector, updated_it);
}
}
bufferlist footer;
bit_vector.encode_footer(footer);
- bufferlist::iterator it = footer.begin();
+ auto it = footer.cbegin();
bit_vector.decode_footer(it);
bit_vector.resize(1);
bufferlist data;
bit_vector1.encode_data(data, byte_offset, byte_length);
- bufferlist::iterator data_it = data.begin();
+ auto data_it = data.cbegin();
bit_vector1.decode_data(data_it, byte_offset);
bit_vector2[bit_vector2.size() - 1] = 1;
bufferlist bl;
::encode(f, bl);
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
try {
::decode(f2, iter);
} catch (buffer::error& err) {
out = in;
return 0;
}
- int decompress(bufferlist::iterator &p, size_t compressed_len, bufferlist &out) override
+ int decompress(bufferlist::const_iterator &p, size_t compressed_len, bufferlist &out) override
{
p.copy(std::min<size_t>(p.get_remaining(), compressed_len), out);
return 0;
after.clear();
size_t compressed_len = out.length();
out.append_zero(12);
- auto it = out.begin();
+ auto it = out.cbegin();
res = compressor->decompress(it, compressed_len, after);
EXPECT_EQ(res, 0);
EXPECT_TRUE(exp.contents_equal(after));
size_t prefix_len = prefix.length();
prefix.claim_append(out);
out.swap(prefix);
- it = out.begin();
+ it = out.cbegin();
it.advance(prefix_len);
res = compressor->decompress(it, compressed_len, after);
EXPECT_EQ(res, 0);
c.choose_args[caid] = arg_map;
bufferlist bl;
c.encode(bl, features|CEPH_FEATURE_CRUSH_CHOOSE_ARGS);
- bufferlist::iterator i(bl.begin());
+ auto i = bl.cbegin();
CrushWrapper c_new;
c_new.decode(i);
ASSERT_EQ(1u, c_new.choose_args.size());
bufferlist bl;
c.encode(bl, features);
c.choose_args.clear();
- bufferlist::iterator i(bl.begin());
+ auto i = bl.cbegin();
CrushWrapper c_new;
c_new.decode(i);
ASSERT_EQ(0u, c_new.choose_args.size());
bufferlist bl(1000000);
encode(src, bl);
T dst;
- bufferlist::iterator i(bl.begin());
+ auto i = bl.cbegin();
decode(dst, i);
ASSERT_EQ(src, dst) << "Encoding roundtrip changed the string: orig=" << src << ", but new=" << dst;
}
encode(len, bl);
encode_nohead(src, bl);
T dst;
- bufferlist::iterator i(bl.begin());
+ auto i = bl.cbegin();
decode(len, i);
decode_nohead(len, dst, i);
ASSERT_EQ(src, dst) << "Encoding roundtrip changed the string: orig=" << src << ", but new=" << dst;
return data == rhs.data;
}
- friend void decode(ConstructorCounter &s, bufferlist::iterator& p)
+ friend void decode(ConstructorCounter &s, bufferlist::const_iterator& p)
{
decode(s.data, p);
}
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][1]);
uint32_t u;
- auto p = bl.begin().get_current_ptr().begin();
+ auto p = bl.begin().get_current_ptr().cbegin();
denc_varint(u, p);
ASSERT_EQ(v[i][0], u);
}
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][2]);
int32_t u;
- auto p = bl.begin().get_current_ptr().begin();
+ auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint(u, p);
ASSERT_EQ((int32_t)v[i][0], u);
}
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][3]);
int64_t u;
- auto p = bl.begin().get_current_ptr().begin();
+ auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint(u, p);
ASSERT_EQ(x, u);
}
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][1]);
uint32_t u;
- auto p = bl.begin().get_current_ptr().begin();
+ auto p = bl.begin().get_current_ptr().cbegin();
denc_varint_lowz(u, p);
ASSERT_EQ(v[i][0], u);
}
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][2]);
int64_t u;
- auto p = bl.begin().get_current_ptr().begin();
+ auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint_lowz(u, p);
ASSERT_EQ(x, u);
}
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][3]);
int64_t u;
- auto p = bl.begin().get_current_ptr().begin();
+ auto p = bl.begin().get_current_ptr().cbegin();
denc_signed_varint_lowz(u, p);
ASSERT_EQ(x, u);
}
cout << std::endl;
ASSERT_EQ(bl.length(), v[i][1]);
uint64_t u;
- auto p = bl.begin().get_current_ptr().begin();
+ auto p = bl.begin().get_current_ptr().cbegin();
denc_lba(u, p);
ASSERT_EQ(v[i][0], u);
}
}
string decode(bufferlist bl, uint64_t seek) override {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
p.seek(seek);
try {
using ceph::decode;
}
string decode(bufferlist bl, uint64_t seek) override {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
p.seek(seek);
try {
Message *n = decode_message(g_ceph_context, 0, p);
using ceph::encode;
encode(t, bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
using ceph::decode;
decode(t, p);
}
using ceph::encode;
encode(d, bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
using ceph::decode;
decode(d, p);
}
ASSERT_EQ(0, memcmp(buf, bl.c_str(), sizeof(buf)));
ASSERT_EQ(8U, csum_bl.length());
- auto csum_bl_it = csum_bl.begin();
+ auto csum_bl_it = csum_bl.cbegin();
uint32_t csum_count;
uint32_t csum;
decode(csum_count, csum_bl_it);
// make sure buffer is at least as long as it claims
bufferlist bl;
bl.append(out, bytes_read);
- auto it = bl.begin();
+ auto it = bl.cbegin();
ceph::decode(features, it);
ASSERT_EQ(RBD_FEATURES_ALL, features);
rados_buffer_free(out);
bufferlist csum_bl;
ASSERT_EQ(0, ioctx.checksum("foo", LIBRADOS_CHECKSUM_TYPE_CRC32C,
init_value_bl, sizeof(buf), 0, 0, &csum_bl));
- auto csum_bl_it = csum_bl.begin();
+ auto csum_bl_it = csum_bl.cbegin();
uint32_t csum_count;
decode(csum_count, csum_bl_it);
ASSERT_EQ(1U, csum_count);
oss << "ioctx.read(" << obj << ", bl, 0, 0) returned " << r;
return oss.str();
}
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
bufferlist header;
map<string, bufferlist> m;
decode(header, p);
ASSERT_GT(res, 0);
bufferlist bl;
bl.append(buf2, res);
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
uint64_t all_features;
decode(all_features, iter);
// make sure *some* features are specified; don't care which ones
bufferlist bl2, out;
int r = ioctx.exec("foo", "rbd", "get_all_features", bl2, out);
ASSERT_EQ(0, r);
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
uint64_t all_features;
decode(all_features, iter);
// make sure *some* features are specified; don't care which ones
for (uint32_t i = 0; i < csum_count; ++i) {
ASSERT_EQ(0, checksum_rvals[i]);
- auto bl_it = checksum_bls[i].begin();
+ auto bl_it = checksum_bls[i].cbegin();
uint32_t count;
decode(count, bl_it);
ASSERT_EQ(1U, count);
ASSERT_EQ(0, this->ioctx.operate("foo", &op, NULL));
ASSERT_EQ(0, checksum_rval);
- auto bl_it = checksum_bl.begin();
+ auto bl_it = checksum_bl.cbegin();
uint32_t count;
decode(count, bl_it);
ASSERT_EQ(csum_count, count);
c->release();
if (hbl.length()) {
- bufferlist::iterator p = hbl.begin();
+ auto p = hbl.cbegin();
HitSet hs;
decode(hs, p);
if (hs.contains(oid)) {
c->release();
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(hitsets[i], p);
}
catch (buffer::error& e) {
cache_ioctx.exec("bar", "refcount", "chunk_read", in, out);
cls_chunk_refcount_read_ret read_ret;
try {
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
decode(read_ret, iter);
} catch (buffer::error& err) {
ASSERT_TRUE(0);
cache_ioctx.exec("bar-chunk", "refcount", "chunk_read", in, out);
cls_chunk_refcount_read_ret read_ret;
try {
- bufferlist::iterator iter = out.begin();
+ auto iter = out.cbegin();
decode(read_ret, iter);
} catch (buffer::error& err) {
ASSERT_TRUE(0);
c->release();
if (hbl.length()) {
- bufferlist::iterator p = hbl.begin();
+ auto p = hbl.cbegin();
HitSet hs;
decode(hs, p);
if (hs.contains(oid)) {
//bl.hexdump(std::cout);
//std::cout << std::endl;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(hitsets[i], p);
// cope with racing splits by refreshing pg_num
reply.append(reply_buf, reply_buf_len);
std::map<std::pair<uint64_t,uint64_t>, bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
- bufferlist::iterator reply_p = reply.begin();
+ auto reply_p = reply.cbegin();
decode(reply_map, reply_p);
decode(missed_map, reply_p);
ASSERT_EQ(1u, reply_map.size());
reply.append(reply_buf, reply_buf_len);
std::map<std::pair<uint64_t,uint64_t>, bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
- bufferlist::iterator reply_p = reply.begin();
+ auto reply_p = reply.cbegin();
decode(reply_map, reply_p);
decode(missed_map, reply_p);
ASSERT_EQ(1u, reply_map.size());
reply.append(reply_buf, reply_buf_len);
std::map<std::pair<uint64_t,uint64_t>, bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
- bufferlist::iterator reply_p = reply.begin();
+ auto reply_p = reply.cbegin();
decode(reply_map, reply_p);
decode(missed_map, reply_p);
ASSERT_EQ(1u, reply_map.size());
ASSERT_EQ(watches.size(), 1u);
bufferlist bl2, bl_reply;
ASSERT_EQ(0, ioctx.notify2(notify_oid, bl2, 300000, &bl_reply));
- bufferlist::iterator p = bl_reply.begin();
+ auto p = bl_reply.cbegin();
std::map<std::pair<uint64_t,uint64_t>,bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
decode(reply_map, p);
ASSERT_EQ(watches.size(), 1u);
bufferlist bl2, bl_reply;
ASSERT_EQ(0, ioctx.notify2(notify_oid, bl2, 300000, &bl_reply));
- bufferlist::iterator p = bl_reply.begin();
+ auto p = bl_reply.cbegin();
std::map<std::pair<uint64_t,uint64_t>,bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
decode(reply_map, p);
ASSERT_EQ(0, comp->wait_for_complete());
ASSERT_EQ(0, comp->get_return_value());
comp->release();
- bufferlist::iterator p = bl_reply.begin();
+ auto p = bl_reply.cbegin();
std::map<std::pair<uint64_t,uint64_t>,bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
decode(reply_map, p);
reply.append(reply_buf, reply_buf_len);
std::map<std::pair<uint64_t,uint64_t>, bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
- bufferlist::iterator reply_p = reply.begin();
+ auto reply_p = reply.cbegin();
decode(reply_map, reply_p);
decode(missed_map, reply_p);
ASSERT_EQ(2u, reply_map.size());
reply.append(reply_buf, reply_buf_len);
std::map<std::pair<uint64_t,uint64_t>, bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
- bufferlist::iterator reply_p = reply.begin();
+ auto reply_p = reply.cbegin();
decode(reply_map, reply_p);
decode(missed_map, reply_p);
ASSERT_EQ(0u, reply_map.size());
std::cout << "notify2" << std::endl;
ASSERT_EQ(0, ioctx.notify2(notify_oid, bl2, 300000, &bl_reply));
std::cout << "notify2 done" << std::endl;
- bufferlist::iterator p = bl_reply.begin();
+ auto p = bl_reply.cbegin();
std::map<std::pair<uint64_t,uint64_t>,bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
decode(reply_map, p);
reply.append(reply_buf, reply_buf_len);
std::map<std::pair<uint64_t,uint64_t>, bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
- bufferlist::iterator reply_p = reply.begin();
+ auto reply_p = reply.cbegin();
decode(reply_map, reply_p);
decode(missed_map, reply_p);
ASSERT_EQ(0u, reply_map.size());
reply.append(reply_buf, reply_buf_len);
std::map<std::pair<uint64_t,uint64_t>, bufferlist> reply_map;
std::set<std::pair<uint64_t,uint64_t> > missed_map;
- bufferlist::iterator reply_p = reply.begin();
+ auto reply_p = reply.cbegin();
decode(reply_map, reply_p);
decode(missed_map, reply_p);
ASSERT_EQ(1u, reply_map.size());
if (r < 0) {
return r;
}
- bufferlist::iterator iter = inbl.begin();
+ auto iter = inbl.cbegin();
decode(tmap_header, iter);
decode(tmap, iter);
}
__u8 c;
std::string key;
bufferlist value;
- bufferlist::iterator iter = cmdbl.begin();
+ auto iter = cmdbl.cbegin();
decode(c, iter);
decode(key, iter);
dout(5) << __func__
<< " full epoch " << start_full << dendl;
bufferlist &bl = rit->second;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
osdmap.decode(p);
}
}
<< " on full epoch " << start_full << dendl;
OSDMap::Incremental inc;
bufferlist &bl = it->second;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
inc.decode(p);
int err = osdmap.apply_incremental(inc);
}
Payload pl;
- auto p = m->get_data().begin();
+ auto p = m->get_data().cbegin();
decode(pl, p);
if (pl.who == Payload::PING) {
lderr(g_ceph_context) << __func__ << " conn=" << m->get_connection() << pl << dendl;
db->get("STATUS", to_get, &got);
restart_seq = 0;
if (!got.empty()) {
- bufferlist::iterator bp = got.begin()->second.begin();
+ auto bp = got.begin()->second.cbegin();
decode(restart_seq, bp);
}
++restart_seq;
encode(obj.last_committed, bl);
encode(obj.restart_seq, bl);
}
-void decode(ObjStatus &obj, bufferlist::iterator &bl) {
+void decode(ObjStatus &obj, bufferlist::const_iterator &bl) {
decode(obj.last_applied, bl);
decode(obj.last_committed, bl);
decode(obj.restart_seq, bl);
db->get(obj_to_meta_prefix(obj), to_get, &got);
ObjStatus retval;
if (!got.empty()) {
- bufferlist::iterator bp = got.begin()->second.begin();
+ auto bp = got.begin()->second.cbegin();
decode(retval, bp);
}
return retval;
iter->seek_to_last();
if (iter->valid()) {
bufferlist bl = iter->value();
- bufferlist::iterator bp = bl.begin();
+ auto bp = bl.cbegin();
pair<uint64_t, bufferlist> val;
decode(val, bp);
assert(seq_to_key(val.first) == iter->key());
if (got.empty())
return ObjectContents();
pair<uint64_t, bufferlist> val;
- bufferlist::iterator bp = got.begin()->second.begin();
+ auto bp = got.begin()->second.cbegin();
decode(val, bp);
bp = val.second.begin();
assert(val.first == version);
if (iter->valid()) {
pair<uint64_t, bufferlist> val;
bufferlist bl = iter->value();
- bufferlist::iterator bp = bl.begin();
+ auto bp = bl.cbegin();
decode(val, bp);
bounds.second = val.first + 1;
}
if (iter->valid()) {
pair<uint64_t, bufferlist> val;
bufferlist bl = iter->value();
- bufferlist::iterator bp = bl.begin();
+ auto bp = bl.cbegin();
decode(val, bp);
most_recent = val.first;
}
t.encode(bl);
encode_ticks.add(Cycles::rdtsc() - start_time);
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
start_time = Cycles::rdtsc();
d.decode(bliter);
decode_ticks.add(Cycles::rdtsc() - start_time);
bufferlist bl;
store->fiemap(ch, oid, 0, 100000, bl);
map<uint64_t,uint64_t> m, e;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(m, p);
cout << " got " << m << std::endl;
e[0] = 100000;
bufferlist bl;
store->fiemap(ch, oid, 0, SKIP_STEP * (MAX_EXTENTS - 1) + 3, bl);
map<uint64_t,uint64_t> m, e;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(m, p);
cout << " got " << m << std::endl;
ASSERT_TRUE(!m.empty());
bufferlist bl;
store->fiemap(ch, oid, SKIP_STEP, SKIP_STEP * (MAX_EXTENTS - 2) + 3, bl);
map<uint64_t,uint64_t> m, e;
- auto p = bl.begin();
+ auto p = bl.cbegin();
decode(m, p);
cout << " got " << m << std::endl;
ASSERT_TRUE(!m.empty());
store->read(ch, txn_object, 0, 100, bl);
int32_t t = 0;
if (bl.length()) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(t, p);
}
if (t > txn) {
ENCODE_FINISH(bl);
}
-void ContDesc::decode(bufferlist::iterator &bl)
+void ContDesc::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(objnum, bl);
return !((*this) == rhs);
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &bp);
+ void decode(bufferlist::const_iterator &bp);
};
WRITE_CLASS_ENCODER(ContDesc)
}
if (old_value.has_contents()) {
ContDesc to_check;
- bufferlist::iterator p = headerbl.begin();
+ auto p = headerbl.cbegin();
decode(to_check, p);
if (to_check != old_value.most_recent()) {
cerr << num << ": oid " << oid << " found incorrect object contents " << to_check
uint32_t checksum = 0;
if (checksum_retvals[i] == 0) {
try {
- auto bl_it = checksums[i].begin();
+ auto bl_it = checksums[i].cbegin();
uint32_t csum_count;
decode(csum_count, bl_it);
decode(checksum, bl_it);
uint32_t checksum[2] = {0};
if (checksum_retvals[1] == 0) {
try {
- auto bl_it = checksums[1].begin();
+ auto bl_it = checksums[1].cbegin();
uint32_t csum_count;
decode(csum_count, bl_it);
decode(checksum[1], bl_it);
int r = comp2->get_return_value();
if (r == 0) {
HitSet hitset;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(hitset, p);
cout << num << ": got hitset of type " << hitset.get_type_name()
<< " size " << bl.length()
void get_crush(CrushWrapper& newcrush) {
bufferlist bl;
osdmap.crush->encode(bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
newcrush.decode(p);
}
int crush_move(const string &name, const vector<string> &argvec) {
bufferlist bl;
params.encode(bl);
BloomHitSet::Params p2;
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
p2.decode(iter);
EXPECT_EQ(0.1, p2.get_fpp());
EXPECT_EQ((unsigned)100, p2.target_size);
encode(d, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(a, bl);
decode(b, bl);
bufferlist b;
DummyBlock dummy_block;
encode(dummy_block, b);
- bufferlist::iterator iter = b.begin();
+ auto iter = b.cbegin();
decode(dummy_block, iter);
}
uint64_t stop = Cycles::rdtsc();
int sum = 0;
uint64_t start = Cycles::rdtsc();
for (int i = 0; i < count; i++) {
- bufferlist::iterator it = b.begin();
+ auto it = b.cbegin();
while (!it.end()) {
sum += (static_cast<const char*>(it.get_current_ptr().c_str()))[it.get_remaining()-1];
++it;
template<>
struct Replay<MockTestImageCtx> {
- MOCK_METHOD2(decode, int(bufferlist::iterator *, EventEntry *));
+ MOCK_METHOD2(decode, int(bufferlist::const_iterator *, EventEntry *));
MOCK_METHOD3(process, void(const EventEntry &, Context *, Context *));
MOCK_METHOD1(flush, void(Context*));
MOCK_METHOD2(shut_down, void(bool, Context*));
EXPECT_CALL(mock_replay_entry, get_data());
C_SaferCond decode_ctx;
EXPECT_CALL(mock_local_replay, decode(_, _))
- .WillOnce(DoAll(Invoke([&decode_ctx](bufferlist::iterator* it,
+ .WillOnce(DoAll(Invoke([&decode_ctx](bufferlist::const_iterator* it,
librbd::journal::EventEntry *e) {
decode_ctx.complete(0);
}),
for (unsigned i = 0; addr_checks2[i][0]; ++i) {
entity_addr_t addr;
entity_addrvec_t addrvec;
- bufferlist::iterator bli;
const char *end = "";
bool ok = addr.parse(addr_checks2[i][0], &end);
ASSERT_TRUE(ok);
bufferlist bl;
addr.encode(bl, 0);
- bli = bl.begin();
+ auto bli = bl.cbegin();
addrvec.decode(bli);
ASSERT_EQ(addr, addrvec.v[0]);
}
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
- bufferlist::iterator bli;
const char *end = "";
bool ok = addr.parse(addr_checks2[i][0], &end);
ASSERT_TRUE(ok);
addrvec.v.push_back(addr);
addrvec.encode(bl, 0);
- bli = bl.begin();
+ auto bli = bl.cbegin();
entity_addr_t a;
a.decode(bli);
ASSERT_EQ(addr, a);
entity_addrvec_t addrvec;
entity_addr_t addr;
bufferlist bl;
- bufferlist::iterator bli;
addrvec.encode(bl, 0);
- bli = bl.begin();
+ auto bli = bl.cbegin();
addr.decode(bli);
ASSERT_EQ(addr, entity_addr_t(1, 0));
}
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
- bufferlist::iterator bli;
for (unsigned i = 0; addrvec_checks[i][0]; ++i) {
const char *end = "";
}
addrvec.encode(bl, 0);
- bli = bl.begin();
+ auto bli = bl.cbegin();
addr.decode(bli);
entity_addr_t addr, a;
entity_addrvec_t addrvec;
bufferlist bl;
- bufferlist::iterator bli;
bool flag = true;
for (unsigned i = 0; addrvec_checks[i][1]; ++i) {
}
addrvec.encode(bl, 0);
- bli = bl.begin();
+ auto bli = bl.cbegin();
addr.decode(bli);
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
- bufferlist::iterator bli;
for (unsigned i = 0; addrvec_checks[i][2]; ++i) {
const char *end = "";
}
addrvec.encode(bl, 0);
- bli = bl.begin();
+ auto bli = bl.cbegin();
addr.decode(bli);
entity_addr_t addr;
entity_addrvec_t addrvec;
bufferlist bl;
- bufferlist::iterator bli;
for (unsigned i = 0; addrvec_checks[i][3]; ++i) {
const char *end = "";
}
addrvec.encode(bl, 0);
- bli = bl.begin();
+ auto bli = bl.cbegin();
addr.decode(bli);
int RadosDump::read_super()
{
bufferlist ebl;
- bufferlist::iterator ebliter = ebl.begin();
+ auto ebliter = ebl.cbegin();
ssize_t bytes;
bytes = ebl.read_fd(file_fd, super_header::FIXED_LENGTH);
assert (h != NULL);
bufferlist ebl;
- bufferlist::iterator ebliter = ebl.begin();
+ auto ebliter = ebl.cbegin();
ssize_t bytes;
bytes = ebl.read_fd(file_fd, sh.header_size);
assert(f != NULL);
bufferlist ebl;
- bufferlist::iterator ebliter = ebl.begin();
+ auto ebliter = ebl.cbegin();
ssize_t bytes;
bytes = ebl.read_fd(file_fd, sh.footer_size);
int RadosDump::skip_object(bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
bufferlist ebl;
bool done = false;
while(!done) {
if (ret)
return ret;
- ebliter = ebl.begin();
if (type >= END_OF_TYPES) {
cout << "Skipping unknown object section type" << std::endl;
continue;
encode(header_size, bl);
encode(footer_size, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(magic, bl);
decode(version, bl);
encode(size, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
uint32_t debug_type;
DECODE_START(1, bl);
decode(debug_type, bl);
encode(magic, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(magic, bl);
DECODE_FINISH(bl);
ENCODE_FINISH(bl);
}
// NOTE: New super_ver prevents decode from ver 1
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(3, bl);
decode(pgid.pgid, bl);
if (struct_v > 1) {
encode(oi, bl, -1); /* FIXME: we always encode with full features */
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(3, bl);
decode(hoid.hobj, bl);
if (struct_v > 1) {
encode(databl, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(offset, bl);
decode(len, bl);
encode(data, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(data, bl);
DECODE_FINISH(bl);
encode(hdr, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(hdr, bl);
DECODE_FINISH(bl);
encode(omap, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode(omap, bl);
DECODE_FINISH(bl);
encode(missing, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
DECODE_START(6, bl);
decode(struct_ver, bl);
decode(map_epoch, bl);
r = bl.read_file(fn.c_str(), &err);
if (r >= 0) {
try {
- bufferlist::iterator iter = bl.begin();
+ auto iter = bl.cbegin();
decode(keyring, iter);
} catch (const buffer::error &err) {
cerr << "error reading file " << fn << std::endl;
int r = obl.read_file(import_keyring.c_str(), &err);
if (r >= 0) {
try {
- bufferlist::iterator iter = obl.begin();
+ auto iter = obl.cbegin();
decode(other, iter);
} catch (const buffer::error &err) {
cerr << "error reading file " << import_keyring << std::endl;
fd = -1;
return;
}
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
uint8_t ver, ver2;
decode(ver, bliter);
decode(ver2, bliter);
fd = -1;
return;
}
- bliter = bl.begin();
+ bliter = bl.cbegin();
t.reset(new MonitorDBStore::Transaction);
t->decode(bliter);
}
std::cerr << err << ": " << cpp_strerror(r) << std::endl;
return r;
}
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
crush->decode(p);
}
}
bufferlist pg_bl = i->value();
pg_stat_t ps;
- bufferlist::iterator p = pg_bl.begin();
+ auto p = pg_bl.cbegin();
decode(ps, p);
// will update the last_epoch_clean of all the pgs.
pg_stat[pgid] = ps;
fs_map.print(ss);
} else if (map_type == "mgr") {
MgrMap mgr_map;
- auto p = bl.begin();
+ auto p = bl.cbegin();
mgr_map.decode(p);
JSONFormatter f;
f.dump_object("mgrmap", mgr_map);
f.flush(ss);
} else if (map_type == "crushmap") {
CrushWrapper cw;
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
cw.decode(it);
CrushCompiler cc(cw, std::cerr, 0);
cc.decompile(ss);
cerr << "Error getting attr on : " << make_pair(coll, *obj) << ", "
<< cpp_strerror(r) << std::endl;
} else {
- bufferlist::iterator bp = attr.begin();
+ auto bp = attr.cbegin();
try {
decode(oi, bp);
} catch (...) {
continue;
bufferlist bl = p->value();
- bufferlist::iterator bp = bl.begin();
+ auto bp = bl.cbegin();
pg_log_entry_t e;
try {
e.decode_with_checksum(bp);
int set_inc_osdmap(ObjectStore *store, epoch_t e, bufferlist& bl, bool force) {
OSDMap::Incremental inc;
- bufferlist::iterator it = bl.begin();
+ auto it = bl.cbegin();
inc.decode(it);
if (e == 0) {
e = inc.epoch;
int dump_data(Formatter *formatter, bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
data_section ds;
ds.decode(ebliter);
int get_data(ObjectStore *store, coll_t coll, ghobject_t hoid,
ObjectStore::Transaction *t, bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
data_section ds;
ds.decode(ebliter);
Formatter *formatter, ghobject_t hoid,
bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
attr_section as;
as.decode(ebliter);
map<string,bufferlist>::iterator mi = as.data.find(SS_ATTR);
if (mi != as.data.end()) {
SnapSet snapset;
- auto p = mi->second.begin();
+ auto p = mi->second.cbegin();
snapset.decode(p);
formatter->open_object_section("snapset");
snapset.dump(formatter);
ObjectStore::Transaction *t, bufferlist &bl,
OSDriver &driver, SnapMapper &snap_mapper)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
attr_section as;
as.decode(ebliter);
map<string,bufferlist>::iterator mi = as.data.find(SS_ATTR);
if (mi != as.data.end()) {
SnapSet snapset;
- auto p = mi->second.begin();
+ auto p = mi->second.cbegin();
snapset.decode(p);
cout << "snapset " << snapset << std::endl;
for (auto& p : snapset.clone_snaps) {
int dump_omap_hdr(Formatter *formatter, bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
omap_hdr_section oh;
oh.decode(ebliter);
int get_omap_hdr(ObjectStore *store, coll_t coll, ghobject_t hoid,
ObjectStore::Transaction *t, bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
omap_hdr_section oh;
oh.decode(ebliter);
int dump_omap(Formatter *formatter, bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
omap_section os;
os.decode(ebliter);
int get_omap(ObjectStore *store, coll_t coll, ghobject_t hoid,
ObjectStore::Transaction *t, bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
omap_section os;
os.decode(ebliter);
int ObjectStoreTool::dump_object(Formatter *formatter,
bufferlist &bl)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
object_begin ob;
ob.decode(ebliter);
{
ObjectStore::Transaction tran;
ObjectStore::Transaction *t = &tran;
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
object_begin ob;
ob.decode(ebliter);
int dump_pg_metadata(Formatter *formatter, bufferlist &bl, metadata_section &ms)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
ms.decode(ebliter);
formatter->open_object_section("metadata_section");
int get_pg_metadata(ObjectStore *store, bufferlist &bl, metadata_section &ms,
const OSDSuperblock& sb, OSDMap& curmap, spg_t pgid)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
ms.decode(ebliter);
spg_t old_pgid = ms.info.pgid;
ms.info.pgid = pgid;
return -EFAULT;
}
- bufferlist::iterator ebliter = ebl.begin();
+ auto ebliter = ebl.cbegin();
pg_begin pgb;
pgb.decode(ebliter);
spg_t pgid = pgb.pgid;
return -EFAULT;
}
- bufferlist::iterator ebliter = ebl.begin();
+ auto ebliter = ebl.cbegin();
pg_begin pgb;
pgb.decode(ebliter);
spg_t pgid = pgb.pgid;
<< cpp_strerror(r) << std::endl;
return r;
}
- bufferlist::iterator bp = attr.begin();
+ auto bp = attr.cbegin();
try {
decode(ss, bp);
} catch (...) {
<< cpp_strerror(r) << std::endl;
} else {
object_info_t oi;
- bufferlist::iterator bp = attr.begin();
+ auto bp = attr.cbegin();
try {
decode(oi, bp);
formatter->open_object_section("info");
return r;
}
object_info_t oi;
- bufferlist::iterator bp = attr.begin();
+ auto bp = attr.cbegin();
try {
decode(oi, bp);
} catch (...) {
bufferlist bl;
OSDSuperblock superblock;
auto ch = fs->open_collection(coll_t::meta());
- bufferlist::iterator p;
+ bufferlist::const_iterator p;
ret = fs->read(ch, OSD_SUPERBLOCK_GOBJECT, 0, 0, bl);
if (ret < 0) {
cerr << "Failure to read OSD superblock: " << cpp_strerror(ret) << std::endl;
goto out;
}
- p = bl.begin();
+ p = bl.cbegin();
decode(superblock, p);
if (debug) {
int r = ioctx.getxattr(oid, "scrub_tag", scrub_tag_bl);
if (r >= 0) {
std::string read_tag;
- bufferlist::iterator q = scrub_tag_bl.begin();
+ auto q = scrub_tag_bl.cbegin();
try {
decode(read_tag, q);
if (read_tag == filter_tag) {
}
for (auto& p : items) {
- bufferlist::iterator q = p.second.begin();
+ auto q = p.second.cbegin();
string dname;
snapid_t last;
dentry_key_t::decode_helper(p.first, dname, last);
if (parent_r != -ENODATA) {
try {
- bufferlist::iterator q = parent_bl.begin();
+ auto q = parent_bl.cbegin();
backtrace.decode(q);
} catch (buffer::error &e) {
dout(4) << "Corrupt backtrace on '" << oid << "': " << e << dendl;
if (layout_r != -ENODATA) {
try {
- bufferlist::iterator q = layout_bl.begin();
+ auto q = layout_bl.cbegin();
decode(loaded_layout, q);
} catch (buffer::error &e) {
dout(4) << "Corrupt layout on '" << oid << "': " << e << dendl;
return r;
}
- bufferlist::iterator old_fnode_iter = fnode_bl.begin();
+ auto old_fnode_iter = fnode_bl.cbegin();
try {
(*fnode).decode(old_fnode_iter);
} catch (const buffer::error &err) {
}
try {
- bufferlist::iterator q = vals[key].begin();
+ auto q = vals[key].cbegin();
snapid_t dnfirst;
decode(dnfirst, q);
char dentry_type;
inode_backtrace_t backtrace;
if (parent_bl.length()) {
try {
- bufferlist::iterator q = parent_bl.begin();
+ auto q = parent_bl.cbegin();
backtrace.decode(q);
have_backtrace = true;
} catch (buffer::error &e) {
JournalPointer jp;
try {
- bufferlist::iterator q = pointer_bl.begin();
+ auto q = pointer_bl.cbegin();
jp.decode(q);
} catch(buffer::error &e) {
derr << "Pointer " << pointer_oid << " is corrupt: " << e.what() << dendl;
header_present = true;
}
- bufferlist::iterator header_bl_i = header_bl.begin();
+ auto header_bl_i = header_bl.cbegin();
header = new Journaler::Header();
try
{
<< ", 0x" << read_buf.length() << std::dec << " bytes available" << dendl;
do {
- bufferlist::iterator p = read_buf.begin();
+ auto p = read_buf.cbegin();
uint64_t candidate_sentinel;
decode(candidate_sentinel, p);
} else if (type == "purge_queue"){
PurgeItem pi;
try {
- bufferlist::iterator q = le_bl.begin();
+ auto q = le_bl.cbegin();
::decode(pi, q);
} catch (const buffer::error &err) {
valid_entry = false;
} else if (r == 0) {
// Conditionally update existing omap header
fnode_t old_fnode;
- bufferlist::iterator old_fnode_iter = old_fnode_bl.begin();
+ auto old_fnode_iter = old_fnode_bl.cbegin();
try {
old_fnode.decode(old_fnode_iter);
dout(4) << "frag " << frag_oid.name << " fnode old v" <<
dout(4) << "dentry exists, checking versions..." << dendl;
bufferlist &old_dentry = read_vals[key];
// Decode dentry+inode
- bufferlist::iterator q = old_dentry.begin();
+ auto q = old_dentry.cbegin();
snapid_t dnfirst;
decode(dnfirst, q);
dout(4) << "dentry exists, checking versions..." << dendl;
bufferlist &old_dentry = read_vals[key];
// Decode dentry+inode
- bufferlist::iterator q = old_dentry.begin();
+ auto q = old_dentry.cbegin();
snapid_t dnfirst;
decode(dnfirst, q);
if (it != read_vals.end()) {
dout(4) << "dentry exists, will remove" << dendl;
- bufferlist::iterator q = it->second.begin();
+ auto q = it->second.cbegin();
snapid_t dnfirst;
decode(dnfirst, q);
char dentry_type;
InodeStore old_inode;
dout(4) << "root exists, will modify (" << old_root_ino_bl.length()
<< ")" << dendl;
- bufferlist::iterator inode_bl_iter = old_root_ino_bl.begin();
+ auto inode_bl_iter = old_root_ino_bl.cbegin();
std::string magic;
decode(magic, inode_bl_iter);
if (magic == CEPH_FS_ONDISK_MAGIC) {
// Deserialize InoTable
version_t inotable_ver;
- bufferlist::iterator q = inotable_bl.begin();
+ auto q = inotable_bl.cbegin();
decode(inotable_ver, q);
InoTable ino_table(NULL);
ino_table.decode(q);
bufferlist table_bl;
int read_r = io->read(object_name, table_bl, 0, 0);
if (read_r >= 0) {
- bufferlist::iterator q = table_bl.begin();
+ auto q = table_bl.cbegin();
try {
if (mds_table) {
version_t version;
return EXIT_FAILURE;
}
}
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
crush.decode(p);
} catch(...) {
// validate
CrushWrapper cw;
- bufferlist::iterator p = cbl.begin();
+ auto p = cbl.cbegin();
cw.decode(p);
if (cw.get_max_devices() > osdmap.get_max_osd()) {
pool_mode = true;
cout << "Importing pool" << std::endl;
} else if (type == TYPE_PG_BEGIN) {
- bufferlist::iterator ebliter = ebl.begin();
+ auto ebliter = ebl.cbegin();
pg_begin pgb;
pgb.decode(ebliter);
spg_t pgid = pgb.pgid;;
int RadosImport::get_object_rados(librados::IoCtx &ioctx, bufferlist &bl, bool no_overwrite)
{
- bufferlist::iterator ebliter = bl.begin();
+ auto ebliter = bl.cbegin();
object_begin ob;
ob.decode(ebliter);
map<string,bufferlist>::iterator i;
return ret;
}
- ebliter = ebl.begin();
+ ebliter = ebl.cbegin();
//cout << "\tdo_object: Section type " << hex << type << dec << std::endl;
//cout << "\t\tsection size " << ebl.length() << std::endl;
if (type >= END_OF_TYPES) {
if (!shard.has_info_corrupted()) {
object_info_t oi;
bufferlist bl;
- bufferlist::iterator bliter = k->second.begin();
+ auto bliter = k->second.cbegin();
decode(oi, bliter); // Can't be corrupted
f.open_object_section("object_info");
oi.dump(&f);
if (!shard.has_snapset_corrupted()) {
SnapSet ss;
bufferlist bl;
- bufferlist::iterator bliter = k->second.begin();
+ auto bliter = k->second.cbegin();
decode(ss, bliter); // Can't be corrupted
f.open_object_section("snapset");
ss.dump(&f);
if (!shard.has_hinfo_corrupted()) {
ECUtil::HashInfo hi;
bufferlist bl;
- bufferlist::iterator bliter = k->second.begin();
+ auto bliter = k->second.cbegin();
decode(hi, bliter); // Can't be corrupted
f.open_object_section("hashinfo");
hi.dump(&f);
bufferlist bl;
auto k = shard.attrs.find(OI_ATTR);
assert(k != shard.attrs.end()); // Can't be missing
- bufferlist::iterator bliter = k->second.begin();
+ auto bliter = k->second.cbegin();
decode(oi, bliter); // Can't be corrupted
f.open_object_section("selected_object_info");
oi.dump(&f);
if (inc.ss_bl.length()) {
SnapSet ss;
bufferlist bl = inc.ss_bl;
- bufferlist::iterator bliter = bl.begin();
+ auto bliter = bl.cbegin();
decode(ss, bliter); // Can't be corrupted
f.open_object_section("snapset");
ss.dump(&f);
cerr << "error reading " << pool_name << "/" << oid << ": " << cpp_strerror(ret) << std::endl;
goto out;
}
- bufferlist::iterator p = outdata.begin();
+ auto p = outdata.cbegin();
bufferlist header;
map<string, bufferlist> kv;
try {
}
bufferlist hdr;
map<string, bufferlist> kv;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(hdr, p);
decode(kv, p);
if (replybl.length()) {
map<pair<uint64_t,uint64_t>,bufferlist> rm;
set<pair<uint64_t,uint64_t> > missed;
- bufferlist::iterator p = replybl.begin();
+ auto p = replybl.cbegin();
decode(rm, p);
decode(missed, p);
for (map<pair<uint64_t,uint64_t>,bufferlist>::iterator p = rm.begin();
void encode(bufferlist& bl) const {
bl.append((const char *)id, ID_SIZE);
}
- void decode(bufferlist::iterator& iter) {
+ void decode(bufferlist::const_iterator& iter) {
iter.copy(ID_SIZE, (char *)id);
}
};
using ceph::encode;
encode(acls_map, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(acls_map, bl);
}
<< " len=" << bl2.length() << std::endl;
ObjectACLs oa;
if (r >= 0) {
- bufferlist::iterator iter = bl2.begin();
+ auto iter = bl2.cbegin();
oa.decode(iter);
}
cout << "ignoring empty keyring: " << keyring_path << std::endl;
return 0;
}
- auto bp = bl.begin();
+ auto bp = bl.cbegin();
try {
decode(keyring, bp);
} catch (const buffer::error& e) {
t->put(prefix, e, bl);
OSDMap::Incremental inc;
- auto p = bl.begin();
+ auto p = bl.cbegin();
inc.decode(p);
features = inc.encode_features | CEPH_FEATURE_RESERVED;
if (osdmap.get_epoch() && e > 1) {
}
t->put(prefix, ms.combine_strings("full", e), bl);
- auto p = bl.begin();
+ auto p = bl.cbegin();
osdmap.decode(p);
if (osdmap.have_crc()) {
if (have_crc && osdmap.get_crc() != crc) {
r = ms.get(prefix, stringify(pgid.pgid), bl);
if (r >= 0) {
pg_stat_t pg_stat;
- auto bp = bl.begin();
+ auto bp = bl.cbegin();
decode(pg_stat, bp);
latest_epoch = pg_stat.reported_epoch;
}
projects / ceph.git / commitdiff