ENCODE_FINISH(bl);
}
-void Anchor::decode(bufferlist::iterator &bl)
+void Anchor::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(ino, bl);
ino(i), dirino(di), d_name(str), d_type(tp) {}
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<Anchor*>& ls);
};
return dir->is_freezing();
}
-void CDentry::decode_replica(bufferlist::iterator& p, bool is_new)
+void CDentry::decode_replica(bufferlist::const_iterator& p, bool is_new)
{
__u32 nonce;
decode(nonce, p);
void CDentry::decode_lock_state(int type, bufferlist& bl)
{
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
snapid_t newfirst;
decode(newfirst, p);
lock.encode_state_for_replica(bl);
encode(need_recover, bl);
}
- void decode_replica(bufferlist::iterator& p, bool is_new);
+ void decode_replica(bufferlist::const_iterator& p, bool is_new);
// -- exporting
// note: this assumes the dentry already exists.
void abort_export() {
put(PIN_TEMPEXPORTING);
}
- void decode_import(bufferlist::iterator& blp, LogSegment *ls) {
+ void decode_import(bufferlist::const_iterator& blp, LogSegment *ls) {
decode(first, blp);
__u32 nstate;
decode(nstate, blp);
const std::set<snapid_t> *snaps,
bool *force_dirty)
{
- bufferlist::iterator q = bl.begin();
+ auto q = bl.cbegin();
snapid_t first;
decode(first, q);
fnode_t got_fnode;
{
- bufferlist::iterator p = hdrbl.begin();
+ auto p = hdrbl.cbegin();
try {
decode(got_fnode, p);
} catch (const buffer::error &err) {
dirty_old_rstat.clear();
}
-void CDir::decode_import(bufferlist::iterator& blp, utime_t now, LogSegment *ls)
+void CDir::decode_import(bufferlist::const_iterator& blp, utime_t now, LogSegment *ls)
{
decode(first, blp);
decode(fnode, blp);
encode(dir_rep, bl);
encode(dir_rep_by, bl);
}
- void _decode_base(bufferlist::iterator& p) {
+ void _decode_base(bufferlist::const_iterator& p) {
decode(first, p);
decode(fnode, p);
decode(dir_rep, p);
encode(nonce, bl);
_encode_base(bl);
}
- void decode_replica(bufferlist::iterator& p) {
+ void decode_replica(bufferlist::const_iterator& p) {
__u32 nonce;
decode(nonce, p);
replica_nonce = nonce;
void abort_export() {
put(PIN_TEMPEXPORTING);
}
- void decode_import(bufferlist::iterator& blp, utime_t now, LogSegment *ls);
+ void decode_import(bufferlist::const_iterator& blp, utime_t now, LogSegment *ls);
void abort_import(utime_t now);
// -- auth pins --
void CInode::_fetched(bufferlist& bl, bufferlist& bl2, Context *fin)
{
dout(10) << __func__ << " got " << bl.length() << " and " << bl2.length() << dendl;
- bufferlist::iterator p;
+ bufferlist::const_iterator p;
if (bl2.length()) {
- p = bl2.begin();
+ p = bl2.cbegin();
} else if (bl.length()) {
- p = bl.begin();
+ p = bl.cbegin();
} else {
derr << "No data while reading inode " << ino() << dendl;
fin->complete(-ENOENT);
&snap_blob);
}
-void InodeStoreBase::decode_bare(bufferlist::iterator &bl,
+void InodeStoreBase::decode_bare(bufferlist::const_iterator &bl,
bufferlist& snap_blob, __u8 struct_v)
{
using ceph::decode;
}
-void InodeStoreBase::decode(bufferlist::iterator &bl, bufferlist& snap_blob)
+void InodeStoreBase::decode(bufferlist::const_iterator &bl, bufferlist& snap_blob)
{
DECODE_START_LEGACY_COMPAT_LEN(5, 4, 4, bl);
decode_bare(bl, snap_blob, struct_v);
DECODE_FINISH(bl);
}
-void CInode::decode_store(bufferlist::iterator& bl)
+void CInode::decode_store(bufferlist::const_iterator& bl)
{
bufferlist snap_blob;
InodeStoreBase::decode(bl, snap_blob);
void CInode::decode_lock_state(int type, bufferlist& bl)
{
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
utime_t tm;
snapid_t newfirst;
if (snapbl.length()) {
open_snaprealm();
auto old_flags = snaprealm->srnode.flags;
- bufferlist::iterator p = snapbl.begin();
+ auto p = snapbl.cbegin();
decode(snaprealm->srnode, p);
if (is_base()) {
bool ok = snaprealm->_open_parents(NULL);
encode(oldest_snap, bl);
}
-void CInode::decode_snap(bufferlist::iterator& p)
+void CInode::decode_snap(bufferlist::const_iterator& p)
{
using ceph::decode;
bufferlist snapbl;
encode(damage_flags, bl);
encode_snap(bl);
}
-void CInode::_decode_base(bufferlist::iterator& p)
+void CInode::_decode_base(bufferlist::const_iterator& p)
{
using ceph::decode;
decode(first, p);
encode(loner_cap, bl);
}
-void CInode::_decode_locks_full(bufferlist::iterator& p)
+void CInode::_decode_locks_full(bufferlist::const_iterator& p)
{
using ceph::decode;
decode(authlock, p);
policylock.encode_state_for_replica(bl);
}
-void CInode::_decode_locks_state(bufferlist::iterator& p, bool is_new)
+void CInode::_decode_locks_state(bufferlist::const_iterator& p, bool is_new)
{
authlock.decode_state(p, is_new);
linklock.decode_state(p, is_new);
policylock.mark_need_recover();
}
}
-void CInode::_decode_locks_rejoin(bufferlist::iterator& p, list<MDSInternalContextBase*>& waiters,
+void CInode::_decode_locks_rejoin(bufferlist::const_iterator& p, list<MDSInternalContextBase*>& waiters,
list<SimpleLock*>& eval_locks, bool survivor)
{
authlock.decode_state_rejoin(p, waiters, survivor);
put(PIN_TEMPEXPORTING);
}
-void CInode::decode_import(bufferlist::iterator& p,
+void CInode::decode_import(bufferlist::const_iterator& p,
LogSegment *ls)
{
DECODE_START(5, p);
// decode fragstat info on bounding cdirs
bufferlist bounding;
decode(bounding, p);
- bufferlist::iterator q = bounding.begin();
+ auto q = bounding.cbegin();
while (!q.end()) {
frag_t fg;
decode(fg, q);
// extract the backtrace, and compare it to a newly-constructed one
try {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
using ceph::decode;
decode(results->backtrace.ondisk_value, p);
dout(10) << "decoded " << bl.length() << " bytes of backtrace successfully" << dendl;
/* Full serialization for use in ".inode" root inode objects */
void encode(bufferlist &bl, uint64_t features, const bufferlist *snap_blob=NULL) const;
- void decode(bufferlist::iterator &bl, bufferlist& snap_blob);
+ void decode(bufferlist::const_iterator &bl, bufferlist& snap_blob);
/* Serialization without ENCODE_START/FINISH blocks for use embedded in dentry */
void encode_bare(bufferlist &bl, uint64_t features, const bufferlist *snap_blob=NULL) const;
- void decode_bare(bufferlist::iterator &bl, bufferlist &snap_blob, __u8 struct_v=5);
+ void decode_bare(bufferlist::const_iterator &bl, bufferlist &snap_blob, __u8 struct_v=5);
/* For test/debug output */
void dump(Formatter *f) const;
void encode(bufferlist &bl, uint64_t features) const {
InodeStoreBase::encode(bl, features, &snap_blob);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
InodeStoreBase::decode(bl, snap_blob);
}
void encode_bare(bufferlist &bl, uint64_t features) const {
InodeStoreBase::encode_bare(bl, features, &snap_blob);
}
- void decode_bare(bufferlist::iterator &bl) {
+ void decode_bare(bufferlist::const_iterator &bl) {
InodeStoreBase::decode_bare(bl, snap_blob);
}
void encode(bufferlist &bl, uint64_t features) const {
InodeStore::encode_bare(bl, features);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
InodeStore::decode_bare(bl);
}
static void generate_test_instances(std::list<InodeStoreBare*>& ls);
if (has_flock_locks)
encode(*flock_locks, bl);
}
- void _decode_file_locks(bufferlist::iterator& p) {
+ void _decode_file_locks(bufferlist::const_iterator& p) {
using ceph::decode;
bool has_fcntl_locks;
decode(has_fcntl_locks, p);
void encode_snap_blob(bufferlist &bl);
void decode_snap_blob(bufferlist &bl);
void encode_store(bufferlist& bl, uint64_t features);
- void decode_store(bufferlist::iterator& bl);
+ void decode_store(bufferlist::const_iterator& bl);
void encode_replica(mds_rank_t rep, bufferlist& bl, uint64_t features, bool need_recover) {
assert(is_auth());
_encode_base(bl, features);
_encode_locks_state_for_replica(bl, need_recover);
}
- void decode_replica(bufferlist::iterator& p, bool is_new) {
+ void decode_replica(bufferlist::const_iterator& p, bool is_new) {
using ceph::decode;
__u32 nonce;
decode(nonce, p);
// -- encode/decode helpers --
void _encode_base(bufferlist& bl, uint64_t features);
- void _decode_base(bufferlist::iterator& p);
+ void _decode_base(bufferlist::const_iterator& p);
void _encode_locks_full(bufferlist& bl);
- void _decode_locks_full(bufferlist::iterator& p);
+ void _decode_locks_full(bufferlist::const_iterator& p);
void _encode_locks_state_for_replica(bufferlist& bl, bool need_recover);
void _encode_locks_state_for_rejoin(bufferlist& bl, int rep);
- void _decode_locks_state(bufferlist::iterator& p, bool is_new);
- void _decode_locks_rejoin(bufferlist::iterator& p, std::list<MDSInternalContextBase*>& waiters,
+ void _decode_locks_state(bufferlist::const_iterator& p, bool is_new);
+ void _decode_locks_rejoin(bufferlist::const_iterator& p, std::list<MDSInternalContextBase*>& waiters,
std::list<SimpleLock*>& eval_locks, bool survivor);
// -- import/export --
state_clear(STATE_EXPORTINGCAPS);
put(PIN_EXPORTINGCAPS);
}
- void decode_import(bufferlist::iterator& p, LogSegment *ls);
+ void decode_import(bufferlist::const_iterator& p, LogSegment *ls);
// for giving to clients
void close_snaprealm(bool no_join=false);
SnapRealm *find_snaprealm() const;
void encode_snap(bufferlist& bl);
- void decode_snap(bufferlist::iterator& p);
+ void decode_snap(bufferlist::const_iterator& p);
// -- caps -- (new)
// client caps
ENCODE_FINISH(bl);
}
-void Capability::Export::decode(bufferlist::iterator &p)
+void Capability::Export::decode(bufferlist::const_iterator &p)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, p);
decode(cap_id, p);
ENCODE_FINISH(bl);
}
-void Capability::Import::decode(bufferlist::iterator &bl)
+void Capability::Import::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(cap_id, bl);
ENCODE_FINISH(bl);
}
-void Capability::revoke_info::decode(bufferlist::iterator& bl)
+void Capability::revoke_info::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(before, bl);
ENCODE_FINISH(bl);
}
-void Capability::decode(bufferlist::iterator &bl)
+void Capability::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl)
decode(last_sent, bl);
cap_id(id), wanted(w), issued(i), pending(p), client_follows(cf),
seq(s), mseq(m), last_issue_stamp(lis) {}
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<Export*>& ls);
};
Import() : cap_id(0), issue_seq(0), mseq(0) {}
Import(int64_t i, ceph_seq_t s, ceph_seq_t m) : cap_id(i), issue_seq(s), mseq(m) {}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &p);
+ void decode(bufferlist::const_iterator &p);
void dump(Formatter *f) const;
};
struct revoke_info {
revoke_info() : before(0), seq(0), last_issue(0) {}
revoke_info(__u32 b, ceph_seq_t s, ceph_seq_t li) : before(b), seq(s), last_issue(li) {}
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<revoke_info*>& ls);
};
// serializers
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<Capability*>& ls);
}
}
-void FSMap::decode(bufferlist::iterator& p)
+void FSMap::decode(bufferlist::const_iterator& p)
{
// The highest MDSMap encoding version before we changed the
// MDSMonitor to store an FSMap instead of an MDSMap was
ENCODE_FINISH(bl);
}
-void Filesystem::decode(bufferlist::iterator& p)
+void Filesystem::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(fscid, p);
bufferlist mdsmap_bl;
decode(mdsmap_bl, p);
- bufferlist::iterator mdsmap_bl_iter = mdsmap_bl.begin();
+ auto mdsmap_bl_iter = mdsmap_bl.cbegin();
mds_map.decode(mdsmap_bl_iter);
DECODE_FINISH(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;
void print(std::ostream& out) const;
void sanity() const;
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void decode(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(p);
}
void sanitize(const std::function<bool(int64_t pool)>& pool_exists);
ENCODE_FINISH(bl);
}
-void FSMapUser::decode(bufferlist::iterator& p)
+void FSMapUser::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(epoch, p);
ENCODE_FINISH(bl);
}
-void FSMapUser::fs_info_t::decode(bufferlist::iterator& p)
+void FSMapUser::fs_info_t::decode(bufferlist::const_iterator& p)
{
DECODE_START(1, p);
decode(cid, p);
std::string name;
fs_info_t() : cid(FS_CLUSTER_ID_NONE) {}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
};
epoch_t epoch;
}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void print(ostream& out) const;
void print_summary(Formatter *f, ostream *out);
encode(free, bl);
ENCODE_FINISH(bl);
}
- void decode_state(bufferlist::iterator& bl) override {
+ void decode_state(bufferlist::const_iterator& bl) override {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(free, bl);
projected_free = free;
void encode(bufferlist& bl) const {
encode_state(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
decode_state(bl);
}
void dump(Formatter *f) const;
// Construct JournalPointer result, null or decoded data
if (r == 0) {
- bufferlist::iterator q = data.begin();
+ auto q = data.cbegin();
try {
decode(q);
} catch (const buffer::error &e) {
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator &bl) {
+ void decode(bufferlist::const_iterator &bl) {
DECODE_START(1, bl);
decode(front, bl);
decode(back, bl);
dout(7) << " xattrs v" << i->xattr_version << " -> " << m->head.xattr_version
<< " len " << m->xattrbl.length() << dendl;
i->xattr_version = m->head.xattr_version;
- bufferlist::iterator p = m->xattrbl.begin();
+ auto p = m->xattrbl.cbegin();
decode(*px, p);
}
if (m->flockbl.length()) {
int32_t num_locks;
- bufferlist::iterator bli = m->flockbl.begin();
+ auto bli = m->flockbl.cbegin();
decode(num_locks, bli);
for ( int i=0; i < num_locks; ++i) {
ceph_filelock decoded_lock;
if (xattr) {
dout(7) << " xattrs v" << pi.inode.xattr_version << " -> " << m->head.xattr_version << dendl;
pi.inode.xattr_version = m->head.xattr_version;
- bufferlist::iterator p = m->xattrbl.begin();
+ auto p = m->xattrbl.cbegin();
decode(*pi.xattrs, p);
wrlock_force(&in->xattrlock, mut);
}
LogEvent *LogEvent::decode(bufferlist& bl)
{
// parse type, length
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
EventType type;
LogEvent *event = NULL;
using ceph::decode;
}
-LogEvent *LogEvent::decode_event(bufferlist& bl, bufferlist::iterator& p, LogEvent::EventType type)
+LogEvent *LogEvent::decode_event(bufferlist& bl, bufferlist::const_iterator& p, LogEvent::EventType type)
{
int length = bl.length() - p.get_off();
generic_dout(15) << "decode_log_event type " << type << ", size " << length << dendl;
private:
EventType _type;
uint64_t _start_off;
- static LogEvent *decode_event(bufferlist& bl, bufferlist::iterator& p, EventType type);
+ static LogEvent *decode_event(bufferlist& bl, bufferlist::const_iterator& p, EventType type);
protected:
utime_t stamp;
// encoding
virtual void encode(bufferlist& bl, uint64_t features) const = 0;
- virtual void decode(bufferlist::iterator &bl) = 0;
+ virtual void decode(bufferlist::const_iterator &bl) = 0;
static LogEvent *decode(bufferlist &bl);
virtual void dump(Formatter *f) const = 0;
inodeno_t ino;
map<client_t,Capability::Export> cap_exports;
- bufferlist::iterator q = p->second.inode_caps.begin();
+ auto q = p->second.inode_caps.cbegin();
decode(ino, q);
decode(cap_exports, q);
++p) {
CDir *dir = get_dirfrag(p->first);
assert(dir);
- bufferlist::iterator q = p->second.begin();
+ auto q = p->second.cbegin();
dir->_decode_base(q);
dout(10) << " got dir replica " << *dir << dendl;
}
// full inodes
- bufferlist::iterator p = ack->inode_base.begin();
+ auto p = ack->inode_base.cbegin();
while (!p.end()) {
inodeno_t ino;
snapid_t last;
decode(basebl, p);
CInode *in = get_inode(ino, last);
assert(in);
- bufferlist::iterator q = basebl.begin();
+ auto q = basebl.cbegin();
snapid_t sseq = 0;
if (in->snaprealm)
sseq = in->snaprealm->srnode.seq;
}
// inodes
- p = ack->inode_locks.begin();
+ p = ack->inode_locks.cbegin();
//dout(10) << "inode_locks len " << ack->inode_locks.length() << " is " << ack->inode_locks << dendl;
while (!p.end()) {
inodeno_t ino;
CInode *in = get_inode(ino, last);
assert(in);
in->set_replica_nonce(nonce);
- bufferlist::iterator q = lockbl.begin();
+ auto q = lockbl.cbegin();
in->_decode_locks_rejoin(q, rejoin_waiters, rejoin_eval_locks, survivor);
in->state_clear(CInode::STATE_REJOINING);
dout(10) << " got inode locks " << *in << dendl;
assert(isolated_inodes.empty());
map<inodeno_t,map<client_t,Capability::Import> > peer_imported;
- bufferlist::iterator bp = ack->imported_caps.begin();
+ auto bp = ack->imported_caps.cbegin();
decode(peer_imported, bp);
for (map<inodeno_t,map<client_t,Capability::Import> >::iterator p = peer_imported.begin();
assert(!in->is_auth());
if (mds->get_state() > MDSMap::STATE_REJOIN ||
(mds->is_rejoin() && !in->is_rejoining())) {
- bufferlist::iterator p = m->snap_blob.begin();
+ auto p = m->snap_blob.cbegin();
in->decode_snap(p);
if (!notify_clients) {
// starting point
CInode *cur = get_inode(m->get_base_ino());
- bufferlist::iterator p = m->trace.begin();
+ auto p = m->trace.cbegin();
int next = m->starts_with;
in->encode_replica(to, bl, features, mds->get_state() < MDSMap::STATE_ACTIVE);
}
-CDir *MDCache::add_replica_dir(bufferlist::iterator& p, CInode *diri, mds_rank_t from,
+CDir *MDCache::add_replica_dir(bufferlist::const_iterator& p, CInode *diri, mds_rank_t from,
list<MDSInternalContextBase*>& finished)
{
dirfrag_t df;
return dir;
}
-CDentry *MDCache::add_replica_dentry(bufferlist::iterator& p, CDir *dir, list<MDSInternalContextBase*>& finished)
+CDentry *MDCache::add_replica_dentry(bufferlist::const_iterator& p, CDir *dir, list<MDSInternalContextBase*>& finished)
{
string name;
snapid_t last;
return dn;
}
-CInode *MDCache::add_replica_inode(bufferlist::iterator& p, CDentry *dn, list<MDSInternalContextBase*>& finished)
+CInode *MDCache::add_replica_inode(bufferlist::const_iterator& p, CDentry *dn, list<MDSInternalContextBase*>& finished)
{
inodeno_t ino;
snapid_t last;
CDentry *MDCache::add_replica_stray(bufferlist &bl, mds_rank_t from)
{
list<MDSInternalContextBase*> finished;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
CInode *mdsin = add_replica_inode(p, NULL, finished);
CDir *mdsdir = add_replica_dir(p, mdsin, from, finished);
}
}
- bufferlist::iterator p = m->bl.begin();
+ auto p = m->bl.cbegin();
list<MDSInternalContextBase*> finished;
if (dn) {
if (m->get_is_primary()) {
diri->take_dir_waiting((*p)->get_frag(), waiters);
// add new replica dirs values
- bufferlist::iterator p = notify->basebl.begin();
+ auto p = notify->basebl.cbegin();
while (!p.end())
add_replica_dir(p, diri, mds_rank_t(notify->get_source().num()), waiters);
list<MDSInternalContextBase*> waiters;
adjust_dir_fragments(diri, p->first.frag, -uf.bits, resultfrags, waiters, true);
} else {
- bufferlist::iterator bp = uf.rollback.begin();
+ auto bp = uf.rollback.cbegin();
for (list<frag_t>::iterator q = uf.old_frags.begin(); q != uf.old_frags.end(); ++q) {
CDir *dir = force_dir_fragment(diri, *q);
resultfrags.push_back(dir);
void replicate_inode(CInode *in, mds_rank_t to, bufferlist& bl,
uint64_t features);
- CDir* add_replica_dir(bufferlist::iterator& p, CInode *diri, mds_rank_t from, list<MDSInternalContextBase*>& finished);
- CDentry *add_replica_dentry(bufferlist::iterator& p, CDir *dir, list<MDSInternalContextBase*>& finished);
- CInode *add_replica_inode(bufferlist::iterator& p, CDentry *dn, list<MDSInternalContextBase*>& finished);
+ CDir* add_replica_dir(bufferlist::const_iterator& p, CInode *diri, mds_rank_t from, list<MDSInternalContextBase*>& finished);
+ CDentry *add_replica_dentry(bufferlist::const_iterator& p, CDir *dir, list<MDSInternalContextBase*>& finished);
+ CInode *add_replica_inode(bufferlist::const_iterator& p, CDentry *dn, list<MDSInternalContextBase*>& finished);
void replicate_stray(CDentry *straydn, mds_rank_t who, bufferlist& bl);
CDentry *add_replica_stray(bufferlist &bl, mds_rank_t from);
// Flag for auth providers that don't provide cap strings
s->auth_caps.set_allow_all();
} else {
- bufferlist::iterator p = caps_info.caps.begin();
+ auto p = caps_info.caps.cbegin();
string auth_cap_str;
try {
decode(auth_cap_str, p);
encode(export_targets, bl);
}
-void MDSMap::mds_info_t::decode(bufferlist::iterator& bl)
+void MDSMap::mds_info_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(7, 4, 4, bl);
decode(global_id, bl);
}
}
-void MDSMap::decode(bufferlist::iterator& p)
+void MDSMap::decode(bufferlist::const_iterator& p)
{
std::map<mds_rank_t,int32_t> inc; // Legacy field, parse and drop
if ((features & CEPH_FEATURE_MDSENC) == 0 ) encode_unversioned(bl);
else encode_versioned(bl, features);
}
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void dump(Formatter *f) const;
void print_summary(ostream &out) const;
return -1;
}
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& p);
+ void decode(bufferlist::const_iterator& p);
void decode(bufferlist& bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
decode(p);
}
void sanitize(const std::function<bool(int64_t pool)>& pool_exists);
}
dout(10) << "load_2 got " << bl.length() << " bytes" << dendl;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
try {
decode(version, p);
// child must overload these
virtual void reset_state() = 0;
- virtual void decode_state(bufferlist::iterator& p) = 0;
+ virtual void decode_state(bufferlist::const_iterator& p) = 0;
virtual void encode_state(bufferlist& bl) const = 0;
};
void do_server_update(bufferlist& bl);
virtual void encode_server_state(bufferlist& bl) const = 0;
- virtual void decode_server_state(bufferlist::iterator& bl) = 0;
+ virtual void decode_server_state(bufferlist::const_iterator& bl) = 0;
void encode_state(bufferlist& bl) const override {
encode_server_state(bl);
encode(pending_for_mds, bl);
}
- void decode_state(bufferlist::iterator& bl) override {
+ void decode_state(bufferlist::const_iterator& bl) override {
decode_server_state(bl);
decode(pending_for_mds, bl);
}
assert(it->second.state == EXPORT_EXPORTING);
assert(it->second.tid == m->get_tid());
- bufferlist::iterator bp = m->imported_caps.begin();
+ auto bp = m->imported_caps.cbegin();
decode(it->second.peer_imported, bp);
it->second.state = EXPORT_LOGGINGFINISH;
assert(it->second.peer == oldauth);
diri = cache->get_inode(m->get_dirfrag().ino);
assert(diri);
- bufferlist::iterator p = m->basedir.begin();
+ auto p = m->basedir.cbegin();
dir = cache->add_replica_dir(p, diri, oldauth, finished);
dout(7) << "handle_export_prep on " << *dir << " (first pass)" << dendl;
} else {
for (list<bufferlist>::iterator p = m->traces.begin();
p != m->traces.end();
++p) {
- bufferlist::iterator q = p->begin();
+ auto q = p->cbegin();
dirfrag_t df;
decode(df, q);
char start;
// new client sessions, open these after we journal
// include imported sessions in EImportStart
- bufferlist::iterator cmp = m->client_map.begin();
+ auto cmp = m->client_map.cbegin();
map<client_t,entity_inst_t> client_map;
decode(client_map, cmp);
assert(cmp.end());
le->cmapv = mds->server->prepare_force_open_sessions(client_map, onlogged->imported_session_map);
encode(client_map, le->client_map, mds->mdsmap->get_up_features());
- bufferlist::iterator blp = m->export_data.begin();
+ auto blp = m->export_data.cbegin();
int num_imported_inodes = 0;
while (!blp.end()) {
num_imported_inodes +=
}
-void Migrator::decode_import_inode(CDentry *dn, bufferlist::iterator& blp,
+void Migrator::decode_import_inode(CDentry *dn, bufferlist::const_iterator& blp,
mds_rank_t oldauth, LogSegment *ls,
map<CInode*, map<client_t,Capability::Export> >& peer_exports,
list<ScatterLock*>& updated_scatterlocks)
}
void Migrator::decode_import_inode_caps(CInode *in, bool auth_cap,
- bufferlist::iterator &blp,
+ bufferlist::const_iterator &blp,
map<CInode*, map<client_t,Capability::Export> >& peer_exports)
{
map<client_t,Capability::Export> cap_map;
}
}
-int Migrator::decode_import_dir(bufferlist::iterator& blp,
+int Migrator::decode_import_dir(bufferlist::const_iterator& blp,
mds_rank_t oldauth,
CDir *import_root,
EImportStart *le,
version_t pv = mds->server->prepare_force_open_sessions(client_map,
finish->imported_session_map);
// decode new caps
- bufferlist::iterator blp = ex->cap_bl.begin();
+ auto blp = ex->cap_bl.cbegin();
decode_import_inode_caps(in, false, blp, finish->peer_exports);
assert(!finish->peer_exports.empty()); // thus, inode is pinned.
void export_caps(CInode *in);
- void decode_import_inode(CDentry *dn, bufferlist::iterator& blp,
+ void decode_import_inode(CDentry *dn, bufferlist::const_iterator& blp,
mds_rank_t oldauth, LogSegment *ls,
map<CInode*, map<client_t,Capability::Export> >& cap_imports,
list<ScatterLock*>& updated_scatterlocks);
- void decode_import_inode_caps(CInode *in, bool auth_cap, bufferlist::iterator &blp,
+ void decode_import_inode_caps(CInode *in, bool auth_cap, bufferlist::const_iterator &blp,
map<CInode*, map<client_t,Capability::Export> >& cap_imports);
void finish_import_inode_caps(CInode *in, mds_rank_t from, bool auth_cap,
const map<client_t,pair<Session*,uint64_t> >& smap,
const map<client_t,Capability::Export> &export_map,
map<client_t,Capability::Import> &import_map);
- int decode_import_dir(bufferlist::iterator& blp,
+ int decode_import_dir(bufferlist::const_iterator& blp,
mds_rank_t oldauth,
CDir *import_root,
EImportStart *le,
int err = -EINVAL;
auto decode_func = [this](unsigned idx, inodeno_t ino, bufferlist &bl) {
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
size_t count = loaded_anchor_map.size();
auto it = loaded_anchor_map.emplace_hint(loaded_anchor_map.end(),
try {
if (first) {
- bufferlist::iterator p = header_bl.begin();
+ auto p = header_bl.cbegin();
version_t version;
unsigned num_objs;
__u8 jstate;
for (auto& it : loaded_journal) {
if (journal_state != JOURNAL_FINISH)
continue;
- bufferlist::iterator p = it.second.begin();
+ auto p = it.second.cbegin();
version_t version;
std::map<string, bufferlist> to_update;
std::set<string> to_remove;
ENCODE_FINISH(bl);
}
-void PurgeItem::decode(bufferlist::iterator &p)
+void PurgeItem::decode(bufferlist::const_iterator &p)
{
DECODE_START(1, p);
decode((uint8_t&)action, p);
dout(20) << " decoding entry" << dendl;
PurgeItem item;
- bufferlist::iterator q = bl.begin();
+ auto q = bl.cbegin();
try {
decode(item, q);
} catch (const buffer::error &err) {
{}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator &p);
+ void decode(bufferlist::const_iterator &p);
};
WRITE_CLASS_ENCODER(PurgeItem)
encode(s, bl);
}
- void decode_state_rejoin(bufferlist::iterator& p, list<MDSInternalContextBase*>& waiters, bool survivor) {
+ void decode_state_rejoin(bufferlist::const_iterator& p, list<MDSInternalContextBase*>& waiters, bool survivor) {
SimpleLock::decode_state_rejoin(p, waiters, survivor);
if (is_flushing()) {
set_dirty();
if (!locks.length()) return;
int numlocks;
ceph_filelock lock;
- bufferlist::iterator p = locks.begin();
+ auto p = locks.cbegin();
decode(numlocks, p);
for (int i = 0; i < numlocks; ++i) {
decode(lock, p);
MClientRequest *req = mdr->client_request;
if (req->get_data().length()) {
- bufferlist::iterator p = req->get_data().begin();
+ auto p = req->get_data().cbegin();
// xattrs on new inode?
CInode::mempool_xattr_map xattrs;
pi.inode.nlink--;
if (targeti->is_projected_snaprealm_global()) {
assert(mdr->slave_request->desti_snapbl.length());
- auto p = mdr->slave_request->desti_snapbl.begin();
+ auto p = mdr->slave_request->desti_snapbl.cbegin();
sr_t *newsnap = targeti->project_snaprealm();
decode(*newsnap, p);
void Server::do_link_rollback(bufferlist &rbl, mds_rank_t master, MDRequestRef& mdr)
{
link_rollback rollback;
- bufferlist::iterator p = rbl.begin();
+ auto p = rbl.cbegin();
decode(rollback, p);
dout(10) << "do_link_rollback on " << rollback.reqid
map<client_t,MClientSnap*> splits;
if (rollback.snapbl.length() && in->snaprealm) {
bool hadrealm;
- bufferlist::iterator p = rollback.snapbl.begin();
+ auto p = rollback.snapbl.cbegin();
decode(hadrealm, p);
if (hadrealm) {
if (!mds->is_resolve()) {
// the file system are taking place here, so there is no Mutation.
rmdir_rollback rollback;
- bufferlist::iterator p = rbl.begin();
+ auto p = rbl.cbegin();
decode(rollback, p);
dout(10) << "do_rmdir_rollback on " << rollback.reqid << dendl;
if (rollback.snapbl.length() && in->snaprealm) {
bool hadrealm;
- bufferlist::iterator p = rollback.snapbl.begin();
+ auto p = rollback.snapbl.cbegin();
decode(hadrealm, p);
if (hadrealm) {
decode(in->snaprealm->srnode, p);
CDentry::linkage_t *srcdnl = srcdn->get_linkage();
/* import node */
- bufferlist::iterator blp = mdr->more()->inode_import.begin();
+ auto blp = mdr->more()->inode_import.cbegin();
// imported caps
map<client_t,entity_inst_t> client_map;
if (mdr->slave_request) {
if (mdr->slave_request->desti_snapbl.length() > 0) {
new_srnode = new sr_t();
- auto p = mdr->slave_request->desti_snapbl.begin();
+ auto p = mdr->slave_request->desti_snapbl.cbegin();
decode(*new_srnode, p);
}
} else if (auto& desti_srnode = mdr->more()->desti_srnode) {
if (mdr->slave_request) {
if (mdr->slave_request->srci_snapbl.length() > 0) {
sr_t *new_srnode = new sr_t();
- auto p = mdr->slave_request->srci_snapbl.begin();
+ auto p = mdr->slave_request->srci_snapbl.cbegin();
decode(*new_srnode, p);
srci->project_snaprealm(new_srnode);
}
}
map<client_t,Capability::Import> peer_imported;
- bufferlist::iterator bp = mdr->more()->inode_import.begin();
+ auto bp = mdr->more()->inode_import.cbegin();
decode(peer_imported, bp);
dout(10) << " finishing inode export on " << *destdnl->get_inode() << dendl;
bool finish_mdr)
{
rename_rollback rollback;
- bufferlist::iterator p = rbl.begin();
+ auto p = rbl.cbegin();
decode(rollback, p);
dout(10) << "do_rename_rollback on " << rollback.reqid << dendl;
if (rollback.srci_snapbl.length() && in->snaprealm) {
bool hadrealm;
- bufferlist::iterator p = rollback.srci_snapbl.begin();
+ auto p = rollback.srci_snapbl.cbegin();
decode(hadrealm, p);
if (hadrealm) {
if (projected && !mds->is_resolve()) {
if (rollback.desti_snapbl.length() && target->snaprealm) {
bool hadrealm;
- bufferlist::iterator p = rollback.desti_snapbl.begin();
+ auto p = rollback.desti_snapbl.cbegin();
decode(hadrealm, p);
if (hadrealm) {
if (projected && !mds->is_resolve()) {
version_t stid = mdr->more()->stid;
snapid_t snapid;
- bufferlist::iterator p = mdr->more()->snapidbl.begin();
+ auto p = mdr->more()->snapidbl.cbegin();
decode(snapid, p);
dout(10) << " stid " << stid << " snapid " << snapid << dendl;
return;
}
version_t stid = mdr->more()->stid;
- bufferlist::iterator p = mdr->more()->snapidbl.begin();
+ auto p = mdr->more()->snapidbl.cbegin();
snapid_t seq;
decode(seq, p);
dout(10) << " stid is " << stid << ", seq is " << seq << dendl;
{
dout(10) << "_rmsnap_finish " << *mdr << " " << snapid << dendl;
snapid_t stid = mdr->more()->stid;
- bufferlist::iterator p = mdr->more()->snapidbl.begin();
+ auto p = mdr->more()->snapidbl.cbegin();
snapid_t seq;
decode(seq, p);
void SessionMapStore::decode_header(
bufferlist &header_bl)
{
- bufferlist::iterator q = header_bl.begin();
+ auto q = header_bl.cbegin();
DECODE_START(1, q)
decode(version, q);
DECODE_FINISH(q);
Session *s = get_or_add_session(inst);
if (s->is_closed())
s->set_state(Session::STATE_OPEN);
- bufferlist::iterator q = i->second.begin();
+ auto q = i->second.cbegin();
s->decode(q);
}
}
void SessionMap::_load_legacy_finish(int r, bufferlist &bl)
{
- bufferlist::iterator blp = bl.begin();
+ auto blp = bl.cbegin();
if (r < 0) {
derr << "_load_finish got " << cpp_strerror(r) << dendl;
assert(0 == "failed to load sessionmap");
/**
* Deserialize sessions, and update by_state index
*/
-void SessionMap::decode_legacy(bufferlist::iterator &p)
+void SessionMap::decode_legacy(bufferlist::const_iterator &p)
{
// Populate `sessions`
SessionMapStore::decode_legacy(p);
return session->get_state_seq();
}
-void SessionMapStore::decode_legacy(bufferlist::iterator& p)
+void SessionMapStore::decode_legacy(bufferlist::const_iterator& p)
{
utime_t now = ceph_clock_now();
uint64_t pre;
decode(n, p);
while (n-- && !p.end()) {
- bufferlist::iterator p2 = p;
+ auto p2 = p;
Session *s = new Session;
s->info.decode(p);
if (session_map.count(s->info.inst.name)) {
}
}
-void Session::decode(bufferlist::iterator &p)
+void Session::decode(bufferlist::const_iterator &p)
{
info.decode(p);
state_seq++;
}
}
- void decode(bufferlist::iterator &p);
+ void decode(bufferlist::const_iterator &p);
void set_client_metadata(std::map<std::string, std::string> const &meta);
std::string get_human_name() const {return human_name;}
virtual void encode_header(bufferlist *header_bl);
virtual void decode_header(bufferlist &header_bl);
virtual void decode_values(std::map<std::string, bufferlist> &session_vals);
- virtual void decode_legacy(bufferlist::iterator& blp);
+ virtual void decode_legacy(bufferlist::const_iterator& blp);
void dump(Formatter *f) const;
void set_rank(mds_rank_t r)
}
// sessions
- void decode_legacy(bufferlist::iterator& blp) override;
+ void decode_legacy(bufferlist::const_iterator& blp) override;
bool empty() const { return session_map.empty(); }
const ceph::unordered_map<entity_name_t, Session*> &get_sessions() const
{
encode(empty_gather_set, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START(2, p);
decode(state, p);
set<__s32> g;
using ceph::encode;
encode(s, bl);
}
- void decode_state(bufferlist::iterator& p, bool is_new=true) {
+ void decode_state(bufferlist::const_iterator& p, bool is_new=true) {
using ceph::decode;
__s16 s;
decode(s, p);
if (is_new)
state = s;
}
- void decode_state_rejoin(bufferlist::iterator& p, list<MDSInternalContextBase*>& waiters, bool survivor) {
+ void decode_state_rejoin(bufferlist::const_iterator& p, list<MDSInternalContextBase*>& waiters, bool survivor) {
__s16 s;
using ceph::decode;
decode(s, p);
char type;
using ceph::decode;
- bufferlist::iterator p = m->bl.begin();
+ auto p = m->bl.cbegin();
decode(type, p);
switch (type) {
{
using ceph::decode;
using ceph::encode;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
__u32 op;
decode(op, p);
void SnapServer::_server_update(bufferlist& bl)
{
using ceph::decode;
- bufferlist::iterator p = bl.begin();
+ auto p = bl.cbegin();
map<int, vector<snapid_t> > purge;
decode(purge, p);
using ceph::encode;
using ceph::decode;
char op;
- bufferlist::iterator p = req->bl.begin();
+ auto p = req->bl.cbegin();
decode(op, p);
MMDSTableRequest *reply = new MMDSTableRequest(table, TABLESERVER_OP_QUERY_REPLY, req->reqid, version);
encode(snaprealm_v2_since, bl);
ENCODE_FINISH(bl);
}
- void decode_server_state(bufferlist::iterator& bl) override {
+ void decode_server_state(bufferlist::const_iterator& bl) override {
DECODE_START_LEGACY_COMPAT_LEN(5, 3, 3, bl);
decode(last_snap, bl);
decode(snaps, bl);
void encode(bufferlist& bl) const {
encode_server_state(bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
decode_server_state(bl);
}
}
void encode(bufferlist &bl, uint64_t features) const override;
- void decode(bufferlist::iterator &bl) override;
+ void decode(bufferlist::const_iterator &bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<ECommitted*>& ls);
EMetaBlob *get_metablob() override { return &metablob; }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator &bl) override;
+ void decode(bufferlist::const_iterator &bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<EExport*>& ls);
void replay(MDSRank *mds) override;
fnode_t fnode;
dirfrag_rollback() { }
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
};
WRITE_CLASS_ENCODER(dirfrag_rollback)
EMetaBlob *get_metablob() override { return &metablob; }
void encode(bufferlist &bl, uint64_t features) const override;
- void decode(bufferlist::iterator &bl) override;
+ void decode(bufferlist::const_iterator &bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<EFragment*>& ls);
void replay(MDSRank *mds) override;
}
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator &bl) override;
+ void decode(bufferlist::const_iterator &bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<EImportFinish*>& ls);
EMetaBlob *get_metablob() override { return &metablob; }
void encode(bufferlist &bl, uint64_t features) const override;
- void decode(bufferlist::iterator &bl) override;
+ void decode(bufferlist::const_iterator &bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<EImportStart*>& ls);
old_inodes = *oi;
snapbl = sbl;
}
- explicit fullbit(bufferlist::iterator &p) {
+ explicit fullbit(bufferlist::const_iterator &p) {
decode(p);
}
fullbit() {}
~fullbit() {}
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<EMetaBlob::fullbit*>& ls);
remotebit(std::string_view d, snapid_t df, snapid_t dl, version_t v, inodeno_t i, unsigned char dt, bool dr) :
dn(d), dnfirst(df), dnlast(dl), dnv(v), ino(i), d_type(dt), dirty(dr) { }
- explicit remotebit(bufferlist::iterator &p) { decode(p); }
+ explicit remotebit(bufferlist::const_iterator &p) { decode(p); }
remotebit(): dnfirst(0), dnlast(0), dnv(0), ino(0),
d_type('\0'), dirty(false) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
void print(ostream& out) const {
out << " remotebit dn " << dn << " [" << dnfirst << "," << dnlast << "] dnv " << dnv
<< " ino " << ino
nullbit(std::string_view d, snapid_t df, snapid_t dl, version_t v, bool dr) :
dn(d), dnfirst(df), dnlast(dl), dnv(v), dirty(dr) { }
- explicit nullbit(bufferlist::iterator &p) { decode(p); }
+ explicit nullbit(bufferlist::const_iterator &p) { decode(p); }
nullbit(): dnfirst(0), dnlast(0), dnv(0), dirty(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<nullbit*>& ls);
void print(ostream& out) {
void _decode_bits() const {
using ceph::decode;
if (dn_decoded) return;
- bufferlist::iterator p = dnbl.begin();
+ auto p = dnbl.cbegin();
decode(dfull, p);
decode(dremote, p);
decode(dnull, p);
}
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<dirlump*>& ls);
};
public:
void encode(bufferlist& bl, uint64_t features) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void get_inodes(std::set<inodeno_t> &inodes) const;
void get_paths(std::vector<std::string> &paths) const;
void get_dentries(std::map<dirfrag_t, std::set<std::string> > &dentries) const;
explicit ENoOp(uint32_t size_) : LogEvent(EVENT_NOOP), pad_size(size_){ }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override {}
void replay(MDSRank *mds) override;
}
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<EOpen*>& ls);
~EResetJournal() override {}
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<EResetJournal*>& ls);
void print(ostream& out) const override {
inos(i), inotablev(iv) { }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<ESession*>& ls);
void mark_old_encoding() { old_style_encode = true; }
void encode(bufferlist &bl, uint64_t features) const override;
- void decode_old(bufferlist::iterator &bl);
- void decode_new(bufferlist::iterator &bl);
- void decode(bufferlist::iterator &bl) override {
+ void decode_old(bufferlist::const_iterator &bl);
+ void decode_new(bufferlist::const_iterator &bl);
+ void decode(bufferlist::const_iterator &bl) override {
if (old_style_encode) decode_old(bl);
else decode_new(bl);
}
link_rollback() : ino(0), was_inc(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<link_rollback*>& ls);
};
bufferlist snapbl;
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<rmdir_rollback*>& ls);
};
drec() : remote_d_type((char)S_IFREG) {}
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<drec*>& ls);
};
bufferlist desti_snapbl;
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<rename_rollback*>& ls);
};
EMetaBlob *get_metablob() override { return &commit; }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<ESlaveUpdate*>& ls);
EMetaBlob *get_metablob() override { return &metablob; }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<ESubtreeMap*>& ls);
table(t), op(o), tid(ti) { }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<ETableClient*>& ls);
table(t), op(o), reqid(ri), bymds(m), tid(ti), version(v) { }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<ETableServer*>& ls);
EMetaBlob *get_metablob() override { return &metablob; }
void encode(bufferlist& bl, uint64_t features) const override;
- void decode(bufferlist::iterator& bl) override;
+ void decode(bufferlist::const_iterator& bl) override;
void dump(Formatter *f) const override;
static void generate_test_instances(list<EUpdate*>& ls);
encode(held_locks, bl);
encode(client_held_lock_counts, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(held_locks, bl);
decode(client_held_lock_counts, bl);
ENCODE_FINISH(bl);
}
-void inode_backpointer_t::decode(bufferlist::iterator& bl)
+void inode_backpointer_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(dirino, bl);
DECODE_FINISH(bl);
}
-void inode_backpointer_t::decode_old(bufferlist::iterator& bl)
+void inode_backpointer_t::decode_old(bufferlist::const_iterator& bl)
{
using ceph::decode;
decode(dirino, bl);
ENCODE_FINISH(bl);
}
-void inode_backtrace_t::decode(bufferlist::iterator& bl)
+void inode_backtrace_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(5, 4, 4, bl);
if (struct_v < 3)
inode_backpointer_t(inodeno_t i, std::string_view d, version_t v) : dirino(i), dname(d), version(v) {}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator &bl);
- void decode_old(bufferlist::iterator &bl);
+ void decode(bufferlist::const_iterator &bl);
+ void decode_old(bufferlist::const_iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<inode_backpointer_t*>& ls);
};
inode_backtrace_t() : pool(-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(list<inode_backtrace_t*>& ls);
ENCODE_FINISH(bl);
}
-void EMetaBlob::fullbit::decode(bufferlist::iterator &bl) {
+void EMetaBlob::fullbit::decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(7, 5, 5, bl);
decode(dn, bl);
decode(dnfirst, bl);
ENCODE_FINISH(bl);
}
-void EMetaBlob::remotebit::decode(bufferlist::iterator &bl)
+void EMetaBlob::remotebit::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(dn, bl);
ENCODE_FINISH(bl);
}
-void EMetaBlob::nullbit::decode(bufferlist::iterator &bl)
+void EMetaBlob::nullbit::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(dn, bl);
ENCODE_FINISH(bl);
}
-void EMetaBlob::dirlump::decode(bufferlist::iterator &bl)
+void EMetaBlob::dirlump::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl)
decode(fnode, bl);
encode(client_flushes, bl);
ENCODE_FINISH(bl);
}
-void EMetaBlob::decode(bufferlist::iterator &bl)
+void EMetaBlob::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(7, 5, 5, bl);
decode(lump_order, bl);
bufferlist rootbl;
decode(rootbl, bl);
if (rootbl.length()) {
- bufferlist::iterator p = rootbl.begin();
+ auto p = rootbl.cbegin();
roots.push_back(ceph::shared_ptr<fullbit>(new fullbit(p)));
}
}
ENCODE_FINISH(bl);
}
-void ESession::decode(bufferlist::iterator &bl)
+void ESession::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 3, 3, bl);
if (struct_v >= 2)
ENCODE_FINISH(bl);
}
-void ESessions::decode_old(bufferlist::iterator &bl)
+void ESessions::decode_old(bufferlist::const_iterator &bl)
{
using ceph::decode;
decode(client_map, bl);
decode(stamp, bl);
}
-void ESessions::decode_new(bufferlist::iterator &bl)
+void ESessions::decode_new(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(client_map, bl);
ENCODE_FINISH(bl);
}
-void ETableServer::decode(bufferlist::iterator &bl)
+void ETableServer::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
ENCODE_FINISH(bl);
}
-void ETableClient::decode(bufferlist::iterator &bl)
+void ETableClient::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
ENCODE_FINISH(bl);
}
-void EUpdate::decode(bufferlist::iterator &bl)
+void EUpdate::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(4, 4, 4, bl);
if (struct_v >= 2)
<< " < " << cmapv << dendl;
// open client sessions?
map<client_t,entity_inst_t> cm;
- bufferlist::iterator blp = client_map.begin();
+ auto blp = client_map.cbegin();
using ceph::decode;
decode(cm, blp);
mds->sessionmap.replay_open_sessions(cm);
ENCODE_FINISH(bl);
}
-void EOpen::decode(bufferlist::iterator &bl) {
+void EOpen::decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
decode(stamp, bl);
ENCODE_FINISH(bl);
}
-void ECommitted::decode(bufferlist::iterator& bl)
+void ECommitted::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
ENCODE_FINISH(bl);
}
-void link_rollback::decode(bufferlist::iterator &bl)
+void link_rollback::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(reqid, bl);
ENCODE_FINISH(bl);
}
-void rmdir_rollback::decode(bufferlist::iterator& bl)
+void rmdir_rollback::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(reqid, bl);
ENCODE_FINISH(bl);
}
-void rename_rollback::drec::decode(bufferlist::iterator &bl)
+void rename_rollback::drec::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(dirfrag, bl);
ENCODE_FINISH(bl);
}
-void rename_rollback::decode(bufferlist::iterator &bl)
+void rename_rollback::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(reqid, bl);
ENCODE_FINISH(bl);
}
-void ESlaveUpdate::decode(bufferlist::iterator &bl)
+void ESlaveUpdate::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
ENCODE_FINISH(bl);
}
-void ESubtreeMap::decode(bufferlist::iterator &bl)
+void ESubtreeMap::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 5, 5, bl);
if (struct_v >= 2)
ENCODE_FINISH(bl);
}
-void EFragment::decode(bufferlist::iterator &bl) {
+void EFragment::decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(5, 4, 4, bl);
if (struct_v >= 2)
decode(stamp, bl);
ENCODE_FINISH(bl);
}
-void dirfrag_rollback::decode(bufferlist::iterator &bl)
+void dirfrag_rollback::decode(bufferlist::const_iterator &bl)
{
DECODE_START(1, bl);
decode(fnode, bl);
ENCODE_FINISH(bl);
}
-void EExport::decode(bufferlist::iterator &bl)
+void EExport::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
dout(10) << "EImportStart.replay sessionmap " << mds->sessionmap.get_version()
<< " < " << cmapv << dendl;
map<client_t,entity_inst_t> cm;
- bufferlist::iterator blp = client_map.begin();
+ auto blp = client_map.cbegin();
using ceph::decode;
decode(cm, blp);
mds->sessionmap.replay_open_sessions(cm);
ENCODE_FINISH(bl);
}
-void EImportStart::decode(bufferlist::iterator &bl) {
+void EImportStart::decode(bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
decode(stamp, bl);
ENCODE_FINISH(bl);
}
-void EImportFinish::decode(bufferlist::iterator &bl)
+void EImportFinish::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 3, 3, bl);
if (struct_v >= 2)
ENCODE_FINISH(bl);
}
-void EResetJournal::decode(bufferlist::iterator &bl)
+void EResetJournal::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(stamp, bl);
}
-void ENoOp::decode(bufferlist::iterator &bl)
+void ENoOp::decode(bufferlist::const_iterator &bl)
{
DECODE_START(2, bl);
decode(pad_size, bl);
ENCODE_FINISH(bl);
}
-void frag_info_t::decode(bufferlist::iterator &bl)
+void frag_info_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(version, bl);
ENCODE_FINISH(bl);
}
-void nest_info_t::decode(bufferlist::iterator &bl)
+void nest_info_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(version, bl);
ENCODE_FINISH(bl);
}
-void client_writeable_range_t::decode(bufferlist::iterator& bl)
+void client_writeable_range_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(range.first, bl);
else
encode(bufferlist(), bl);
}
-void inline_data_t::decode(bufferlist::iterator &p)
+void inline_data_t::decode(bufferlist::const_iterator &p)
{
using ceph::decode;
decode(version, p);
ENCODE_FINISH(bl);
}
-void fnode_t::decode(bufferlist::iterator &bl)
+void fnode_t::decode(bufferlist::const_iterator &bl)
{
DECODE_START_LEGACY_COMPAT_LEN(3, 2, 2, bl);
decode(version, bl);
ENCODE_FINISH(bl);
}
-void old_rstat_t::decode(bufferlist::iterator& bl)
+void old_rstat_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(first, bl);
ENCODE_FINISH(bl);
}
-void session_info_t::decode(bufferlist::iterator& p)
+void session_info_t::decode(bufferlist::const_iterator& p)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 2, 2, p);
decode(inst, p);
ENCODE_FINISH(bl);
}
-void string_snap_t::decode(bufferlist::iterator& bl)
+void string_snap_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(name, bl);
ENCODE_FINISH(bl);
}
-void MDSCacheObjectInfo::decode(bufferlist::iterator& p)
+void MDSCacheObjectInfo::decode(bufferlist::const_iterator& p)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, p);
decode(ino, p);
ENCODE_FINISH(bl);
}
-void mds_table_pending_t::decode(bufferlist::iterator& bl)
+void mds_table_pending_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(reqid, bl);
ENCODE_FINISH(bl);
}
-void inode_load_vec_t::decode(const utime_t &t, bufferlist::iterator &p)
+void inode_load_vec_t::decode(const utime_t &t, bufferlist::const_iterator &p)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, p);
for (auto &i : vec) {
ENCODE_FINISH(bl);
}
-void mds_load_t::decode(const utime_t &t, bufferlist::iterator &bl) {
+void mds_load_t::decode(const utime_t &t, bufferlist::const_iterator &bl) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(auth, t, bl);
decode(all, t, bl);
encode_nohead(flockbl, bl);
}
-void cap_reconnect_t::decode(bufferlist::iterator& bl) {
+void cap_reconnect_t::decode(bufferlist::const_iterator& bl) {
DECODE_START(1, bl);
decode_old(bl); // extract out when something changes
if (struct_v >= 2)
DECODE_FINISH(bl);
}
-void cap_reconnect_t::decode_old(bufferlist::iterator& bl) {
+void cap_reconnect_t::decode_old(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(path, bl);
decode(capinfo, bl);
}
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<frag_info_t*>& ls);
};
}
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<nest_info_t*>& ls);
};
encode(ino, bl);
encode(snapid, bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
using ceph::decode;
decode(ino, p);
decode(snapid, p);
encode(max_files, bl);
ENCODE_FINISH(bl);
}
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
DECODE_START_LEGACY_COMPAT_LEN(1, 1, 1, p);
decode(max_bytes, p);
decode(max_files, p);
client_writeable_range_t() {}
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<client_writeable_range_t*>& ls);
};
-inline void decode(client_writeable_range_t::byte_range_t& range, bufferlist::iterator& bl) {
+inline void decode(client_writeable_range_t::byte_range_t& range, bufferlist::const_iterator& bl) {
decode(range.first, bl);
decode(range.last, bl);
}
return !(*this == o);
}
void encode(bufferlist &bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
};
WRITE_CLASS_ENCODER(inline_data_t)
}
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(std::list<inode_t*>& ls);
/**
}
template<template<typename> class Allocator>
-void inode_t<Allocator>::decode(bufferlist::iterator &p)
+void inode_t<Allocator>::decode(bufferlist::const_iterator &p)
{
DECODE_START_LEGACY_COMPAT_LEN(15, 6, 6, p);
ENCODE_DUMP_POST(cl);
}
template<template<typename> class Allocator>
-inline void decode(inode_t<Allocator> &c, ::ceph::bufferlist::iterator &p)
+inline void decode(inode_t<Allocator> &c, ::ceph::bufferlist::const_iterator &p)
{
c.decode(p);
}
xattr_map<Allocator> xattrs;
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(std::list<old_inode_t*>& ls);
};
}
template<template<typename> class Allocator>
-void old_inode_t<Allocator>::decode(bufferlist::iterator& bl)
+void old_inode_t<Allocator>::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(first, bl);
ENCODE_DUMP_POST(cl);
}
template<template<typename> class Allocator>
-inline void decode(old_inode_t<Allocator> &c, ::ceph::bufferlist::iterator &p)
+inline void decode(old_inode_t<Allocator> &c, ::ceph::bufferlist::const_iterator &p)
{
c.decode(p);
}
utime_t localized_scrub_stamp;
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<fnode_t*>& ls);
fnode_t() {}
nest_info_t rstat, accounted_rstat;
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<old_rstat_t*>& ls);
};
}
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<session_info_t*>& ls);
};
oss << name << "_" << b;
key = oss.str();
}
- static void decode_helper(bufferlist::iterator& bl, string& nm, snapid_t& sn) {
+ static void decode_helper(bufferlist::const_iterator& bl, string& nm, snapid_t& sn) {
string key;
decode(key, bl);
decode_helper(key, nm, sn);
string_snap_t(const char *n, snapid_t s) : name(n), snapid(s) {}
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<string_snap_t*>& ls);
};
version_t tid = 0;
mds_table_pending_t() {}
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<mds_table_pending_t*>& ls);
};
encode(name, bl);
encode(tid, bl);
}
- void decode(bufferlist::iterator &p) {
+ void decode(bufferlist::const_iterator &p) {
using ceph::decode;
decode(name, p);
decode(tid, p);
flockbl.claim(lb);
}
void encode(bufferlist& bl) const;
- void decode(bufferlist::iterator& bl);
+ void decode(bufferlist::const_iterator& bl);
void encode_old(bufferlist& bl) const;
- void decode_old(bufferlist::iterator& bl);
+ void decode_old(bufferlist::const_iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<cap_reconnect_t*>& ls);
encode(path, bl);
encode(capinfo, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(path, bl);
decode(capinfo, bl);
encode(ino, bl);
encode(frag, bl);
}
- void decode(bufferlist::iterator& bl) {
+ void decode(bufferlist::const_iterator& bl) {
using ceph::decode;
decode(ino, bl);
decode(frag, bl);
vec[i].reset(now);
}
void encode(bufferlist &bl) const;
- void decode(const utime_t &t, bufferlist::iterator &p);
+ void decode(const utime_t &t, bufferlist::const_iterator &p);
// for dencoder
- void decode(bufferlist::iterator& p) { utime_t sample; decode(sample, p); }
+ void decode(bufferlist::const_iterator& p) { utime_t sample; decode(sample, p); }
void dump(Formatter *f);
static void generate_test_instances(list<inode_load_vec_t*>& ls);
};
inline void encode(const inode_load_vec_t &c, bufferlist &bl) { c.encode(bl); }
-inline void decode(inode_load_vec_t & c, const utime_t &t, bufferlist::iterator &p) {
+inline void decode(inode_load_vec_t & c, const utime_t &t, bufferlist::const_iterator &p) {
c.decode(t, p);
}
// for dencoder
-inline void decode(inode_load_vec_t & c, bufferlist::iterator &p) {
+inline void decode(inode_load_vec_t & c, bufferlist::const_iterator &p) {
utime_t sample;
c.decode(sample, p);
}
}
ENCODE_FINISH(bl);
}
- void decode(const utime_t &t, bufferlist::iterator &p) {
+ void decode(const utime_t &t, bufferlist::const_iterator &p) {
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, p);
for (auto &i : vec) {
decode(i, t, p);
DECODE_FINISH(p);
}
// for dencoder infrastructure
- void decode(bufferlist::iterator& p) {
+ void decode(bufferlist::const_iterator& p) {
utime_t sample;
decode(sample, p);
}
};
inline void encode(const dirfrag_load_vec_t &c, bufferlist &bl) { c.encode(bl); }
-inline void decode(dirfrag_load_vec_t& c, const utime_t &t, bufferlist::iterator &p) {
+inline void decode(dirfrag_load_vec_t& c, const utime_t &t, bufferlist::const_iterator &p) {
c.decode(t, p);
}
// this for dencoder
-inline void decode(dirfrag_load_vec_t& c, bufferlist::iterator &p) {
+inline void decode(dirfrag_load_vec_t& c, bufferlist::const_iterator &p) {
utime_t sample;
c.decode(sample, p);
}
double mds_load(); // defiend in MDBalancer.cc
void encode(bufferlist& bl) const;
- void decode(const utime_t& now, bufferlist::iterator& bl);
+ void decode(const utime_t& now, bufferlist::const_iterator& bl);
//this one is for dencoder infrastructure
- void decode(bufferlist::iterator& bl) { utime_t sample; decode(sample, bl); }
+ void decode(bufferlist::const_iterator& bl) { utime_t sample; decode(sample, bl); }
void dump(Formatter *f) const;
static void generate_test_instances(list<mds_load_t*>& ls);
};
inline void encode(const mds_load_t &c, bufferlist &bl) { c.encode(bl); }
-inline void decode(mds_load_t &c, const utime_t &t, bufferlist::iterator &p) {
+inline void decode(mds_load_t &c, const utime_t &t, bufferlist::const_iterator &p) {
c.decode(t, p);
}
// this one is for dencoder
-inline void decode(mds_load_t &c, bufferlist::iterator &p) {
+inline void decode(mds_load_t &c, bufferlist::const_iterator &p) {
utime_t sample;
c.decode(sample, p);
}
MDSCacheObjectInfo() {}
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<MDSCacheObjectInfo*>& ls);
};
ENCODE_FINISH(bl);
}
-void SnapInfo::decode(bufferlist::iterator& bl)
+void SnapInfo::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(snapid, bl);
ENCODE_FINISH(bl);
}
-void snaplink_t::decode(bufferlist::iterator& bl)
+void snaplink_t::decode(bufferlist::const_iterator& bl)
{
DECODE_START_LEGACY_COMPAT_LEN(2, 2, 2, bl);
decode(ino, bl);
ENCODE_FINISH(bl);
}
-void sr_t::decode(bufferlist::iterator& p)
+void sr_t::decode(bufferlist::const_iterator& p)
{
DECODE_START_LEGACY_COMPAT_LEN(6, 4, 4, p);
if (struct_v == 2) {
mutable string long_name; ///< cached _$ino_$name
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<SnapInfo*>& ls);
snapid_t first;
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<snaplink_t*>& ls);
};
{}
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<sr_t*>& ls);
};
projects / ceph-ci.git / commitdiff