void set_stamp(utime_t t) { stamp = t; }
// encoding
- virtual void encode(bufferlist& bl) const = 0;
+ virtual void encode(bufferlist& bl, uint64_t features) const = 0;
virtual void decode(bufferlist::iterator &bl) = 0;
static LogEvent *decode(bufferlist &bl);
virtual void dump(Formatter *f) const = 0;
- void encode_with_header(bufferlist& bl) {
+ void encode_with_header(bufferlist& bl, uint64_t features) {
::encode(EVENT_NEW_ENCODING, bl);
ENCODE_START(1, 1, bl)
::encode(_type, bl);
- encode(bl);
+ encode(bl, features);
ENCODE_FINISH(bl);
}
LogSegment *ls = le->_segment;
// encode it, with event type
bufferlist bl;
- le->encode_with_header(bl);
+ le->encode_with_header(bl, mds->mdsmap->get_up_features());
uint64_t write_pos = journaler->get_write_pos();
if (modified) {
bl.clear();
- le->encode_with_header(bl);
+ le->encode_with_header(bl, mds->mdsmap->get_up_features());
}
delete le;
out << "ECommitted " << reqid;
}
- void encode(bufferlist &bl) const;
+ void encode(bufferlist &bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ECommitted*>& ls);
void update_segment() {}
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(ECommitted)
#endif
EMetaBlob *get_metablob() { return &metablob; }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EExport*>& ls);
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(EExport)
#endif
EMetaBlob *get_metablob() { return &metablob; }
- void encode(bufferlist &bl) const;
+ void encode(bufferlist &bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EFragment*>& ls);
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(EFragment)
#endif
out << " failed";
}
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EImportFinish*>& ls);
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(EImportFinish)
#endif
EMetaBlob *get_metablob() { return &metablob; }
- void encode(bufferlist &bl) const;
+ void encode(bufferlist &bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EImportStart*>& ls);
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(EImportStart)
#endif
fullbit() {}
~fullbit() {}
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EMetaBlob::fullbit*>& ls);
return state_string;
}
};
- WRITE_CLASS_ENCODER(fullbit)
+ WRITE_CLASS_ENCODER_FEATURES(fullbit)
/* remotebit - a dentry + remote inode link (i.e. just an ino)
*/
}
// if this changes, update the versioning in encode for it!
- void _encode_bits() const {
+ void _encode_bits(uint64_t features) const {
if (!dn_decoded) return;
- ::encode(dfull, dnbl);
+ ::encode(dfull, dnbl, features);
::encode(dremote, dnbl);
::encode(dnull, dnbl);
}
dn_decoded = true;
}
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator &bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<dirlump*>& ls);
};
- WRITE_CLASS_ENCODER(dirlump)
+ WRITE_CLASS_ENCODER_FEATURES(dirlump)
// my lumps. preserve the order we added them in a list.
list<dirfrag_t> lump_order;
list<pair<metareqid_t,uint64_t> > client_flushes;
public:
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void get_inodes(std::set<inodeno_t> &inodes) const;
void get_paths(std::vector<std::string> &paths) const;
void update_segment(LogSegment *ls);
void replay(MDSRank *mds, LogSegment *ls, MDSlaveUpdate *su=NULL);
};
-WRITE_CLASS_ENCODER(EMetaBlob)
-WRITE_CLASS_ENCODER(EMetaBlob::fullbit)
+WRITE_CLASS_ENCODER_FEATURES(EMetaBlob)
+WRITE_CLASS_ENCODER_FEATURES(EMetaBlob::fullbit)
WRITE_CLASS_ENCODER(EMetaBlob::remotebit)
WRITE_CLASS_ENCODER(EMetaBlob::nullbit)
-WRITE_CLASS_ENCODER(EMetaBlob::dirlump)
+WRITE_CLASS_ENCODER_FEATURES(EMetaBlob::dirlump)
inline ostream& operator<<(ostream& out, const EMetaBlob& t) {
t.print(out);
ENoOp() : LogEvent(EVENT_NOOP), pad_size(0) { }
explicit ENoOp(uint32_t size_) : LogEvent(EVENT_NOOP), pad_size(size_){ }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const {}
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(ENoOp)
#endif
inos.push_back(ino);
}
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EOpen*>& ls);
void update_segment();
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(EOpen)
#endif
EResetJournal() : LogEvent(EVENT_RESETJOURNAL) { }
~EResetJournal() {}
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EResetJournal*>& ls);
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(EResetJournal)
#endif
cmapv(v),
inos(i), inotablev(iv) { }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ESession*>& ls);
void replay(MDSRank *mds);
entity_inst_t get_client_inst() const {return client_inst;}
};
+WRITE_CLASS_ENCODER_FEATURES(ESession)
#endif
void mark_old_encoding() { old_style_encode = true; }
- void encode(bufferlist &bl) const;
+ void encode(bufferlist &bl, uint64_t features) const;
void decode_old(bufferlist::iterator &bl);
void decode_new(bufferlist::iterator &bl);
void decode(bufferlist::iterator &bl) {
void update_segment();
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(ESessions)
#endif
EMetaBlob *get_metablob() { return &commit; }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ESlaveUpdate*>& ls);
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(ESlaveUpdate)
#endif
EMetaBlob *get_metablob() { return &metablob; }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ESubtreeMap*>& ls);
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(ESubtreeMap)
#endif
LogEvent(EVENT_TABLECLIENT),
table(t), op(o), tid(ti) { }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ETableClient*>& ls);
//void update_segment();
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(ETableClient)
#endif
LogEvent(EVENT_TABLESERVER),
table(t), op(o), reqid(ri), bymds(m), tid(ti), version(v) { }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<ETableServer*>& ls);
void update_segment();
void replay(MDSRank *mds);
};
+WRITE_CLASS_ENCODER_FEATURES(ETableServer)
#endif
EMetaBlob *get_metablob() { return &metablob; }
- void encode(bufferlist& bl) const;
+ void encode(bufferlist& bl, uint64_t features) const;
void decode(bufferlist::iterator& bl);
void dump(Formatter *f) const;
static void generate_test_instances(list<EUpdate*>& ls);
void replay(MDSRank *mds);
EMetaBlob const *get_metablob() const {return &metablob;}
};
+WRITE_CLASS_ENCODER_FEATURES(EUpdate)
#endif
// EMetaBlob::fullbit
-void EMetaBlob::fullbit::encode(bufferlist& bl) const {
+void EMetaBlob::fullbit::encode(bufferlist& bl, uint64_t features) const {
ENCODE_START(8, 5, bl);
::encode(dn, bl);
::encode(dnfirst, bl);
::encode(false, bl);
} else {
::encode(true, bl);
- ::encode(old_inodes, bl);
+ ::encode(old_inodes, bl, features);
}
if (!inode.is_dir())
::encode(snapbl, bl);
// EMetaBlob::dirlump
-void EMetaBlob::dirlump::encode(bufferlist& bl) const
+void EMetaBlob::dirlump::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(2, 2, bl);
::encode(fnode, bl);
::encode(nfull, bl);
::encode(nremote, bl);
::encode(nnull, bl);
- _encode_bits();
+ _encode_bits(features);
::encode(dnbl, bl);
ENCODE_FINISH(bl);
}
/**
* EMetaBlob proper
*/
-void EMetaBlob::encode(bufferlist& bl) const
+void EMetaBlob::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(8, 5, bl);
::encode(lump_order, bl);
- ::encode(lump_map, bl);
- ::encode(roots, bl);
+ ::encode(lump_map, bl, features);
+ ::encode(roots, bl, features);
::encode(table_tids, bl);
::encode(opened_ino, bl);
::encode(allocated_ino, bl);
update_segment();
}
-void ESession::encode(bufferlist &bl) const
+void ESession::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(4, 3, bl);
::encode(stamp, bl);
// -----------------------
// ESessions
-void ESessions::encode(bufferlist &bl) const
+void ESessions::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(1, 1, bl);
::encode(client_map, bl);
// -----------------------
// ETableServer
-void ETableServer::encode(bufferlist& bl) const
+void ETableServer::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
// ---------------------
// ETableClient
-void ETableClient::encode(bufferlist& bl) const
+void ETableClient::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
// -----------------------
// EUpdate
-void EUpdate::encode(bufferlist &bl) const
+void EUpdate::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(4, 4, bl);
::encode(stamp, bl);
::encode(type, bl);
- ::encode(metablob, bl);
+ ::encode(metablob, bl, features);
::encode(client_map, bl);
::encode(cmapv, bl);
::encode(reqid, bl);
// ------------------------
// EOpen
-void EOpen::encode(bufferlist &bl) const {
+void EOpen::encode(bufferlist &bl, uint64_t features) const {
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
- ::encode(metablob, bl);
+ ::encode(metablob, bl, features);
::encode(inos, bl);
ENCODE_FINISH(bl);
}
}
}
-void ECommitted::encode(bufferlist& bl) const
+void ECommitted::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
ls.back()->stray.remote_d_type = IFTODT(S_IFREG);
}
-void ESlaveUpdate::encode(bufferlist &bl) const
+void ESlaveUpdate::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
::encode(master, bl);
::encode(op, bl);
::encode(origop, bl);
- ::encode(commit, bl);
+ ::encode(commit, bl, features);
::encode(rollback, bl);
ENCODE_FINISH(bl);
}
// -----------------------
// ESubtreeMap
-void ESubtreeMap::encode(bufferlist& bl) const
+void ESubtreeMap::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(6, 5, bl);
::encode(stamp, bl);
- ::encode(metablob, bl);
+ ::encode(metablob, bl, features);
::encode(subtrees, bl);
::encode(ambiguous_subtrees, bl);
::encode(expire_pos, bl);
in->verify_dirfrags();
}
-void EFragment::encode(bufferlist &bl) const {
+void EFragment::encode(bufferlist &bl, uint64_t features) const {
ENCODE_START(5, 4, bl);
::encode(stamp, bl);
::encode(op, bl);
::encode(ino, bl);
::encode(basefrag, bl);
::encode(bits, bl);
- ::encode(metablob, bl);
+ ::encode(metablob, bl, features);
::encode(orig_frags, bl);
::encode(rollback, bl);
ENCODE_FINISH(bl);
mds->mdcache->try_trim_non_auth_subtree(dir);
}
-void EExport::encode(bufferlist& bl) const
+void EExport::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
- ::encode(metablob, bl);
+ ::encode(metablob, bl, features);
::encode(base, bl);
::encode(bounds, bl);
ENCODE_FINISH(bl);
update_segment();
}
-void EImportStart::encode(bufferlist &bl) const {
+void EImportStart::encode(bufferlist &bl, uint64_t features) const {
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
::encode(base, bl);
- ::encode(metablob, bl);
+ ::encode(metablob, bl, features);
::encode(bounds, bl);
::encode(cmapv, bl);
::encode(client_map, bl);
}
}
-void EImportFinish::encode(bufferlist& bl) const
+void EImportFinish::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(3, 3, bl);
::encode(stamp, bl);
// ------------------------
// EResetJournal
-void EResetJournal::encode(bufferlist& bl) const
+void EResetJournal::encode(bufferlist& bl, uint64_t features) const
{
ENCODE_START(2, 2, bl);
::encode(stamp, bl);
}
-void ENoOp::encode(bufferlist &bl) const
+void ENoOp::encode(bufferlist &bl, uint64_t features) const
{
ENCODE_START(2, 2, bl);
::encode(pad_size, bl);
TYPE_STRAYDATA(SnapServer)
#include "mds/events/ECommitted.h"
-TYPE(ECommitted)
+TYPE_FEATUREFUL(ECommitted)
#include "mds/events/EExport.h"
-TYPE(EExport)
+TYPE_FEATUREFUL(EExport)
#include "mds/events/EFragment.h"
-TYPE(EFragment)
+TYPE_FEATUREFUL(EFragment)
#include "mds/events/EImportFinish.h"
-TYPE(EImportFinish)
+TYPE_FEATUREFUL(EImportFinish)
#include "mds/events/EImportStart.h"
-TYPE(EImportStart)
+TYPE_FEATUREFUL(EImportStart)
#include "mds/events/EMetaBlob.h"
-TYPE_NOCOPY(EMetaBlob::fullbit)
+TYPE_FEATUREFUL_NOCOPY(EMetaBlob::fullbit)
TYPE(EMetaBlob::remotebit)
TYPE(EMetaBlob::nullbit)
-TYPE(EMetaBlob::dirlump)
-TYPE(EMetaBlob)
+TYPE_FEATUREFUL(EMetaBlob::dirlump)
+TYPE_FEATUREFUL(EMetaBlob)
#include "mds/events/EOpen.h"
-TYPE(EOpen)
+TYPE_FEATUREFUL(EOpen)
#include "mds/events/EResetJournal.h"
-TYPE(EResetJournal)
+TYPE_FEATUREFUL(EResetJournal)
#include "mds/events/ESession.h"
-TYPE(ESession)
+TYPE_FEATUREFUL(ESession)
#include "mds/events/ESessions.h"
-TYPE(ESessions)
+TYPE_FEATUREFUL(ESessions)
#include "mds/events/ESlaveUpdate.h"
TYPE(link_rollback)
TYPE(rmdir_rollback)
TYPE(rename_rollback::drec)
TYPE(rename_rollback)
-TYPE(ESlaveUpdate)
+TYPE_FEATUREFUL(ESlaveUpdate)
#include "mds/events/ESubtreeMap.h"
-TYPE(ESubtreeMap)
+TYPE_FEATUREFUL(ESubtreeMap)
#include "mds/events/ETableClient.h"
-TYPE(ETableClient)
+TYPE_FEATUREFUL(ETableClient)
#include "mds/events/ETableServer.h"
-TYPE(ETableServer)
+TYPE_FEATUREFUL(ETableServer)
#include "mds/events/EUpdate.h"
-TYPE(EUpdate)
+TYPE_FEATUREFUL(EUpdate)
#ifdef WITH_RBD
#include "librbd/journal/Types.h"
for (JournalScanner::EventMap::const_iterator i = scan.events.begin(); i != scan.events.end(); ++i) {
LogEvent *le = i->second.log_event;
bufferlist le_bin;
- le->encode(le_bin);
+ le->encode(le_bin, CEPH_FEATURES_SUPPORTED_DEFAULT);
std::stringstream filename;
filename << "0x" << std::hex << i->first << std::dec << "_" << le->get_type_str() << ".bin";
// is needed inside the ENoOp to make up the difference.
bufferlist tmp;
ENoOp enoop(0);
- enoop.encode_with_header(tmp);
+ enoop.encode_with_header(tmp, CEPH_FEATURES_SUPPORTED_DEFAULT);
dout(4) << "erase_region " << pos << " len=" << length << dendl;
// Serialize an ENoOp with the correct amount of padding
enoop = ENoOp(padding);
bufferlist entry;
- enoop.encode_with_header(entry);
+ enoop.encode_with_header(entry, CEPH_FEATURES_SUPPORTED_DEFAULT);
JournalStream stream(JOURNAL_FORMAT_RESILIENT);
// Serialize region of log stream
LogEvent *le = new EResetJournal;
bufferlist bl;
- le->encode_with_header(bl);
+ le->encode_with_header(bl, CEPH_FEATURES_SUPPORTED_DEFAULT);
cout << "writing EResetJournal entry" << std::endl;
C_SaferCond cond;