#include "mds/mdstypes.h"
-class MCacheExpire : public Message {
+class MCacheExpire : public SafeMessage {
private:
__s32 from;
int get_from() const { return from; }
protected:
- MCacheExpire() : Message{MSG_MDS_CACHEEXPIRE}, from(-1) {}
+ MCacheExpire() : SafeMessage{MSG_MDS_CACHEEXPIRE}, from(-1) {}
MCacheExpire(int f) :
- Message{MSG_MDS_CACHEEXPIRE},
+ SafeMessage{MSG_MDS_CACHEEXPIRE},
from(f) { }
~MCacheExpire() override {}
#include "msg/Message.h"
-class MClientCapRelease : public Message {
+class MClientCapRelease : public SafeMessage {
public:
std::string_view get_type_name() const override { return "client_cap_release";}
void print(ostream& out) const override {
static constexpr int COMPAT_VERSION = 1;
MClientCapRelease() :
- Message{CEPH_MSG_CLIENT_CAPRELEASE, HEAD_VERSION, COMPAT_VERSION}
+ SafeMessage{CEPH_MSG_CLIENT_CAPRELEASE, HEAD_VERSION, COMPAT_VERSION}
{
memset(&head, 0, sizeof(head));
}
#include "mds/mdstypes.h"
#include "include/ceph_features.h"
-class MClientCaps : public Message {
+class MClientCaps : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 11;
protected:
MClientCaps()
- : Message{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION} {}
+ : SafeMessage{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION} {}
MClientCaps(int op,
inodeno_t ino,
inodeno_t realm,
int dirty,
int mseq,
epoch_t oeb)
- : Message{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION},
+ : SafeMessage{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION},
osd_epoch_barrier(oeb) {
memset(&head, 0, sizeof(head));
head.op = op;
MClientCaps(int op,
inodeno_t ino, inodeno_t realm,
uint64_t id, int mseq, epoch_t oeb)
- : Message{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION},
+ : SafeMessage{CEPH_MSG_CLIENT_CAPS, HEAD_VERSION, COMPAT_VERSION},
osd_epoch_barrier(oeb) {
memset(&head, 0, sizeof(head));
head.op = op;
#include "msg/Message.h"
-class MClientLease : public Message {
+class MClientLease : public SafeMessage {
public:
struct ceph_mds_lease h;
std::string dname;
snapid_t get_last() const { return snapid_t(h.last); }
protected:
- MClientLease() : Message(CEPH_MSG_CLIENT_LEASE) {}
+ MClientLease() : SafeMessage(CEPH_MSG_CLIENT_LEASE) {}
MClientLease(const MClientLease& m) :
- Message(CEPH_MSG_CLIENT_LEASE),
+ SafeMessage(CEPH_MSG_CLIENT_LEASE),
h(m.h),
dname(m.dname) {}
MClientLease(int ac, ceph_seq_t seq, int m, uint64_t i, uint64_t sf, uint64_t sl) :
- Message(CEPH_MSG_CLIENT_LEASE) {
+ SafeMessage(CEPH_MSG_CLIENT_LEASE) {
h.action = ac;
h.seq = seq;
h.mask = m;
h.duration_ms = 0;
}
MClientLease(int ac, ceph_seq_t seq, int m, uint64_t i, uint64_t sf, uint64_t sl, std::string_view d) :
- Message(CEPH_MSG_CLIENT_LEASE),
+ SafeMessage(CEPH_MSG_CLIENT_LEASE),
dname(d) {
h.action = ac;
h.seq = seq;
#include "msg/Message.h"
-class MClientQuota : public Message {
+class MClientQuota : public SafeMessage {
public:
inodeno_t ino;
nest_info_t rstat;
protected:
MClientQuota() :
- Message{CEPH_MSG_CLIENT_QUOTA},
+ SafeMessage{CEPH_MSG_CLIENT_QUOTA},
ino(0)
{}
~MClientQuota() override {}
#include "msg/Message.h"
-class MClientReclaim: public Message {
+class MClientReclaim: public SafeMessage {
public:
static constexpr int HEAD_VERSION = 1;
static constexpr int COMPAT_VERSION = 1;
protected:
MClientReclaim() :
- Message{CEPH_MSG_CLIENT_RECLAIM, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{CEPH_MSG_CLIENT_RECLAIM, HEAD_VERSION, COMPAT_VERSION} {}
MClientReclaim(std::string_view _uuid, uint32_t _flags) :
- Message{CEPH_MSG_CLIENT_RECLAIM, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{CEPH_MSG_CLIENT_RECLAIM, HEAD_VERSION, COMPAT_VERSION},
uuid(_uuid), flags(_flags) {}
private:
~MClientReclaim() override {}
#include "msg/Message.h"
-class MClientReclaimReply: public Message {
+class MClientReclaimReply: public SafeMessage {
public:
static constexpr int HEAD_VERSION = 1;
static constexpr int COMPAT_VERSION = 1;
MClientReclaimReply{0, 0}
{}
MClientReclaimReply(int r, epoch_t e=0) :
- Message{CEPH_MSG_CLIENT_RECLAIM_REPLY, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{CEPH_MSG_CLIENT_RECLAIM_REPLY, HEAD_VERSION, COMPAT_VERSION},
result(r), epoch(e) {}
private:
#include "include/ceph_features.h"
-class MClientReconnect : public Message {
+class MClientReconnect : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 5;
static constexpr int COMPAT_VERSION = 4;
private:
MClientReconnect() :
- Message{CEPH_MSG_CLIENT_RECONNECT, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{CEPH_MSG_CLIENT_RECONNECT, HEAD_VERSION, COMPAT_VERSION} {}
~MClientReconnect() override {}
size_t cap_size = 0;
};
-class MClientReply : public Message {
+class MClientReply : public SafeMessage {
public:
// reply data
struct ceph_mds_reply_head head {};
bool is_safe() const { return head.safe; }
protected:
- MClientReply() : Message{CEPH_MSG_CLIENT_REPLY} {}
+ MClientReply() : SafeMessage{CEPH_MSG_CLIENT_REPLY} {}
MClientReply(const MClientRequest &req, int result = 0) :
- Message{CEPH_MSG_CLIENT_REPLY} {
+ SafeMessage{CEPH_MSG_CLIENT_REPLY} {
memset(&head, 0, sizeof(head));
header.tid = req.get_tid();
head.op = req.get_op();
// metadata ops.
-class MClientRequest : public Message {
+class MClientRequest : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 4;
static constexpr int COMPAT_VERSION = 1;
protected:
// cons
MClientRequest()
- : Message(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {}
+ : SafeMessage(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {}
MClientRequest(int op)
- : Message(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {
+ : SafeMessage(CEPH_MSG_CLIENT_REQUEST, HEAD_VERSION, COMPAT_VERSION) {
memset(&head, 0, sizeof(head));
head.op = op;
}
#include "msg/Message.h"
-class MClientRequestForward : public Message {
+class MClientRequestForward : public SafeMessage {
private:
int32_t dest_mds;
int32_t num_fwd;
protected:
MClientRequestForward()
- : Message{CEPH_MSG_CLIENT_REQUEST_FORWARD},
+ : SafeMessage{CEPH_MSG_CLIENT_REQUEST_FORWARD},
dest_mds(-1), num_fwd(-1), client_must_resend(false) {}
MClientRequestForward(ceph_tid_t t, int dm, int nf, bool cmr) :
- Message{CEPH_MSG_CLIENT_REQUEST_FORWARD},
+ SafeMessage{CEPH_MSG_CLIENT_REQUEST_FORWARD},
dest_mds(dm), num_fwd(nf), client_must_resend(cmr) {
ceph_assert(client_must_resend);
header.tid = t;
#include "msg/Message.h"
#include "mds/mdstypes.h"
-class MClientSession : public Message {
+class MClientSession : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 3;
static constexpr int COMPAT_VERSION = 1;
int get_max_leases() const { return head.max_leases; }
protected:
- MClientSession() : Message{CEPH_MSG_CLIENT_SESSION, HEAD_VERSION, COMPAT_VERSION} { }
+ MClientSession() : SafeMessage{CEPH_MSG_CLIENT_SESSION, HEAD_VERSION, COMPAT_VERSION} { }
MClientSession(int o, version_t s=0) :
- Message{CEPH_MSG_CLIENT_SESSION, HEAD_VERSION, COMPAT_VERSION} {
+ SafeMessage{CEPH_MSG_CLIENT_SESSION, HEAD_VERSION, COMPAT_VERSION} {
memset(&head, 0, sizeof(head));
head.op = o;
head.seq = s;
}
MClientSession(int o, utime_t st) :
- Message{CEPH_MSG_CLIENT_SESSION, HEAD_VERSION, COMPAT_VERSION} {
+ SafeMessage{CEPH_MSG_CLIENT_SESSION, HEAD_VERSION, COMPAT_VERSION} {
memset(&head, 0, sizeof(head));
head.op = o;
head.seq = 0;
#include "msg/Message.h"
-class MClientSnap : public Message {
+class MClientSnap : public SafeMessage {
public:
ceph_mds_snap_head head;
bufferlist bl;
protected:
MClientSnap(int o=0) :
- Message{CEPH_MSG_CLIENT_SNAP} {
+ SafeMessage{CEPH_MSG_CLIENT_SNAP} {
memset(&head, 0, sizeof(head));
head.op = o;
}
#include "msg/Message.h"
-class MDentryLink : public Message {
+class MDentryLink : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MDentryLink() :
- Message(MSG_MDS_DENTRYLINK, HEAD_VERSION, COMPAT_VERSION) { }
+ SafeMessage(MSG_MDS_DENTRYLINK, HEAD_VERSION, COMPAT_VERSION) { }
MDentryLink(dirfrag_t r, dirfrag_t df, std::string_view n, bool p) :
- Message(MSG_MDS_DENTRYLINK, HEAD_VERSION, COMPAT_VERSION),
+ SafeMessage(MSG_MDS_DENTRYLINK, HEAD_VERSION, COMPAT_VERSION),
subtree(r),
dirfrag(df),
dn(n),
#include "msg/Message.h"
-class MDentryUnlink : public Message {
+class MDentryUnlink : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MDentryUnlink() :
- Message(MSG_MDS_DENTRYUNLINK, HEAD_VERSION, COMPAT_VERSION) { }
+ SafeMessage(MSG_MDS_DENTRYUNLINK, HEAD_VERSION, COMPAT_VERSION) { }
MDentryUnlink(dirfrag_t df, std::string_view n) :
- Message(MSG_MDS_DENTRYUNLINK, HEAD_VERSION, COMPAT_VERSION),
+ SafeMessage(MSG_MDS_DENTRYUNLINK, HEAD_VERSION, COMPAT_VERSION),
dirfrag(df),
dn(n) {}
~MDentryUnlink() override {}
#include "msg/Message.h"
-class MDirUpdate : public Message {
+class MDirUpdate : public SafeMessage {
public:
mds_rank_t get_source_mds() const { return from_mds; }
dirfrag_t get_dirfrag() const { return dirfrag; }
protected:
~MDirUpdate() {}
- MDirUpdate() : Message(MSG_MDS_DIRUPDATE, HEAD_VERSION, COMPAT_VERSION) {}
+ MDirUpdate() : SafeMessage(MSG_MDS_DIRUPDATE, HEAD_VERSION, COMPAT_VERSION) {}
MDirUpdate(mds_rank_t f,
dirfrag_t dirfrag,
int dir_rep,
const std::set<int32_t>& dir_rep_by,
filepath& path,
bool discover = false) :
- Message(MSG_MDS_DIRUPDATE, HEAD_VERSION, COMPAT_VERSION), from_mds(f), dirfrag(dirfrag),
+ SafeMessage(MSG_MDS_DIRUPDATE, HEAD_VERSION, COMPAT_VERSION), from_mds(f), dirfrag(dirfrag),
dir_rep(dir_rep), dir_rep_by(dir_rep_by), path(path) {
this->discover = discover ? 5 : 0;
}
MDirUpdate(const MDirUpdate& m)
- : Message{MSG_MDS_DIRUPDATE},
+ : SafeMessage{MSG_MDS_DIRUPDATE},
from_mds(m.from_mds),
dirfrag(m.dirfrag),
dir_rep(m.dir_rep),
#include <string>
-class MDiscover : public Message {
+class MDiscover : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 1;
static constexpr int COMPAT_VERSION = 1;
void set_base_dir_frag(frag_t f) { base_dir_frag = f; }
protected:
- MDiscover() : Message(MSG_MDS_DISCOVER, HEAD_VERSION, COMPAT_VERSION) { }
+ MDiscover() : SafeMessage(MSG_MDS_DISCOVER, HEAD_VERSION, COMPAT_VERSION) { }
MDiscover(inodeno_t base_ino_,
frag_t base_frag_,
snapid_t s,
filepath& want_path_,
bool want_base_dir_ = true,
bool discover_xlocks_ = false) :
- Message{MSG_MDS_DISCOVER},
+ SafeMessage{MSG_MDS_DISCOVER},
base_ino(base_ino_),
base_dir_frag(base_frag_),
snapid(s),
*
*/
-class MDiscoverReply : public Message {
+class MDiscoverReply : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 2;
static constexpr int COMPAT_VERSION = 2;
void set_base_dir_frag(frag_t df) { base_dir_frag = df; }
protected:
- MDiscoverReply() : Message{MSG_MDS_DISCOVERREPLY, HEAD_VERSION, COMPAT_VERSION} { }
+ MDiscoverReply() : SafeMessage{MSG_MDS_DISCOVERREPLY, HEAD_VERSION, COMPAT_VERSION} { }
MDiscoverReply(const MDiscover &dis) :
- Message{MSG_MDS_DISCOVERREPLY, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_DISCOVERREPLY, HEAD_VERSION, COMPAT_VERSION},
base_ino(dis.get_base_ino()),
base_dir_frag(dis.get_base_dir_frag()),
wanted_base_dir(dis.wants_base_dir()),
header.tid = dis.get_tid();
}
MDiscoverReply(dirfrag_t df) :
- Message{MSG_MDS_DISCOVERREPLY, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_DISCOVERREPLY, HEAD_VERSION, COMPAT_VERSION},
base_ino(df.ino),
base_dir_frag(df.frag),
wanted_base_dir(false),
#include "msg/Message.h"
-class MExportCaps : public Message {
+class MExportCaps : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 2;
static constexpr int COMPAT_VERSION = 1;
protected:
MExportCaps() :
- Message{MSG_MDS_EXPORTCAPS, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{MSG_MDS_EXPORTCAPS, HEAD_VERSION, COMPAT_VERSION} {}
~MExportCaps() override {}
public:
#include "msg/Message.h"
-class MExportCapsAck : public Message {
+class MExportCapsAck : public SafeMessage {
static constexpr int HEAD_VERSION = 1;
static constexpr int COMPAT_VERSION = 1;
protected:
MExportCapsAck() :
- Message{MSG_MDS_EXPORTCAPSACK, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{MSG_MDS_EXPORTCAPSACK, HEAD_VERSION, COMPAT_VERSION} {}
MExportCapsAck(inodeno_t i) :
- Message{MSG_MDS_EXPORTCAPSACK, HEAD_VERSION, COMPAT_VERSION}, ino(i) {}
+ SafeMessage{MSG_MDS_EXPORTCAPSACK, HEAD_VERSION, COMPAT_VERSION}, ino(i) {}
~MExportCapsAck() override {}
public:
#include "msg/Message.h"
-class MExportDir : public Message {
+class MExportDir : public SafeMessage {
public:
dirfrag_t dirfrag;
bufferlist export_data;
bufferlist client_map;
protected:
- MExportDir() : Message{MSG_MDS_EXPORTDIR} {}
+ MExportDir() : SafeMessage{MSG_MDS_EXPORTDIR} {}
MExportDir(dirfrag_t df, uint64_t tid) :
- Message{MSG_MDS_EXPORTDIR}, dirfrag(df) {
+ SafeMessage{MSG_MDS_EXPORTDIR}, dirfrag(df) {
set_tid(tid);
}
~MExportDir() override {}
#include "MExportDir.h"
#include "msg/Message.h"
-class MExportDirAck : public Message {
+class MExportDirAck : public SafeMessage {
public:
dirfrag_t dirfrag;
bufferlist imported_caps;
dirfrag_t get_dirfrag() const { return dirfrag; }
protected:
- MExportDirAck() : Message{MSG_MDS_EXPORTDIRACK} {}
+ MExportDirAck() : SafeMessage{MSG_MDS_EXPORTDIRACK} {}
MExportDirAck(dirfrag_t df, uint64_t tid) :
- Message{MSG_MDS_EXPORTDIRACK}, dirfrag(df) {
+ SafeMessage{MSG_MDS_EXPORTDIRACK}, dirfrag(df) {
set_tid(tid);
}
~MExportDirAck() override {}
#include "msg/Message.h"
#include "include/types.h"
-class MExportDirCancel : public Message {
+class MExportDirCancel : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
dirfrag_t get_dirfrag() const { return dirfrag; }
protected:
- MExportDirCancel() : Message{MSG_MDS_EXPORTDIRCANCEL, HEAD_VERSION, COMPAT_VERSION} {}
+ MExportDirCancel() : SafeMessage{MSG_MDS_EXPORTDIRCANCEL, HEAD_VERSION, COMPAT_VERSION} {}
MExportDirCancel(dirfrag_t df, uint64_t tid) :
- Message{MSG_MDS_EXPORTDIRCANCEL, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df) {
+ SafeMessage{MSG_MDS_EXPORTDIRCANCEL, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df) {
set_tid(tid);
}
~MExportDirCancel() override {}
#include "msg/Message.h"
#include "include/types.h"
-class MExportDirDiscover : public Message {
+class MExportDirDiscover : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MExportDirDiscover() :
- Message{MSG_MDS_EXPORTDIRDISCOVER, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_EXPORTDIRDISCOVER, HEAD_VERSION, COMPAT_VERSION},
started(false) { }
MExportDirDiscover(dirfrag_t df, filepath& p, mds_rank_t f, uint64_t tid) :
- Message{MSG_MDS_EXPORTDIRDISCOVER, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_EXPORTDIRDISCOVER, HEAD_VERSION, COMPAT_VERSION},
from(f), dirfrag(df), path(p), started(false) {
set_tid(tid);
}
#include "msg/Message.h"
#include "include/types.h"
-class MExportDirDiscoverAck : public Message {
+class MExportDirDiscoverAck : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
bool is_success() const { return success; }
protected:
- MExportDirDiscoverAck() : Message{MSG_MDS_EXPORTDIRDISCOVERACK, HEAD_VERSION, COMPAT_VERSION} {}
+ MExportDirDiscoverAck() : SafeMessage{MSG_MDS_EXPORTDIRDISCOVERACK, HEAD_VERSION, COMPAT_VERSION} {}
MExportDirDiscoverAck(dirfrag_t df, uint64_t tid, bool s=true) :
- Message{MSG_MDS_EXPORTDIRDISCOVERACK, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_EXPORTDIRDISCOVERACK, HEAD_VERSION, COMPAT_VERSION},
dirfrag(df), success(s) {
set_tid(tid);
}
#include "msg/Message.h"
-class MExportDirFinish : public Message {
+class MExportDirFinish : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MExportDirFinish() :
- Message{MSG_MDS_EXPORTDIRFINISH, HEAD_VERSION, COMPAT_VERSION}, last(false) {}
+ SafeMessage{MSG_MDS_EXPORTDIRFINISH, HEAD_VERSION, COMPAT_VERSION}, last(false) {}
MExportDirFinish(dirfrag_t df, bool l, uint64_t tid) :
- Message{MSG_MDS_EXPORTDIRFINISH, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), last(l) {
+ SafeMessage{MSG_MDS_EXPORTDIRFINISH, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), last(l) {
set_tid(tid);
}
~MExportDirFinish() override {}
#include "msg/Message.h"
-class MExportDirNotify : public Message {
+class MExportDirNotify : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MExportDirNotify() :
- Message{MSG_MDS_EXPORTDIRNOTIFY, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{MSG_MDS_EXPORTDIRNOTIFY, HEAD_VERSION, COMPAT_VERSION} {}
MExportDirNotify(dirfrag_t i, uint64_t tid, bool a, pair<__s32,__s32> oa, pair<__s32,__s32> na) :
- Message{MSG_MDS_EXPORTDIRNOTIFY, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_EXPORTDIRNOTIFY, HEAD_VERSION, COMPAT_VERSION},
base(i), ack(a), old_auth(oa), new_auth(na) {
set_tid(tid);
}
#include "msg/Message.h"
-class MExportDirNotifyAck : public Message {
+class MExportDirNotifyAck : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MExportDirNotifyAck() :
- Message{MSG_MDS_EXPORTDIRNOTIFYACK, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{MSG_MDS_EXPORTDIRNOTIFYACK, HEAD_VERSION, COMPAT_VERSION} {}
MExportDirNotifyAck(dirfrag_t df, uint64_t tid, pair<__s32,__s32> na) :
- Message{MSG_MDS_EXPORTDIRNOTIFYACK, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), new_auth(na) {
+ SafeMessage{MSG_MDS_EXPORTDIRNOTIFYACK, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), new_auth(na) {
set_tid(tid);
}
~MExportDirNotifyAck() override {}
#include "msg/Message.h"
#include "include/types.h"
-class MExportDirPrep : public Message {
+class MExportDirPrep : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MExportDirPrep() = default;
MExportDirPrep(dirfrag_t df, uint64_t tid) :
- Message{MSG_MDS_EXPORTDIRPREP, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_EXPORTDIRPREP, HEAD_VERSION, COMPAT_VERSION},
dirfrag(df)
{
set_tid(tid);
#include "msg/Message.h"
#include "include/types.h"
-class MExportDirPrepAck : public Message {
+class MExportDirPrepAck : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
protected:
MExportDirPrepAck() :
- Message{MSG_MDS_EXPORTDIRPREPACK, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{MSG_MDS_EXPORTDIRPREPACK, HEAD_VERSION, COMPAT_VERSION} {}
MExportDirPrepAck(dirfrag_t df, bool s, uint64_t tid) :
- Message{MSG_MDS_EXPORTDIRPREPACK, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), success(s) {
+ SafeMessage{MSG_MDS_EXPORTDIRPREPACK, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), success(s) {
set_tid(tid);
}
~MExportDirPrepAck() override {}
#include "msg/Message.h"
-class MInodeFileCaps : public Message {
+class MInodeFileCaps : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 1;
static constexpr int COMPAT_VERSION = 1;
int get_caps() const { return caps; }
protected:
- MInodeFileCaps() : Message(MSG_MDS_INODEFILECAPS, HEAD_VERSION, COMPAT_VERSION) {}
+ MInodeFileCaps() : SafeMessage(MSG_MDS_INODEFILECAPS, HEAD_VERSION, COMPAT_VERSION) {}
MInodeFileCaps(inodeno_t ino, int caps) :
- Message(MSG_MDS_INODEFILECAPS, HEAD_VERSION, COMPAT_VERSION) {
+ SafeMessage(MSG_MDS_INODEFILECAPS, HEAD_VERSION, COMPAT_VERSION) {
this->ino = ino;
this->caps = caps;
}
#include "mds/locks.h"
#include "mds/SimpleLock.h"
-class MLock : public Message {
+class MLock : public SafeMessage {
private:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
MDSCacheObjectInfo &get_object_info() { return object_info; }
protected:
- MLock() : Message{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION} {}
+ MLock() : SafeMessage{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION} {}
MLock(int ac, mds_rank_t as) :
- Message{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION},
action(ac), asker(as),
lock_type(0) { }
MLock(SimpleLock *lock, int ac, mds_rank_t as) :
- Message{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION},
action(ac), asker(as),
lock_type(lock->get_type()) {
lock->get_parent()->set_object_info(object_info);
}
MLock(SimpleLock *lock, int ac, mds_rank_t as, bufferlist& bl) :
- Message{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_LOCK, HEAD_VERSION, COMPAT_VERSION},
action(ac), asker(as), lock_type(lock->get_type()) {
lock->get_parent()->set_object_info(object_info);
lockdata.claim(bl);
// sent from replica to auth
-class MMDSCacheRejoin : public Message {
+class MMDSCacheRejoin : public SafeMessage {
public:
static constexpr int OP_WEAK = 1; // replica -> auth, i exist, + maybe open files.
static constexpr int OP_STRONG = 2; // replica -> auth, i exist, + open files and lock state.
static constexpr int COMPAT_VERSION = 1;
MMDSCacheRejoin(int o) : MMDSCacheRejoin() { op = o; }
- MMDSCacheRejoin() : Message{MSG_MDS_CACHEREJOIN, HEAD_VERSION, COMPAT_VERSION} {}
+ MMDSCacheRejoin() : SafeMessage{MSG_MDS_CACHEREJOIN, HEAD_VERSION, COMPAT_VERSION} {}
~MMDSCacheRejoin() override {}
};
#include "msg/Message.h"
#include "include/filepath.h"
-class MMDSFindIno : public Message {
+class MMDSFindIno : public SafeMessage {
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
public:
inodeno_t ino;
protected:
- MMDSFindIno() : Message{MSG_MDS_FINDINO, HEAD_VERSION, COMPAT_VERSION} {}
- MMDSFindIno(ceph_tid_t t, inodeno_t i) : Message{MSG_MDS_FINDINO, HEAD_VERSION, COMPAT_VERSION}, tid(t), ino(i) {}
+ MMDSFindIno() : SafeMessage{MSG_MDS_FINDINO, HEAD_VERSION, COMPAT_VERSION} {}
+ MMDSFindIno(ceph_tid_t t, inodeno_t i) : SafeMessage{MSG_MDS_FINDINO, HEAD_VERSION, COMPAT_VERSION}, tid(t), ino(i) {}
~MMDSFindIno() override {}
public:
#include "msg/Message.h"
#include "include/filepath.h"
-class MMDSFindInoReply : public Message {
+class MMDSFindInoReply : public SafeMessage {
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
public:
filepath path;
protected:
- MMDSFindInoReply() : Message{MSG_MDS_FINDINOREPLY, HEAD_VERSION, COMPAT_VERSION} {}
- MMDSFindInoReply(ceph_tid_t t) : Message{MSG_MDS_FINDINOREPLY, HEAD_VERSION, COMPAT_VERSION}, tid(t) {}
+ MMDSFindInoReply() : SafeMessage{MSG_MDS_FINDINOREPLY, HEAD_VERSION, COMPAT_VERSION} {}
+ MMDSFindInoReply(ceph_tid_t t) : SafeMessage{MSG_MDS_FINDINOREPLY, HEAD_VERSION, COMPAT_VERSION}, tid(t) {}
~MMDSFindInoReply() override {}
public:
#include "msg/Message.h"
-class MMDSFragmentNotify : public Message {
+class MMDSFragmentNotify : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 2;
static constexpr int COMPAT_VERSION = 1;
protected:
MMDSFragmentNotify() :
- Message{MSG_MDS_FRAGMENTNOTIFY, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{MSG_MDS_FRAGMENTNOTIFY, HEAD_VERSION, COMPAT_VERSION} {}
MMDSFragmentNotify(dirfrag_t df, int b, uint64_t tid) :
- Message{MSG_MDS_FRAGMENTNOTIFY, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_FRAGMENTNOTIFY, HEAD_VERSION, COMPAT_VERSION},
base_dirfrag(df), bits(b) {
set_tid(tid);
}
#include "msg/Message.h"
-class MMDSFragmentNotifyAck : public Message {
+class MMDSFragmentNotifyAck : public SafeMessage {
private:
dirfrag_t base_dirfrag;
int8_t bits = 0;
bufferlist basebl;
protected:
- MMDSFragmentNotifyAck() : Message{MSG_MDS_FRAGMENTNOTIFYACK} {}
+ MMDSFragmentNotifyAck() : SafeMessage{MSG_MDS_FRAGMENTNOTIFYACK} {}
MMDSFragmentNotifyAck(dirfrag_t df, int b, uint64_t tid) :
- Message{MSG_MDS_FRAGMENTNOTIFYACK},
+ SafeMessage{MSG_MDS_FRAGMENTNOTIFYACK},
base_dirfrag(df), bits(b) {
set_tid(tid);
}
#include "mds/MDSMap.h"
#include "include/ceph_features.h"
-class MMDSMap : public Message {
+class MMDSMap : public SafeMessage {
private:
static constexpr int HEAD_VERSION = 1;
static constexpr int COMPAT_VERSION = 1;
protected:
MMDSMap() :
- Message{CEPH_MSG_MDS_MAP, HEAD_VERSION, COMPAT_VERSION} {}
+ SafeMessage{CEPH_MSG_MDS_MAP, HEAD_VERSION, COMPAT_VERSION} {}
MMDSMap(const uuid_d &f, const MDSMap &mm) :
- Message{CEPH_MSG_MDS_MAP, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{CEPH_MSG_MDS_MAP, HEAD_VERSION, COMPAT_VERSION},
fsid(f) {
epoch = mm.get_epoch();
mm.encode(encoded, -1); // we will reencode with fewer features as necessary
#include "msg/Message.h"
-class MMDSOpenIno : public Message {
+class MMDSOpenIno : public SafeMessage {
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
public:
vector<inode_backpointer_t> ancestors;
protected:
- MMDSOpenIno() : Message{MSG_MDS_OPENINO, HEAD_VERSION, COMPAT_VERSION} {}
+ MMDSOpenIno() : SafeMessage{MSG_MDS_OPENINO, HEAD_VERSION, COMPAT_VERSION} {}
MMDSOpenIno(ceph_tid_t t, inodeno_t i, vector<inode_backpointer_t>* pa) :
- Message{MSG_MDS_OPENINO, HEAD_VERSION, COMPAT_VERSION}, ino(i) {
+ SafeMessage{MSG_MDS_OPENINO, HEAD_VERSION, COMPAT_VERSION}, ino(i) {
header.tid = t;
if (pa)
ancestors = *pa;
#include "msg/Message.h"
-class MMDSOpenInoReply : public Message {
+class MMDSOpenInoReply : public SafeMessage {
public:
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
int32_t error;
protected:
- MMDSOpenInoReply() : Message{MSG_MDS_OPENINOREPLY, HEAD_VERSION, COMPAT_VERSION}, error(0) {}
+ MMDSOpenInoReply() : SafeMessage{MSG_MDS_OPENINOREPLY, HEAD_VERSION, COMPAT_VERSION}, error(0) {}
MMDSOpenInoReply(ceph_tid_t t, inodeno_t i, mds_rank_t h=MDS_RANK_NONE, int e=0) :
- Message{MSG_MDS_OPENINOREPLY, HEAD_VERSION, COMPAT_VERSION}, ino(i), hint(h), error(e) {
+ SafeMessage{MSG_MDS_OPENINOREPLY, HEAD_VERSION, COMPAT_VERSION}, ino(i), hint(h), error(e) {
header.tid = t;
}
#include "mds/Capability.h"
-class MMDSResolve : public Message {
+class MMDSResolve : public SafeMessage {
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
list<table_client> table_clients;
protected:
- MMDSResolve() : Message{MSG_MDS_RESOLVE, HEAD_VERSION, COMPAT_VERSION}
+ MMDSResolve() : SafeMessage{MSG_MDS_RESOLVE, HEAD_VERSION, COMPAT_VERSION}
{}
~MMDSResolve() override {}
#include "include/types.h"
-class MMDSResolveAck : public Message {
+class MMDSResolveAck : public SafeMessage {
static const int HEAD_VERSION = 1;
static const int COMPAT_VERSION = 1;
public:
vector<metareqid_t> abort;
protected:
- MMDSResolveAck() : Message{MSG_MDS_RESOLVEACK, HEAD_VERSION, COMPAT_VERSION} {}
+ MMDSResolveAck() : SafeMessage{MSG_MDS_RESOLVEACK, HEAD_VERSION, COMPAT_VERSION} {}
~MMDSResolveAck() override {}
public:
#include "msg/Message.h"
#include "mds/mdstypes.h"
-class MMDSSlaveRequest : public Message {
+class MMDSSlaveRequest : public SafeMessage {
static constexpr int HEAD_VERSION = 1;
static constexpr int COMPAT_VERSION = 1;
public:
bufferlist& get_lock_data() { return inode_export; }
protected:
- MMDSSlaveRequest() : Message{MSG_MDS_SLAVE_REQUEST, HEAD_VERSION, COMPAT_VERSION} { }
+ MMDSSlaveRequest() : SafeMessage{MSG_MDS_SLAVE_REQUEST, HEAD_VERSION, COMPAT_VERSION} { }
MMDSSlaveRequest(metareqid_t ri, __u32 att, int o) :
- Message{MSG_MDS_SLAVE_REQUEST, HEAD_VERSION, COMPAT_VERSION},
+ SafeMessage{MSG_MDS_SLAVE_REQUEST, HEAD_VERSION, COMPAT_VERSION},
reqid(ri), attempt(att), op(o), flags(0), lock_type(0),
inode_export_v(0), srcdn_auth(MDS_RANK_NONE) { }
~MMDSSlaveRequest() override {}
#include "msg/Message.h"
-class MMDSSnapUpdate : public Message {
+class MMDSSnapUpdate : public SafeMessage {
private:
inodeno_t ino;
__s16 snap_op;
bufferlist snap_blob;
protected:
- MMDSSnapUpdate() : Message{MSG_MDS_SNAPUPDATE} {}
+ MMDSSnapUpdate() : SafeMessage{MSG_MDS_SNAPUPDATE} {}
MMDSSnapUpdate(inodeno_t i, version_t tid, int op) :
- Message{MSG_MDS_SNAPUPDATE}, ino(i), snap_op(op) {
+ SafeMessage{MSG_MDS_SNAPUPDATE}, ino(i), snap_op(op) {
set_tid(tid);
}
~MMDSSnapUpdate() override {}
#include "msg/Message.h"
#include "mds/mds_table_types.h"
-class MMDSTableRequest : public Message {
+class MMDSTableRequest : public SafeMessage {
public:
__u16 table = 0;
__s16 op = 0;
bufferlist bl;
protected:
- MMDSTableRequest() : Message{MSG_MDS_TABLE_REQUEST} {}
+ MMDSTableRequest() : SafeMessage{MSG_MDS_TABLE_REQUEST} {}
MMDSTableRequest(int tab, int o, uint64_t r, version_t v=0) :
- Message{MSG_MDS_TABLE_REQUEST},
+ SafeMessage{MSG_MDS_TABLE_REQUEST},
table(tab), op(o), reqid(r) {
set_tid(v);
}